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()); }
public static void TestHandleCollector() { Tuple<int, int, int> intialGcState = new Tuple<int, int, int>( GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2)); HandleCollector lowLimitCollector = new HandleCollector("LowLimit.Collector", LowLimitSize); for (int i = 0; i < LowLimitSize + 1; ++i) { HandleLimitTester hlt = new HandleLimitTester(lowLimitCollector); } Tuple<int, int, int> postLowLimitState = new Tuple<int, int, int>( GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2)); Assert.True(intialGcState.Item1 + intialGcState.Item2 + intialGcState.Item3 < postLowLimitState.Item1 + postLowLimitState.Item2 + postLowLimitState.Item3, "Low limit handle did not trigger a GC"); HandleCollector highLimitCollector = new HandleCollector("HighLimit.Collector", HighLimitSize); for (int i = 0; i < HighLimitSize + 10; ++i) { HandleLimitTester hlt = new HandleLimitTester(highLimitCollector); } Tuple<int, int, int> postHighLimitState = new Tuple<int, int, int>( GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2)); Assert.True(postLowLimitState.Item1 + postLowLimitState.Item2 + postLowLimitState.Item3 < postHighLimitState.Item1 + postHighLimitState.Item2 + postHighLimitState.Item3, "High limit handle did not trigger a GC"); }
public void Ctor_Name_InitialThreshold(string name, int initialThreshold) { var handleCollector = new HandleCollector(name, initialThreshold); Assert.Equal(0, handleCollector.Count); Assert.Equal(name ?? string.Empty, handleCollector.Name); Assert.Equal(initialThreshold, handleCollector.InitialThreshold); Assert.Equal(int.MaxValue, handleCollector.MaximumThreshold); }
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 SimplePropertyValidation() { string name = "ExampleName"; int initial = 10; int max = 20; HandleCollector collector = new HandleCollector(name, initial, max); Assert.Equal(0, collector.Count); Assert.Equal(name, collector.Name); Assert.Equal(initial, collector.InitialThreshold); Assert.Equal(max, collector.MaximumThreshold); }
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); }
public static void TestHandleCollector() { (int gen0, int gen1, int gen2)initialGcState = (GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2)); int initSum = initialGcState.gen0 + initialGcState.gen1 + initialGcState.gen2; HandleCollector lowLimitCollector = new HandleCollector("LowLimit.Collector", LowLimitSize); for (int i = 0; i < LowLimitSize + 1; ++i) { HandleLimitTester hlt = new HandleLimitTester(lowLimitCollector); Assert.True(lowLimitCollector.Count <= i + 1); } // HandleLimitTester does the decrement on the HandleCollector during finalization, so we wait for pending finalizers. GC.WaitForPendingFinalizers(); (int gen0, int gen1, int gen2)postLowLimitState = (GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2)); int postLowLimitSum = postLowLimitState.gen0 + postLowLimitState.gen1 + postLowLimitState.gen2; Assert.True(initSum < postLowLimitSum, $"Low limit handle did not trigger a GC: {initSum} < {postLowLimitSum}"); HandleCollector highLimitCollector = new HandleCollector("HighLimit.Collector", HighLimitSize); for (int i = 0; i < HighLimitSize + 10; ++i) { HandleLimitTester hlt = new HandleLimitTester(highLimitCollector); Assert.True(highLimitCollector.Count <= i + 1); } // HandleLimitTester does the decrement on the HandleCollector during finalization, so we wait for pending finalizers. GC.WaitForPendingFinalizers(); (int gen0, int gen1, int gen2)postHighLimitState = (GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2)); int postHighLimitSum = postHighLimitState.gen0 + postHighLimitState.gen1 + postHighLimitState.gen2; Assert.True(postLowLimitSum < postHighLimitSum, $"High limit handle did not trigger a GC: {postLowLimitSum} < {postHighLimitSum}"); }
public static void EmptyRemoval() { HandleCollector collector = new HandleCollector("EmptyRemoval", 10); Assert.Throws <InvalidOperationException>(() => collector.Remove()); }
public static void NullNameCtor() { HandleCollector collector = new HandleCollector(null, 0, 0); Assert.Equal(string.Empty, collector.Name); }
internal HandleLimitTester(HandleCollector collector) { _collector = collector; _collector.Add(); GC.KeepAlive(this); }
public static void EmptyRemoval() { HandleCollector collector = new HandleCollector("EmptyRemoval", 10); Assert.Throws<InvalidOperationException>(() => collector.Remove()); }
internal HandleLimitTester(HandleCollector collector) { _collector = collector; // Adding an allocation to ensure memory pressure exists so the call to // GC.Collect() in the Add() method below will have something to do. _pressure = new int[1_000];