Add() private méthode

private Add ( ) : void
Résultat void
Exemple #1
0
        public static void CountOverflow()
        {
            HandleCollector collector = new HandleCollector("CountOverflow", int.MaxValue);

            // We could iterate here 2B times calling Add, but that often takes over 100s
            // Instead, for testing purposes, we reach into the HandleCollector via reflection
            // to make it think it's already been called int.MaxValue - 10 times.  We then
            // only have to call Add 10 times rather than int.MaxValue times, and the test
            // completes very quickly.  If we ever need to run the test on a platform that
            // doesn't support such reflection, we can revert to the super-long running test
            // or find another workaround.

            const int ToAdd = 10; // int.MaxValue

            {
                // Jump HandleCollector instance forward until it almost overflows
                TypeInfo  type        = typeof(HandleCollector).GetTypeInfo();
                FieldInfo handleCount =
                    type.GetDeclaredField("_handleCount") ?? // corefx
                    type.GetDeclaredField("handleCount");    // desktop
                Assert.NotNull(handleCount);
                handleCount.SetValue(collector, int.MaxValue - ToAdd);
            }

            for (int i = 0; i < ToAdd; i++)
            {
                collector.Add();
            }

            Assert.Throws <InvalidOperationException>(() => collector.Add());
        }
        public static void CountOverflow()
        {
            HandleCollector collector = new HandleCollector("CountOverflow", int.MaxValue);
            for (int i = 0; i < Int32.MaxValue; i++)
            {
                collector.Add();
            }

            Assert.Throws<InvalidOperationException>(() => collector.Add());
        }
        public static void CountOverflow()
        {
            HandleCollector collector = new HandleCollector("CountOverflow", int.MaxValue);

            for (int i = 0; i < Int32.MaxValue; i++)
            {
                collector.Add();
            }

            Assert.Throws <InvalidOperationException>(() => collector.Add());
        }
        public static void CountOverflow()
        {
            HandleCollector collector = new HandleCollector("CountOverflow", int.MaxValue);

            // We could iterate here 2B times calling Add, but that often takes over 100s
            // Instead, for testing purposes, we reach into the HandleCollector via reflection
            // to make it think it's already been called int.MaxValue - 10 times.  We then
            // only have to call Add 10 times rather than int.MaxValue times, and the test
            // completes very quickly.  If we ever need to run the test on a platform that
            // doesn't support such reflection, we can revert to the super-long running test
            // or find another workaround.

            const int ToAdd = 10; // int.MaxValue
            {
                // Jump HandleCollector instance forward until it almost overflows
                FieldInfo handleCount = typeof(HandleCollector).GetTypeInfo().GetDeclaredField("_handleCount");
                Assert.NotNull(handleCount);
                handleCount.SetValue(collector, int.MaxValue - ToAdd);
            }

            for (int i = 0; i < ToAdd; i++)
            {
                collector.Add();
            }

            Assert.Throws<InvalidOperationException>(() => collector.Add());
        }
Exemple #5
0
        public void AddRemove_AcrossMultipleGenerations_Success()
        {
            var collector = new HandleCollector("name", 0);

            collector.Add();
            Assert.Equal(1, collector.Count);

            collector.Add();
            Assert.Equal(2, collector.Count);

            collector.Add();
            Assert.Equal(3, collector.Count);

            collector.Remove();
            Assert.Equal(2, collector.Count);

            collector.Remove();
            Assert.Equal(1, collector.Count);

            collector.Remove();
            Assert.Equal(0, collector.Count);
        }
 internal HandleLimitTester(HandleCollector collector)
 {
     _collector = collector;
     _collector.Add();
     GC.KeepAlive(this);
 }
 internal HandleLimitTester(HandleCollector collector)
 {
     _collector = collector;
     _collector.Add();
     GC.KeepAlive(this);
 }