public FakeCounterFixture(int input, int output)
 {
     m_dio = new DioCrossConnectFixture(input, output);
     m_allocated = true;
     m_source = new FakeCounterSource(m_dio.GetOutput());
     m_counter = new Counter(m_dio.GetInput());
 }

 public virtual string Print(Counter counter)
 {
     _counter = counter;
     if (TryPrintFizzBuzz() || TryPrintBuzz())
         return _returnValue;
     return PrintFizz();
 }

        public async Task<StreamSubscriptionHandle<int>> BecomeConsumer(Guid streamId, string streamNamespace, string providerToUse)
        {
            logger.Info("BecomeConsumer");

            // new counter for this subscription
            var count = new Counter();
            var error = new Counter();

            // get stream
            IStreamProvider streamProvider = GetStreamProvider(providerToUse);
            var stream = streamProvider.GetStream<int>(streamId, streamNamespace);

            int countCapture = consumerCount;
            consumerCount++;
            // subscribe
            StreamSubscriptionHandle<int> handle = await stream.SubscribeAsync(
                (e, t) => OnNext(e, t, countCapture, count),
                e => OnError(e, countCapture, error));

            // track counter
            consumedMessageCounts.Add(handle, Tuple.Create(count,error));

            // return handle
            return handle;
        }

        static void Main(string[] args)
        {
            int pairs = args.Count() == 0 ? 16 : Int32.Parse(args[0]);
            int msgs = args.Count() == 2 ? Int32.Parse(args[1]) : 10;
            int sleepForMax = 20;

            var counters = new Counter[pairs];

            InitCounters(pairs, counters, msgs);

            int sleepFor = sleepForMax;
            while (sleepFor > 0)
            {
                Console.WriteLine("Sleeping for "+sleepFor+" seconds whilst it warms up");
                Thread.Sleep(1000);
                sleepFor--;
            }

            Console.WriteLine("Warm up sent "+ SumCounters(pairs,counters) + " messages. Running for real now...");
            ResetCounters(pairs, counters);

            Thread.Sleep(1000 * sleepForMax);

            shutdownAll();

            var sum = SumCounters(pairs, counters);

            Console.WriteLine("" + sum + " messages sent in "+ sleepForMax + " seconds.");

            decimal sps = ((decimal)sum) / ((decimal)sleepForMax);

            Console.WriteLine("That's " + sps + " messages per second");

            Console.ReadKey();
        }

 protected DbConnectionPoolCounters(string categoryName, string categoryHelp)
 {
     AppDomain.CurrentDomain.DomainUnload += new EventHandler(this.UnloadEventHandler);
     AppDomain.CurrentDomain.ProcessExit += new EventHandler(this.ExitEventHandler);
     AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(this.ExceptionEventHandler);
     string instanceName = null;
     if (!System.Data.Common.ADP.IsEmpty(categoryName) && System.Data.Common.ADP.IsPlatformNT5)
     {
         instanceName = this.GetInstanceName();
     }
     string str2 = categoryName;
     this.HardConnectsPerSecond = new Counter(str2, instanceName, CreationData.HardConnectsPerSecond.CounterName, CreationData.HardConnectsPerSecond.CounterType);
     this.HardDisconnectsPerSecond = new Counter(str2, instanceName, CreationData.HardDisconnectsPerSecond.CounterName, CreationData.HardDisconnectsPerSecond.CounterType);
     this.NumberOfNonPooledConnections = new Counter(str2, instanceName, CreationData.NumberOfNonPooledConnections.CounterName, CreationData.NumberOfNonPooledConnections.CounterType);
     this.NumberOfPooledConnections = new Counter(str2, instanceName, CreationData.NumberOfPooledConnections.CounterName, CreationData.NumberOfPooledConnections.CounterType);
     this.NumberOfActiveConnectionPoolGroups = new Counter(str2, instanceName, CreationData.NumberOfActiveConnectionPoolGroups.CounterName, CreationData.NumberOfActiveConnectionPoolGroups.CounterType);
     this.NumberOfInactiveConnectionPoolGroups = new Counter(str2, instanceName, CreationData.NumberOfInactiveConnectionPoolGroups.CounterName, CreationData.NumberOfInactiveConnectionPoolGroups.CounterType);
     this.NumberOfActiveConnectionPools = new Counter(str2, instanceName, CreationData.NumberOfActiveConnectionPools.CounterName, CreationData.NumberOfActiveConnectionPools.CounterType);
     this.NumberOfInactiveConnectionPools = new Counter(str2, instanceName, CreationData.NumberOfInactiveConnectionPools.CounterName, CreationData.NumberOfInactiveConnectionPools.CounterType);
     this.NumberOfStasisConnections = new Counter(str2, instanceName, CreationData.NumberOfStasisConnections.CounterName, CreationData.NumberOfStasisConnections.CounterType);
     this.NumberOfReclaimedConnections = new Counter(str2, instanceName, CreationData.NumberOfReclaimedConnections.CounterName, CreationData.NumberOfReclaimedConnections.CounterType);
     string str3 = null;
     if (!System.Data.Common.ADP.IsEmpty(categoryName))
     {
         TraceSwitch switch2 = new TraceSwitch("ConnectionPoolPerformanceCounterDetail", "level of detail to track with connection pool performance counters");
         if (TraceLevel.Verbose == switch2.Level)
         {
             str3 = categoryName;
         }
     }
     this.SoftConnectsPerSecond = new Counter(str3, instanceName, CreationData.SoftConnectsPerSecond.CounterName, CreationData.SoftConnectsPerSecond.CounterType);
     this.SoftDisconnectsPerSecond = new Counter(str3, instanceName, CreationData.SoftDisconnectsPerSecond.CounterName, CreationData.SoftDisconnectsPerSecond.CounterType);
     this.NumberOfActiveConnections = new Counter(str3, instanceName, CreationData.NumberOfActiveConnections.CounterName, CreationData.NumberOfActiveConnections.CounterType);
     this.NumberOfFreeConnections = new Counter(str3, instanceName, CreationData.NumberOfFreeConnections.CounterName, CreationData.NumberOfFreeConnections.CounterType);
 }

 private Counter CreateCounter()
 {
     Counter counter = new Counter();
     counter.Id = 1;
     counter.Name = "Foo";
     return counter;
 }

        public static AreaType ReadAreaType(XmlReader reader, Counter<string> badTags)
        {
            string type = null;
            int level = 0;
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "type")
                {
                    type = reader.ReadElementContentAsString();
                }
                else if (reader.NodeType == XmlNodeType.Element && reader.Name == "level")
                {
                    level = reader.ReadElementContentAsInt();
                }
                else if (reader.NodeType == XmlNodeType.Element)
                {
                    badTags.Increment(reader.Name);
                }
                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "area")
                {
                    break;
                }
            }

            if (level == 0 || type == null)
                throw new Exception("Area type or level not specified.");
            return new AreaType(level, type);
        }

 public FakeCounterFixture(int input, int output)
 {
     this.dio = new DIOCrossConnectFixture(input, output);
     m_allocated = true;
     source = new FakeCounterSource(dio.GetOutput());
     counter = new Counter(dio.GetInput());
 }

        public void SetUp(BenchmarkContext context)
        {
            _counter = context.GetCounter(CounterName);

            if (ConfigurationManager.AppSettings["TestKey"] != "42")
                throw new InvalidOperationException("TestKey from AppSettings could not be loaded!");
        }

        public async Task<StreamSubscriptionHandle<int>> BecomeConsumer(Guid streamId, string streamNamespace, string providerToUse)
        {
            logger.Info("BecomeConsumer");

            // new counter for this subscription
            var count = new Counter();

            // get stream
            IStreamProvider streamProvider = GetStreamProvider(providerToUse);
            var stream = streamProvider.GetStream<int>(streamId, streamNamespace);

            // subscribe
            StreamSubscriptionHandle<int> handle = await stream.SubscribeAsync(
                (e, t) =>
                {
                    logger.Info("Got next event {0}", e);
                    count.Increment();
                    return TaskDone.Done;
                });

            // track counter
            consumedMessageCounts.Add(handle, count);

            // return handle
            return handle;
        }

        public override string Print(Counter counter)
        {
            if (_counter == counter)
                return _expected;

            throw new InvalidOperationException();
        }

        static void Main(string[] args)
        {
            try {
            var face = new Face("aleph.ndn.ucla.edu");

            var counter = new Counter();

            // Try to fetch anything.
            var name1 = new Name("/");
            Console.Out.WriteLine("Express name " + name1.toUri());
            face.expressInterest(name1, counter, counter);

            // Try to fetch using a known name.
            var name2 = new Name("/ndn/edu/ucla/remap/demo/ndn-js-test/hello.txt/%FDU%8D%9DM");
            Console.Out.WriteLine("Express name " + name2.toUri());
            face.expressInterest(name2, counter, counter);

            // Expect this to time out.
            var name3 = new Name("/test/timeout");
            Console.Out.WriteLine("Express name " + name3.toUri());
            face.expressInterest(name3, counter, counter);

            // The main event loop.
            while (counter.callbackCount_ < 3) {
              face.processEvents();
              // We need to sleep for a few milliseconds so we don't use 100% of the CPU.
              System.Threading.Thread.Sleep(5);
            }
              } catch (Exception e) {
            Console.Out.WriteLine("exception: " + e.Message);
              }
        }

    static void Main(string[] args)
    {
        Counter c = new Counter();
        c.ThresholdReached += c_ThresholdReached;

        // Provide remaining implementation for the class
    }

 protected override void SetupClient()
 {
     this.sendArgsPool = PrimitiveObjectPool.Create(100, CreateSendAsyncEventArgs);
     this.sentBytesCount = new Counter(MessageSize * MessageCount);
     this.clientSocket = new Socket(EndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
     this.clientSocket.Connect(EndPoint);
 }

        public async Task DeactivationTest_ClientConsumer(Guid streamGuid, string streamNamespace)
        {
            // get producer and consumer
            var producer = GrainClient.GrainFactory.GetGrain<ISampleStreaming_ProducerGrain>(Guid.NewGuid());

            var count = new Counter();
            // get stream and subscribe
            IStreamProvider streamProvider = GrainClient.GetStreamProvider(streamProviderName);
            var stream = streamProvider.GetStream<int>(streamGuid, streamNamespace);
            StreamSubscriptionHandle<int> subscriptionHandle = await stream.SubscribeAsync((e, t) => count.Increment());

            // produce one message (PubSubRendezvousGrain will have one consumer and one producer)
            await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
            await producer.Produce();

            Assert.AreEqual(count.Value, 1, "Client consumer grain has not received stream message");

            //TODO: trigger deactivation programmatically
            await Task.Delay(TimeSpan.FromMilliseconds(130000)); // wait for the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain to be deactivated

            // deactivating PubSubRendezvousGrain and SampleStreaming_ProducerGrain during the same GC cycle causes a deadlock
            // resume producing after the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain grains have been deactivated:
            await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName).WithTimeout(Timeout, "BecomeProducer is hung due to deactivation deadlock");
            await producer.Produce().WithTimeout(Timeout, "Produce is hung due to deactivation deadlock");

            Assert.AreEqual(count.Value, 2, "Client consumer grain did not receive stream messages after PubSubRendezvousGrain and SampleStreaming_ProducerGrain reactivation");
        }

 public void TestCounterInit1()
 {
     using (Counter ctr = new Counter())
     {
         TestInit(0, 0, 0, false, false, false, false);
     }
 }

		public void ForBreak ()
		{
			var counter = new Counter ();

			var c = Expression.Parameter (typeof (Counter), "c");
			var l = Expression.Parameter (typeof (int), "l");

			var i = Expression.Variable (typeof (int), "i");
			var for_break = Expression.Label ("for_break");

			var hitcounter = Expression.Lambda<Action<Counter, int>> (
				CustomExpression.For (
					i,
					Expression.Constant (0),
					Expression.LessThan (i, l),
					Expression.PreIncrementAssign (i),
					Expression.Block (
						Expression.Condition (
							Expression.LessThan (i, Expression.Constant (10)),
							Expression.Call (c, typeof (Counter).GetMethod ("Hit", Type.EmptyTypes)),
							Expression.Goto (for_break))),
					for_break),
				c, l).Compile ();

			hitcounter (counter, 100);

			Assert.AreEqual (10, counter.Count);
		}

 public Counter Add(string name, string notes, out int counterId)
 {
     var counter = new Counter(name, notes);
     counterId = _counters.Count;
     _counters.Add(counter);
     return counter;
 }

 private void CreateSut()
 {
     _counterMock = MockRepository.GenerateStrictMock<Counter>();
     _fizzPredicateMock = MockRepository.GenerateStrictMock<FizzPredicate>();
     _buzzPredicateMock = MockRepository.GenerateStrictMock<BuzzPredicate>();
     _sut = new FizzBuzzPrinter(_fizzPredicateMock, _buzzPredicateMock);
 }

        public async Task<StreamSubscriptionHandle<int>> BecomeConsumer(Guid streamId, string streamNamespace, string providerToUse)
        {
            logger.Info("BecomeConsumer");

            // new counter for this subscription
            var count = new Counter();

            // get stream
            IStreamProvider streamProvider = GetStreamProvider(providerToUse);
            var stream = streamProvider.GetStream<int>(streamId, streamNamespace);

            // subscribe
            StreamSubscriptionHandle<int> handle = await stream.SubscribeAsync(
                (e, t) =>
                {
                    logger.Info("Got next event {0}", e);
                    string contextValue = RequestContext.Get(SampleStreaming_ProducerGrain.RequestContextKey) as string;
                    if (!String.Equals(contextValue, SampleStreaming_ProducerGrain.RequestContextValue))
                    {
                        throw new Exception(String.Format("Got the wrong RequestContext value {0}.", contextValue));
                    }
                    count.Increment();
                    return TaskDone.Done;
                });

            // track counter
            consumedMessageCounts.Add(handle, count);

            // return handle
            return handle;
        }