Add Unit Tests for GC and strings

Author: josesimoes

Tests/NFUnitTestGC/TestGCWithStringArrays.cs

@@ -0,0 +1,119 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// Portions Copyright (c) Microsoft Corporation.  All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+using nanoFramework.TestFramework;
+using System;
+
+namespace NFUnitTestGC
+{
+    [TestClass]
+    public class TestGCWithStringArrays
+    {
+        [TestMethod]
+        public void TestCompactionForNotFixedStringArray()
+        {
+            OutputHelper.WriteLine("Starting TestCompactionForNotFixedStringArray");
+
+            for (int loop = 0; loop < 10; loop++)
+            {
+                OutputHelper.WriteLine($"Starting iteration {loop}");
+
+                // First we create objects and holes that keeps some space that could be used by compaction
+
+                for (int loop = 0; loop < 10; loop++)
+                {
+                    OutputHelper.WriteLine($"Starting iteration {loop}");
+
+                    // First we create objects and holes that keeps some space that could be used by compaction.
+                    // Small count so compaction does not happen. 
+                    HolderForString[] arrayOfStrings = new HolderForString[10];
+                    RunStringAllocations(arrayOfStrings);
+
+                    // This is the array that we expect to move in during compaction.
+                    HolderForString[] testNativeBuffer = new HolderForString[100];
+                    // Fill it, so it is not optimized out
+                    for (int i = 0; i < testNativeBuffer.Length; i++)
+                    {
+                        testNativeBuffer[i] = new HolderForString(Guid.NewGuid().ToString());
+                    }
+
+                    OutputHelper.WriteLine("Large HolderForString array created");
+                    OutputHelper.WriteLine("Forcing compaction to occurr");
+
+                    // Causes compaction
+                    InitiateTimeSpanCompaction();
+
+                    OutputHelper.WriteLine("Compaction occurred");
+                    OutputHelper.WriteLine("Checking arrays for corrupted data...");
+
+                    int index = 0;
+
+                    // Check that array content is not corrupted
+                    foreach (HolderForString holder in testNativeBuffer)
+                    {
+                        Assert.AreEqual(
+                            holder.StringHash,
+                            holder.StringContent.GetHashCode(),
+                            $"Array content comparison failed at position {index}. Expecting {holder.StringHash}, found {holder.StringContent.GetHashCode()}");
+                        index++;
+                    }
+
+                    OutputHelper.WriteLine("No corruption detected in array");
+                }
+
+                OutputHelper.WriteLine("Completed TestCompactionForNotFixedArray");
+            }
+        }
+
+        private TimeSpan GetRandomTimeSpan()
+        {
+            Random rand = new();
+
+            return TimeSpan.FromTicks(rand.Next() * 1000_000);
+        }
+
+        // This function cause compaction to occur.
+        // It is not so trivial as it need to fragment heap with referenced objects.      
+        void InitiateTimeSpanCompaction()
+        {
+            // Large count, so compaction happens during RunAllocations.
+            HolderForTimeSpan[] arrayOfArrays = new HolderForTimeSpan[500];
+            RunTimeSpanAllocations(arrayOfArrays);
+        }
+
+        private void RunTimeSpanAllocations(HolderForTimeSpan[] arrObj)
+        {
+
+            for (int i = 1; i < arrObj.Length; i++)
+            {
+                // Creates referenced object, which stays in memory until InitiateCompaction exits
+                arrObj[i] = new HolderForTimeSpan(GetRandomTimeSpan());
+
+                // Tries to create larger object that would be later hole
+                // This object could be garbage collected on each "i" cycle
+                HolderForTimeSpan[] arr = new HolderForTimeSpan[50 * i];
+
+                // Creates some usage for array elements, so it is not optimized out
+                arr[0] = new HolderForTimeSpan(TimeSpan.MinValue);
+                arr[1] = new HolderForTimeSpan(TimeSpan.MaxValue);
+
+                Console.WriteLine($"On Cycle {i:D3} DateTime holder allocated");
+            }
+        }
+
+        private class HolderForString
+        {
+            public int StringHash { get; }
+            public string StringContent { get; }
+
+            public HolderForString(string value)
+            {
+                StringContent = value;
+                StringHash = value.GetHashCode();
+            }
+        }
+    }
+}