Fixes #3930 - Splits tests to Tests/UnitTests, Tests/IntegrationTests, Tests/StressTests (#3954)

* Tons of API doc updates * Removed stale test * Removed stale tests * Fixed Skipped Shadow test 1 * Fixed Skipped Shadow test 2 * Fixed Skipped Shadow test 3 * Removed stale test * Removed stale test2 * Explicit unregister of event handler on Application.Driver!.ClearedContents * Added Toplevels to dict * code cleanup * spelling error * Removed stale test3 * Removed stale test4 * Removed stale test5 * added script * tweaked script * tweaked script * Created StressTests project; moved some tests * Created IntegrationTests project; moved some tests * New yml * made old yml just unit tests * Tweaked Button_IsDefault_Raises_Accepted_Correctly * tweaked script * cleaned up ymls * tweakled up ymls * stress tests... * stress tests on ubuntu only * Fixed WindowsDriver in InvokeLeakTest * Fixed WindowsDriver in InvokeLeakTest2 * Added Directory.Packages.props. Added Directory.Build.props * Shortened StressTest time * Removed dupe file. * DemoFiles * Moved all tests to ./Tests dir. * Fixed release build issue * Fixed .sln file * Fixed .sl* files * Fixing ymls * Fixing interation tests * Create link to the file TestHelpers. * Created Tests/UnitTestsParallelizable. Moved all obviously parallelizable tests. Updated yml. * fixing logs * fixing logs2 * fixing logs3 * don't require stress to pass for PRs * Fix a failure? * tweaked script * Coudl this be it? * Moved tons of tests to parallelizable * Fixed some stuff * Script to find duplicate tests * Testing workflows * Updated to v4 * Fix RelativeBasePath issue * Replace powershell to pwsh * Add ignore projects. * Removed dupe unit tests * Code cleanup of tests * Cleaned up test warnings * yml tweak * Moved setter * tweak ymls * just randomly throwing spaghetti at a wall * Enable runing 5 test runners in par * Turned off DEBUG_DISPOSABLE for par tests * RunningUnitTests=true * code cleanup (forcing more Action runs) * DISABLE_DEBUG_IDISPOSABLE * Added View.DebugIDisposable. False by default. * Remobed bogus tareet * Remobed bogus tareet2 * fixed warning * added api doc * fixed warning * fixed warning * fixed warning2 * fixed warning3 * fixed warning4 --------- Co-authored-by: BDisp <bd.bdisp@gmail.com>
2026-01-01 08:50:25 +01:00 · 2025-03-05 23:44:27 -07:00
parent 64b216b1e8
commit b0f32811eb
303 changed files with 11531 additions and 11883 deletions
--- a/Tests/UnitTests/Configuration/SerializableConfigurationPropertyTests.cs
+++ b/Tests/UnitTests/Configuration/SerializableConfigurationPropertyTests.cs
@@ -0,0 +1,112 @@
+#nullable enable
+
+using System.Reflection;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+
+namespace Terminal.Gui.ConfigurationTests;
+
+public class SerializableConfigurationPropertyTests
+{
+
+    /// <summary>
+    ///     If this test fails, you need to add a new property to <see cref="SourceGenerationContext"/> to support serialization of the new property type.
+    /// </summary>
+    [Fact]
+    public void Test_SerializableConfigurationProperty_Types_Added_To_JsonSerializerContext ()
+    {
+        // The assembly containing the types to inspect
+        var assembly = Assembly.GetAssembly (typeof (SourceGenerationContext));
+
+        // Get all types from the assembly
+        var types = assembly!.GetTypes ();
+
+        // Find all properties with the SerializableConfigurationProperty attribute
+        var properties = new List<PropertyInfo> ();
+        foreach (var type in types)
+        {
+            properties.AddRange (type.GetProperties ().Where (p =>
+                p.GetCustomAttributes (typeof (SerializableConfigurationProperty), false).Any ()));
+        }
+
+        // Get the types of the properties
+        var propertyTypes = properties.Select (p => p.PropertyType).Distinct ();
+
+        // Get the types registered in the JsonSerializerContext derived class
+        var contextType = typeof (SourceGenerationContext);
+        var contextTypes = GetRegisteredTypes (contextType);
+
+        // Ensure all property types are included in the JsonSerializerContext derived class
+        IEnumerable<Type> collection = contextTypes as Type [] ?? contextTypes.ToArray ();
+
+        foreach (var type in propertyTypes)
+        {
+            Assert.Contains (type, collection);
+        }
+
+        // Ensure no property has the generic JsonStringEnumConverter<>
+        EnsureNoSpecifiedConverters (properties, new [] { typeof (JsonStringEnumConverter<>) });
+        // Ensure no property has the type RuneJsonConverter
+        EnsureNoSpecifiedConverters (properties, new [] { typeof (RuneJsonConverter) });
+        // Ensure no property has the type KeyJsonConverter
+        EnsureNoSpecifiedConverters (properties, new [] { typeof (KeyJsonConverter) });
+
+        // Find all classes with the JsonConverter attribute of type ScopeJsonConverter<>
+        var classesWithScopeJsonConverter = types.Where (t =>
+            t.GetCustomAttributes (typeof (JsonConverterAttribute), false)
+            .Any (attr => ((JsonConverterAttribute)attr).ConverterType!.IsGenericType &&
+                         ((JsonConverterAttribute)attr).ConverterType!.GetGenericTypeDefinition () == typeof (ScopeJsonConverter<>)));
+
+        // Ensure all these classes are included in the JsonSerializerContext derived class
+        foreach (var type in classesWithScopeJsonConverter)
+        {
+            Assert.Contains (type, collection);
+        }
+    }
+
+    private static IEnumerable<Type> GetRegisteredTypes (Type contextType)
+    {
+        // Use reflection to find which types are registered in the JsonSerializerContext
+        var registeredTypes = new List<Type> ();
+
+        var properties = contextType.GetProperties (BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
+        foreach (var property in properties)
+        {
+            if (property.PropertyType.IsGenericType &&
+                property.PropertyType.GetGenericTypeDefinition () == typeof (JsonTypeInfo<>))
+            {
+                registeredTypes.Add (property.PropertyType.GetGenericArguments () [0]);
+            }
+        }
+
+        return registeredTypes.Distinct ();
+    }
+
+    private static void EnsureNoSpecifiedConverters (List<PropertyInfo> properties, IEnumerable<Type> converterTypes)
+    {
+        // Ensure no property has any of the specified converter types
+        foreach (var property in properties)
+        {
+            var jsonConverterAttributes = property.GetCustomAttributes (typeof (JsonConverterAttribute), false)
+                                                  .Cast<JsonConverterAttribute> ();
+
+            foreach (var attribute in jsonConverterAttributes)
+            {
+                foreach (var converterType in converterTypes)
+                {
+                    if (attribute.ConverterType!.IsGenericType &&
+                        attribute.ConverterType.GetGenericTypeDefinition () == converterType)
+                    {
+                        Assert.Fail ($"Property '{property.Name}' should not use the converter '{converterType.Name}'.");
+                    }
+
+                    if (!attribute.ConverterType!.IsGenericType &&
+                        attribute.ConverterType == converterType)
+                    {
+                        Assert.Fail ($"Property '{property.Name}' should not use the converter '{converterType.Name}'.");
+                    }
+                }
+            }
+        }
+    }
+}