public void TestMoq()
        {
            Mock <AverageTimer32PerformanceCounter>          averageTimer32PerformanceCounterMock;
            Mock <NumberOfItems64PerformanceCounter>         numberofItems64PerformanceCounterMock;
            Mock <PercentageRatePerformanceCounter>          percentageRatePerformanceCounterMock;
            Mock <RatePerSecond32PerformanceCounter>         ratePerSecond32PerformanceCounterMock;
            Mock <ISingleInstancePerformanceCounterCategory> singleInstancePerformanceCounterCategoryMock;
            const string counterName = "counterName";

            averageTimer32PerformanceCounterMock = new Mock <AverageTimer32PerformanceCounter>();
            averageTimer32PerformanceCounterMock.Setup(pc => pc.AddTiming(It.IsAny <Stopwatch>()));
            averageTimer32PerformanceCounterMock.Setup(pc => pc.Dispose());

            numberofItems64PerformanceCounterMock = new Mock <NumberOfItems64PerformanceCounter>();
            numberofItems64PerformanceCounterMock.Setup(pc => pc.Increment());
            numberofItems64PerformanceCounterMock.Setup(pc => pc.IncrementBy(It.IsAny <long>()));
            numberofItems64PerformanceCounterMock.Setup(pc => pc.Dispose());

            percentageRatePerformanceCounterMock = new Mock <PercentageRatePerformanceCounter>();
            percentageRatePerformanceCounterMock.Setup(pc => pc.AddHit());
            percentageRatePerformanceCounterMock.Setup(pc => pc.AddMiss());
            percentageRatePerformanceCounterMock.Setup(pc => pc.Dispose());

            ratePerSecond32PerformanceCounterMock = new Mock <RatePerSecond32PerformanceCounter>();
            ratePerSecond32PerformanceCounterMock.Setup(pc => pc.Increment());
            ratePerSecond32PerformanceCounterMock.Setup(pc => pc.Dispose());

            singleInstancePerformanceCounterCategoryMock = new Mock <ISingleInstancePerformanceCounterCategory>();
            singleInstancePerformanceCounterCategoryMock.Setup(
                pcc => pcc.GetPerformanceCounter <AverageTimer32PerformanceCounter>(It.IsAny <string>()))
            .Returns(() => averageTimer32PerformanceCounterMock.Object);
            singleInstancePerformanceCounterCategoryMock.Setup(
                pcc => pcc.GetPerformanceCounter <NumberOfItems64PerformanceCounter>(It.IsAny <string>()))
            .Returns(() => numberofItems64PerformanceCounterMock.Object);
            singleInstancePerformanceCounterCategoryMock.Setup(
                pcc => pcc.GetPerformanceCounter <PercentageRatePerformanceCounter>(It.IsAny <string>()))
            .Returns(() => percentageRatePerformanceCounterMock.Object);
            singleInstancePerformanceCounterCategoryMock.Setup(
                pcc => pcc.GetPerformanceCounter <RatePerSecond32PerformanceCounter>(It.IsAny <string>()))
            .Returns(() => ratePerSecond32PerformanceCounterMock.Object);
            singleInstancePerformanceCounterCategoryMock.Setup(pcc => pcc.Dispose());

            using (ISingleInstancePerformanceCounterCategory singleInstancePerformanceCounterCategory =
                       singleInstancePerformanceCounterCategoryMock.Object)
            {
                singleInstancePerformanceCounterCategory.GetPerformanceCounter <AverageTimer32PerformanceCounter>(
                    counterName).AddTiming(new Stopwatch());
                singleInstancePerformanceCounterCategory.GetPerformanceCounter <NumberOfItems64PerformanceCounter>(
                    counterName).Increment();
                singleInstancePerformanceCounterCategory.GetPerformanceCounter <NumberOfItems64PerformanceCounter>(
                    counterName).IncrementBy(0);
                singleInstancePerformanceCounterCategory.GetPerformanceCounter <PercentageRatePerformanceCounter>(
                    counterName).AddHit();
                singleInstancePerformanceCounterCategory.GetPerformanceCounter <PercentageRatePerformanceCounter>(
                    counterName).AddMiss();
                singleInstancePerformanceCounterCategory.GetPerformanceCounter <RatePerSecond32PerformanceCounter>(
                    counterName).Increment();
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Private constructor to start the counter.
        /// </summary>
        private PerformanceCounters(string categoryName, string countName, string rateName, string durationName)
        {
            _durationName = durationName;

            _perfCounters = Categories.GetOrAdd(categoryName, name =>
                                                new SingleInstancePerformanceCounterCategory(name));

            _perfCounters.GetPerformanceCounter <RatePerSecond32PerformanceCounter>(rateName).Increment();
            _perfCounters.GetPerformanceCounter <NumberOfItems64PerformanceCounter>(countName).Increment();
            _stopWatch = new Stopwatch();
            _stopWatch.Start();
        }
        /// <summary>
        /// Create a new <see cref="CounterEntityAccessControlChecker"/>.
        /// </summary>
        /// <param name="checker">
        /// The <see cref="IEntityAccessControlChecker"/> to actually perform the check. This cannot be null.
        /// </param>
        /// <param name="accessControlCounters">
        /// The <see cref="ISingleInstancePerformanceCounterCategory"/> used to update/set access control performance counters.
        /// </param>
        /// <param name="accessControlPermissionCounters">
        /// The <see cref="IMultiInstancePerformanceCounterCategory"/> used to update/set access control permission performance counters.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// No argument can be null.
        /// </exception>
        internal CounterEntityAccessControlChecker(
            IEntityAccessControlChecker checker,
            ISingleInstancePerformanceCounterCategory accessControlCounters,
            IMultiInstancePerformanceCounterCategory accessControlPermissionCounters)
        {
            if (checker == null)
            {
                throw new ArgumentNullException("checker");
            }
            if (accessControlCounters == null)
            {
                throw new ArgumentNullException("accessControlCounters");
            }
            if (accessControlPermissionCounters == null)
            {
                throw new ArgumentNullException("accessControlPermissionCounters");
            }

            Checker = checker;
            AccessControlCounters           = accessControlCounters;
            AccessControlPermissionCounters = accessControlPermissionCounters;
        }