Migrate 210 tests to UnitTests.Parallelizable, add CreateFakeDriver helper, prove View.Draw() works in parallel tests, and provide comprehensive performance analysis (#4297)

* Initial plan * Migrate Category A test files to UnitTests.Parallelizable (135 tests) Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add 11 ButtonTests to Parallelizable, remove from UnitTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add comprehensive test migration report Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add comprehensive performance analysis of UnitTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Migrate 2 Autocomplete tests and add Text tests analysis Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add proof-of-concept: TextFormatter.Draw works in parallel tests with local driver Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add CreateFakeDriver helper to ParallelizableBase and migrate 4 TextFormatterTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Remove proof-of-concept test from AutocompleteTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Move Scheme-accessing tests back to UnitTests to fix intermittent failures Co-authored-by: tig <585482+tig@users.noreply.github.com> * Update parallel tests README to document ConfigurationManager/SchemeManager restrictions Co-authored-by: tig <585482+tig@users.noreply.github.com> * Document static member restriction in parallel tests README Co-authored-by: tig <585482+tig@users.noreply.github.com> * Restore accidentally deleted ButtonTests.Accept_Cancel_Event_OnAccept_Returns_True test Co-authored-by: tig <585482+tig@users.noreply.github.com> * Migrate Accept_Cancel_Event_OnAccept_Returns_True test to Parallelizable Co-authored-by: tig <585482+tig@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: tig <585482+tig@users.noreply.github.com>
2025-12-26 15:57:56 +01:00 · 2025-10-20 08:56:11 -06:00
parent ed64f5773e
commit 041e9de70e
25 changed files with 1561 additions and 348 deletions
--- a/Tests/UnitTestsParallelizable/Configuration/MemorySizeEstimator.cs
+++ b/Tests/UnitTestsParallelizable/Configuration/MemorySizeEstimator.cs
@@ -0,0 +1,253 @@
+#nullable enable
+
+namespace Terminal.Gui.ConfigurationTests;
+
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class MemorySizeEstimator
+{
+    public static long EstimateSize<T> (T? source)
+    {
+        if (source is null)
+        {
+            return 0;
+        }
+
+        ConcurrentDictionary<object, long> visited = new (ReferenceEqualityComparer.Instance);
+        return EstimateSizeInternal (source, visited);
+    }
+
+    private const int POINTER_SIZE = 8; // 64-bit system
+    private const int OBJECT_HEADER_SIZE = 16; // 2 pointers for GC
+
+    private static long EstimateSizeInternal (object? source, ConcurrentDictionary<object, long> visited)
+    {
+        if (source is null)
+        {
+            return 0;
+        }
+
+        // Handle already visited objects to avoid circular references
+        if (visited.TryGetValue (source, out long existingSize))
+        {
+            // // Log revisited object (enable for debugging)
+            // Console.WriteLine($"Revisited {source.GetType().FullName}: {existingSize} bytes");
+            return existingSize;
+        }
+
+        Type type = source.GetType ();
+        long size = 0;
+
+        // Handle simple types
+        if (IsSimpleType (type))
+        {
+            size = EstimateSimpleTypeSize (source, type);
+            visited.TryAdd (source, size);
+            // // Log simple type (enable for debugging)
+            // Console.WriteLine($"{type.FullName}: {size} bytes");
+            return size;
+        }
+
+        // Handle arrays
+        if (type.IsArray)
+        {
+            size = EstimateArraySize (source, visited);
+        }
+        // Handle dictionaries
+        else if (source is IDictionary)
+        {
+            size = EstimateDictionarySize (source, visited);
+        }
+        // Handle collections
+        else if (typeof (ICollection).IsAssignableFrom (type))
+        {
+            size = EstimateCollectionSize (source, visited);
+        }
+        // Handle structs and classes
+        else
+        {
+            size = EstimateObjectSize (source, type, visited);
+        }
+
+        visited.TryAdd (source, size);
+        // // Log object size (enable for debugging)
+        // if (size == 0)
+        // {
+        //     Console.WriteLine($"Zero size for {type.FullName}");
+        // }
+        // else
+        // {
+        //     Console.WriteLine($"{type.FullName}: {size} bytes");
+        // }
+
+        return size;
+    }
+
+    private static bool IsSimpleType (Type type)
+    {
+        if (type.IsPrimitive
+            || type.IsEnum
+            || type == typeof (decimal)
+            || type == typeof (DateTime)
+            || type == typeof (DateTimeOffset)
+            || type == typeof (TimeSpan)
+            || type == typeof (Guid)
+            || type == typeof (Rune)
+            || type == typeof (string))
+        {
+            return true;
+        }
+
+        // Treat structs with no writable public properties as simple types
+        if (type.IsValueType)
+        {
+            PropertyInfo [] writableProperties = type.GetProperties (BindingFlags.Instance | BindingFlags.Public)
+                .Where (p => p is { CanRead: true, CanWrite: true } && p.GetIndexParameters ().Length == 0)
+                .ToArray ();
+            return writableProperties.Length == 0;
+        }
+
+        // Treat Property翰Info as simple (metadata, not cloned)
+        if (typeof (PropertyInfo).IsAssignableFrom (type))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    private static long EstimateSimpleTypeSize (object source, Type type)
+    {
+        if (type == typeof (string))
+        {
+            string str = (string)source;
+            // Header + length (4) + char array ref + chars (2 bytes each)
+            return OBJECT_HEADER_SIZE + 4 + POINTER_SIZE + (str.Length * 2);
+        }
+
+        try
+        {
+            return Marshal.SizeOf (type);
+        }
+        catch (ArgumentException)
+        {
+            // Fallback for enums or other simple types
+            return 4; // Conservative estimate
+        }
+    }
+
+    private static long EstimateArraySize (object source, ConcurrentDictionary<object, long> visited)
+    {
+        Array array = (Array)source;
+        long size = OBJECT_HEADER_SIZE + 4 + POINTER_SIZE; // Header + length + padding
+
+        foreach (object? element in array)
+        {
+            size += EstimateSizeInternal (element, visited);
+        }
+
+        return size;
+    }
+
+    private static long EstimateDictionarySize (object source, ConcurrentDictionary<object, long> visited)
+    {
+        IDictionary dict = (IDictionary)source;
+        long size = OBJECT_HEADER_SIZE + (POINTER_SIZE * 5); // Header + buckets, entries, comparer, fields
+        size += dict.Count * 4; // Bucket array (~4 bytes per entry)
+        size += dict.Count * (4 + 4 + POINTER_SIZE * 2); // Entry array: hashcode, next, key, value
+
+        foreach (object? key in dict.Keys)
+        {
+            size += EstimateSizeInternal (key, visited);
+            size += EstimateSizeInternal (dict [key], visited);
+        }
+
+        return size;
+    }
+
+    private static long EstimateCollectionSize (object source, ConcurrentDictionary<object, long> visited)
+    {
+        Type type = source.GetType ();
+        long size = OBJECT_HEADER_SIZE + (POINTER_SIZE * 3); // Header + internal array + fields
+
+        if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof (Dictionary<,>))
+        {
+            return EstimateDictionarySize (source, visited);
+        }
+
+        if (source is IEnumerable enumerable)
+        {
+            foreach (object? item in enumerable)
+            {
+                size += EstimateSizeInternal (item, visited);
+            }
+        }
+
+        return size;
+    }
+
+    private static long EstimateObjectSize (object source, Type type, ConcurrentDictionary<object, long> visited)
+    {
+        long size = OBJECT_HEADER_SIZE;
+
+        // Size public writable properties
+        foreach (PropertyInfo prop in type.GetProperties (BindingFlags.Instance | BindingFlags.Public)
+            .Where (p => p is { CanRead: true, CanWrite: true } && p.GetIndexParameters ().Length == 0))
+        {
+            try
+            {
+                object? value = prop.GetValue (source);
+                size += EstimateSizeInternal (value, visited);
+            }
+            catch (Exception)
+            {
+                // // Log exception (enable for debugging)
+                // Console.WriteLine($"Error processing property {prop.Name} of {type.FullName}: {ex.Message}");
+                // Continue to avoid crashing
+            }
+        }
+
+        // For structs, also size fields (to handle generic structs)
+        if (type.IsValueType)
+        {
+            FieldInfo [] fields = type.GetFields (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            foreach (FieldInfo field in fields)
+            {
+                try
+                {
+                    object? fieldValue = field.GetValue (source);
+                    size += EstimateSizeInternal (fieldValue, visited);
+                }
+                catch (Exception)
+                {
+                    // // Log exception (enable for debugging)
+                    // Console.WriteLine($"Error processing field {field.Name} of {type.FullName}: {ex.Message}");
+                    // Continue to avoid crashing
+                }
+            }
+        }
+
+        return size;
+    }
+
+    private sealed class ReferenceEqualityComparer : IEqualityComparer<object>
+    {
+        public static ReferenceEqualityComparer Instance { get; } = new ();
+
+        public new bool Equals (object? x, object? y)
+        {
+            return ReferenceEquals (x, y);
+        }
+
+        public int GetHashCode (object obj)
+        {
+            return RuntimeHelpers.GetHashCode (obj);
+        }
+    }
+}
--- a/Tests/UnitTestsParallelizable/Configuration/ThemeManagerTests.cs
+++ b/Tests/UnitTestsParallelizable/Configuration/ThemeManagerTests.cs
@@ -0,0 +1,290 @@
+#nullable enable
+using System.Collections.Concurrent;
+using System.Diagnostics.Metrics;
+using System.Text;
+using Xunit.Abstractions;
+using static Terminal.Gui.Configuration.ConfigurationManager;
+
+namespace Terminal.Gui.ConfigurationTests;
+
+public class ThemeManagerTests (ITestOutputHelper output)
+{
+    [Fact]
+    public void ResetToCurrentValues_Adds_Default_Theme ()
+    {
+        try
+        {
+            Enable (ConfigLocations.HardCoded);
+            Assert.NotEmpty (ThemeManager.Themes!);
+
+            ThemeManager.UpdateToCurrentValues ();
+
+            Assert.NotEmpty (ThemeManager.Themes!);
+
+            // Default theme exists
+            Assert.NotNull (ThemeManager.Themes? [ThemeManager.DEFAULT_THEME_NAME]);
+        }
+        finally
+        {
+            Disable (resetToHardCodedDefaults: true);
+        }
+    }
+
+    // ResetToCurrentValues
+
+    //    OnThemeChanged
+
+    #region Tests Settings["Theme"] and ThemeManager.Theme
+
+    [Fact]
+    public void Theme_Settings_Theme_Equals_ThemeManager_Theme ()
+    {
+        Assert.False (IsEnabled);
+
+        Assert.Equal (Settings! ["Theme"].PropertyValue, ThemeManager.Theme);
+        Assert.Equal (ThemeManager.DEFAULT_THEME_NAME, ThemeManager.Theme);
+    }
+
+    [Fact]
+    public void Theme_Enabled_Settings_Theme_Equals_ThemeManager_Theme ()
+    {
+        Assert.False (IsEnabled);
+
+        Enable (ConfigLocations.HardCoded);
+
+        Assert.Equal (Settings! ["Theme"].PropertyValue, ThemeManager.Theme);
+        Assert.Equal (ThemeManager.DEFAULT_THEME_NAME, ThemeManager.Theme);
+
+        Disable (resetToHardCodedDefaults: true);
+    }
+
+    [Fact]
+    public void Theme_Set_Sets ()
+    {
+        Assert.False (IsEnabled);
+
+        Enable (ConfigLocations.HardCoded);
+
+        Assert.Equal (ThemeManager.DEFAULT_THEME_NAME, ThemeManager.Theme);
+
+        ThemeManager.Theme = "Test";
+        Assert.Equal ("Test", ThemeManager.Theme);
+        Assert.Equal (Settings! ["Theme"].PropertyValue, ThemeManager.Theme);
+        Assert.Equal ("Test", Settings! ["Theme"].PropertyValue);
+
+        Disable (resetToHardCodedDefaults: true);
+    }
+
+    [Fact]
+    public void Theme_ResetToHardCodedDefaults_Sets_To_Default ()
+    {
+        try
+        {
+            Assert.False (IsEnabled);
+            Assert.Equal (ThemeManager.DEFAULT_THEME_NAME, ThemeManager.Theme);
+
+            Enable (ConfigLocations.HardCoded);
+            Assert.Equal ("Default", ThemeManager.Theme);
+
+            ThemeManager.Theme = "Test";
+            Assert.Equal ("Test", ThemeManager.Theme);
+            Assert.Equal (Settings! ["Theme"].PropertyValue, ThemeManager.Theme);
+            Assert.Equal ("Test", Settings! ["Theme"].PropertyValue);
+
+            ResetToHardCodedDefaults ();
+            Assert.Equal ("Default", ThemeManager.Theme);
+        }
+        finally
+        {
+            Disable(true);
+        }
+    }
+
+    #endregion Tests Settings["Theme"] and ThemeManager.Theme
+
+    #region Tests Settings["Themes"] and ThemeManager.Themes
+
+    [Fact]
+    public void Themes_Set_Throws_If_Not_Enabled ()
+    {
+        Assert.False (IsEnabled);
+
+        Assert.Single (ThemeManager.Themes!);
+        Assert.Throws<InvalidOperationException> (() => ThemeManager.Themes = new ());
+        Assert.Single (ThemeManager.Themes!);
+    }
+
+    [Fact]
+    public void Themes_Set_Sets_If_Enabled ()
+    {
+        Assert.False (IsEnabled);
+
+        Enable (ConfigLocations.HardCoded);
+
+        Assert.Single (ThemeManager.Themes!);
+
+        // Use ConcurrentDictionary instead of a regular dictionary
+        ThemeManager.Themes = new ConcurrentDictionary<string, ThemeScope> (
+                                                                            new Dictionary<string, ThemeScope>
+                                                                            {
+                                                                                { "Default", new ThemeScope() },
+                                                                                { "test", new ThemeScope() }
+                                                                            },
+                                                                            StringComparer.InvariantCultureIgnoreCase
+                                                                           );
+
+        Assert.Contains ("test", ThemeManager.Themes!);
+
+        Disable (resetToHardCodedDefaults: true);
+    }
+
+
+    [Fact]
+    public void Themes_Set_Throws_If_No_Default_Theme_In_Dictionary ()
+    {
+        Assert.False (IsEnabled);
+
+        Enable (ConfigLocations.HardCoded);
+
+        Assert.Single (ThemeManager.Themes!);
+
+        Assert.Throws<InvalidOperationException> (
+                                                  () => ThemeManager.Themes = new ConcurrentDictionary<string, ThemeScope> (
+                                                             new Dictionary<string, ThemeScope>
+                                                             {
+                                                                 { "test", new ThemeScope() }
+                                                             },
+                                                             StringComparer.InvariantCultureIgnoreCase
+                                                            ));
+        Assert.Single (ThemeManager.Themes!);
+
+        Disable (resetToHardCodedDefaults: true);
+    }
+
+    [Fact]
+    public void Themes_Get () { }
+
+    #endregion Tests Settings["Themes"] and ThemeManager.Themes
+
+    [Fact]
+    public void Themes_TryAdd_Adds ()
+    {
+        Enable (ConfigLocations.HardCoded);
+
+        // Verify that the Themes dictionary contains only the Default theme
+        Assert.Single (ThemeManager.Themes!);
+        Assert.Contains (ThemeManager.DEFAULT_THEME_NAME, ThemeManager.Themes!);
+
+        var theme = new ThemeScope ();
+        theme.LoadHardCodedDefaults ();
+        Assert.NotEmpty (theme);
+
+        Assert.True (ThemeManager.Themes!.TryAdd ("testTheme", theme));
+        Assert.Equal (2, ThemeManager.Themes.Count);
+
+        Disable (resetToHardCodedDefaults: true);
+    }
+
+    [Fact]
+    public void Apply_Applies ()
+    {
+        Assert.False (IsEnabled);
+        Enable (ConfigLocations.HardCoded);
+
+        var theme = new ThemeScope ();
+        theme.LoadHardCodedDefaults ();
+        Assert.NotEmpty (theme);
+
+        Assert.True (ThemeManager.Themes!.TryAdd ("testTheme", theme));
+        Assert.Equal (2, ThemeManager.Themes.Count);
+
+        Assert.Equal (LineStyle.Rounded, FrameView.DefaultBorderStyle);
+        theme ["FrameView.DefaultBorderStyle"].PropertyValue = LineStyle.Double; // default is Single
+
+        ThemeManager.Theme = "testTheme";
+        ThemeManager.Themes! [ThemeManager.Theme]!.Apply ();
+
+        Assert.Equal (LineStyle.Double, FrameView.DefaultBorderStyle);
+
+        Disable (resetToHardCodedDefaults: true);
+    }
+
+    [Fact]
+    public void Theme_Reload_Consistency ()
+    {
+        try
+        {
+            Enable (ConfigLocations.HardCoded);
+
+            // BUGBUG: Setting Schemes to empty array is not valid!
+            // Create a test theme
+            RuntimeConfig = """
+                            {
+                                 "Theme": "TestTheme",
+                                 "Themes": [
+                                   {
+                                     "TestTheme": {
+                                       "Schemes": []
+                                     }
+                                   }
+                                 ]
+                            }
+                            """;
+
+            // Load the test theme
+            ThrowOnJsonErrors = true;
+            Load (ConfigLocations.Runtime);
+            Assert.Equal ("TestTheme", ThemeManager.Theme);
+
+            // Now reset everything and reload
+            ResetToHardCodedDefaults ();
+
+            // Verify we're back to default
+            Assert.Equal ("Default", ThemeManager.Theme);
+        }
+        finally
+        {
+            Disable (resetToHardCodedDefaults: true);
+        }
+    }
+
+    [Fact]
+    public void In_Memory_Themes_Size_Is_Reasonable ()
+    {
+        output.WriteLine ($"Start: Color size: {(MemorySizeEstimator.EstimateSize (Color.Red))} b");
+
+        output.WriteLine ($"Start: Attribute size: {(MemorySizeEstimator.EstimateSize (Attribute.Default))} b");
+
+        output.WriteLine ($"Start: Base Scheme size: {(MemorySizeEstimator.EstimateSize (Scheme.GetHardCodedSchemes ()))} b");
+
+        output.WriteLine ($"Start: PropertyInfo size: {(MemorySizeEstimator.EstimateSize (ConfigurationManager.Settings! ["Application.QuitKey"]))} b");
+
+        ThemeScope themeScope = new ThemeScope ();
+        output.WriteLine ($"Start: ThemeScope ({themeScope.Count}) size: {(MemorySizeEstimator.EstimateSize (themeScope))} b");
+
+        themeScope.AddValue ("Schemes", Scheme.GetHardCodedSchemes ());
+        output.WriteLine ($"Start: ThemeScope ({themeScope.Count}) size: {(MemorySizeEstimator.EstimateSize (themeScope))} b");
+
+        output.WriteLine ($"Start: HardCoded Schemes ({SchemeManager.Schemes!.Count}) size: {(MemorySizeEstimator.EstimateSize (SchemeManager.Schemes!))} b");
+
+        output.WriteLine ($"Start: Themes dictionary ({ThemeManager.Themes!.Count}) size: {(MemorySizeEstimator.EstimateSize (ThemeManager.Themes!)) / 1024} Kb");
+
+        Enable (ConfigLocations.HardCoded);
+
+        output.WriteLine ($"Enabled: Themes dictionary ({ThemeManager.Themes.Count}) size: {(MemorySizeEstimator.EstimateSize (ThemeManager.Themes!)) / 1024} Kb");
+
+        Load (ConfigLocations.LibraryResources);
+        output.WriteLine ($"After Load: Themes dictionary ({ThemeManager.Themes!.Count}) size: {(MemorySizeEstimator.EstimateSize (ThemeManager.Themes!)) / 1024} Kb");
+
+        output.WriteLine ($"Total Settings Size: {(MemorySizeEstimator.EstimateSize (Settings!)) / 1024} Kb");
+
+        string json = ConfigurationManager.SourcesManager?.ToJson (Settings)!;
+
+        // In memory size should be less than the size of the json
+        output.WriteLine ($"JSON size: {json.Length / 1024} Kb");
+
+        Assert.True (70000 > MemorySizeEstimator.EstimateSize (ThemeManager.Themes!), $"In memory size ({(MemorySizeEstimator.EstimateSize (Settings!)) / 1024} Kb) is > json size ({json.Length / 1024} Kb)");
+
+        Disable (resetToHardCodedDefaults: true);
+    }
+}