Add tests for source generators

- Bootstrap xUnit project to test source generators
- Implement source generator tests
- Better tests structure (put test data in cs files)
- Enable `ScriptSerializationGeneratorTests`
- Enable `ScriptPathAttributeGeneratorTests`
- Fix `NesterClass` -> `NestedClass`
- Use `Path.Combine` when dealing with paths
- Copy test data to the output directory

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/AllReadOnly.cs

@@ -0,0 +1,9 @@
+using Godot;
+
+public partial class AllReadOnly : GodotObject
+{
+    public readonly string readonly_field = "foo";
+    public string readonly_auto_property { get; } = "foo";
+    public string readonly_property { get => "foo"; }
+    public string initonly_auto_property { get; init; }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/AllWriteOnly.cs

@@ -0,0 +1,7 @@
+using Godot;
+
+public partial class AllWriteOnly : GodotObject
+{
+    bool writeonly_backing_field = false;
+    public bool writeonly_property { set => writeonly_backing_field = value; }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/Bar.cs

@@ -0,0 +1,14 @@
+using Godot;
+
+partial class Bar : GodotObject
+{
+}
+
+// Foo in another file
+partial class Foo
+{
+}
+
+partial class NotSameNameAsFile : GodotObject
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/EventSignals.cs

@@ -0,0 +1,7 @@
+using Godot;
+
+public partial class EventSignals : GodotObject
+{
+    [Signal]
+    public delegate void MySignalEventHandler(string str, int num);
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/ExportedFields.cs

@@ -0,0 +1,102 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+
+public partial class ExportedFields : GodotObject
+{
+    [Export] private Boolean field_Boolean = true;
+    [Export] private Char field_Char = 'f';
+    [Export] private SByte field_SByte = 10;
+    [Export] private Int16 field_Int16 = 10;
+    [Export] private Int32 field_Int32 = 10;
+    [Export] private Int64 field_Int64 = 10;
+    [Export] private Byte field_Byte = 10;
+    [Export] private UInt16 field_UInt16 = 10;
+    [Export] private UInt32 field_UInt32 = 10;
+    [Export] private UInt64 field_UInt64 = 10;
+    [Export] private Single field_Single = 10;
+    [Export] private Double field_Double = 10;
+    [Export] private String field_String = "foo";
+
+    // Godot structs
+    [Export] private Vector2 field_Vector2 = new(10f, 10f);
+    [Export] private Vector2I field_Vector2I = Vector2I.Up;
+    [Export] private Rect2 field_Rect2 = new(new Vector2(10f, 10f), new Vector2(10f, 10f));
+    [Export] private Rect2I field_Rect2I = new(new Vector2I(10, 10), new Vector2I(10, 10));
+    [Export] private Transform2D field_Transform2D = Transform2D.Identity;
+    [Export] private Vector3 field_Vector3 = new(10f, 10f, 10f);
+    [Export] private Vector3I field_Vector3I = Vector3I.Back;
+    [Export] private Basis field_Basis = new Basis(Quaternion.Identity);
+    [Export] private Quaternion field_Quaternion = new Quaternion(Basis.Identity);
+    [Export] private Transform3D field_Transform3D = Transform3D.Identity;
+    [Export] private Vector4 field_Vector4 = new(10f, 10f, 10f, 10f);
+    [Export] private Vector4I field_Vector4I = Vector4I.One;
+    [Export] private Projection field_Projection = Projection.Identity;
+    [Export] private Aabb field_Aabb = new Aabb(10f, 10f, 10f, new Vector3(1f, 1f, 1f));
+    [Export] private Color field_Color = Colors.Aquamarine;
+    [Export] private Plane field_Plane = Plane.PlaneXZ;
+    [Export] private Callable field_Callable = new Callable(Engine.GetMainLoop(), "_process");
+    [Export] private Signal field_Signal = new Signal(Engine.GetMainLoop(), "property_list_changed");
+
+    // Enums
+    enum MyEnum
+    {
+        A,
+        B,
+        C
+    }
+
+    [Export] private MyEnum field_Enum = MyEnum.C;
+
+    [Flags]
+    enum MyFlagsEnum
+    {
+        A,
+        B,
+        C
+    }
+
+    [Export] private MyFlagsEnum field_FlagsEnum = MyFlagsEnum.C;
+
+    // Arrays
+    [Export] private Byte[] field_ByteArray = { 0, 1, 2, 3, 4, 5, 6 };
+    [Export] private Int32[] field_Int32Array = { 0, 1, 2, 3, 4, 5, 6 };
+    [Export] private Int64[] field_Int64Array = { 0, 1, 2, 3, 4, 5, 6 };
+    [Export] private Single[] field_SingleArray = { 0f, 1f, 2f, 3f, 4f, 5f, 6f };
+    [Export] private Double[] field_DoubleArray = { 0d, 1d, 2d, 3d, 4d, 5d, 6d };
+    [Export] private String[] field_StringArray = { "foo", "bar" };
+    [Export(PropertyHint.Enum, "A,B,C")] private String[] field_StringArrayEnum = { "foo", "bar" };
+    [Export] private Vector2[] field_Vector2Array = { Vector2.Up, Vector2.Down, Vector2.Left, Vector2.Right };
+    [Export] private Vector3[] field_Vector3Array = { Vector3.Up, Vector3.Down, Vector3.Left, Vector3.Right };
+    [Export] private Color[] field_ColorArray = { Colors.Aqua, Colors.Aquamarine, Colors.Azure, Colors.Beige };
+    [Export] private GodotObject[] field_GodotObjectOrDerivedArray = { null };
+    [Export] private StringName[] field_StringNameArray = { "foo", "bar" };
+    [Export] private NodePath[] field_NodePathArray = { "foo", "bar" };
+    [Export] private Rid[] field_RidArray = { default, default, default };
+    // Note we use Array and not System.Array. This tests the generated namespace qualification.
+    [Export] private Int32[] field_empty_Int32Array = Array.Empty<Int32>();
+    // Note we use List and not System.Collections.Generic.
+    [Export] private int[] field_array_from_list = new List<int>(Array.Empty<int>()).ToArray();
+
+    // Variant
+    [Export] private Variant field_Variant = "foo";
+
+    // Classes
+    [Export] private GodotObject field_GodotObjectOrDerived;
+    [Export] private Godot.Texture field_GodotResourceTexture;
+    [Export] private StringName field_StringName = new StringName("foo");
+    [Export] private NodePath field_NodePath = new NodePath("foo");
+    [Export] private Rid field_Rid;
+
+    [Export]
+    private Godot.Collections.Dictionary field_GodotDictionary = new() { { "foo", 10 }, { Vector2.Up, Colors.Chocolate } };
+
+    [Export]
+    private Godot.Collections.Array field_GodotArray = new() { "foo", 10, Vector2.Up, Colors.Chocolate };
+
+    [Export]
+    private Godot.Collections.Dictionary<string, bool> field_GodotGenericDictionary = new() { { "foo", true }, { "bar", false } };
+
+    [Export]
+    private Godot.Collections.Array<int> field_GodotGenericArray = new() { 0, 1, 2, 3, 4, 5, 6 };
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/ExportedProperties.cs

@@ -0,0 +1,186 @@
+using Godot;
+using System;
+
+public partial class ExportedProperties : GodotObject
+{
+    // Do not generate default value
+    private String _notGenerate_Property_String = new string("not generate");
+    [Export]
+    public String NotGenerate_Complex_Lamda_Property
+    {
+        get => _notGenerate_Property_String + Convert.ToInt32("1");
+        set => _notGenerate_Property_String = value;
+    }
+
+    [Export]
+    public String NotGenerate_Lamda_NoField_Property
+    {
+        get => new string("not generate");
+        set => _notGenerate_Property_String = value;
+    }
+
+    [Export]
+    public String NotGenerate_Complex_Return_Property
+    {
+        get
+        {
+            return _notGenerate_Property_String + Convert.ToInt32("1");
+        }
+        set
+        {
+            _notGenerate_Property_String = value;
+        }
+    }
+
+    private int _notGenerate_Property_Int = 1;
+    [Export]
+    public string NotGenerate_Returns_Property
+    {
+        get
+        {
+            if (_notGenerate_Property_Int == 1)
+            {
+                return "a";
+            }
+            else
+            {
+                return "b";
+            }
+        }
+        set
+        {
+            _notGenerate_Property_Int = value == "a" ? 1 : 2;
+        }
+    }
+
+    // Full Property
+    private String _fullProperty_String = "FullProperty_String";
+    [Export]
+    public String FullProperty_String
+    {
+        get
+        {
+            return _fullProperty_String;
+        }
+        set
+        {
+            _fullProperty_String = value;
+        }
+    }
+
+    private String _fullProperty_String_Complex = new string("FullProperty_String_Complex") + Convert.ToInt32("1");
+    [Export]
+    public String FullProperty_String_Complex
+    {
+        get
+        {
+            return _fullProperty_String_Complex;
+        }
+        set
+        {
+            _fullProperty_String_Complex = value;
+        }
+    }
+
+    // Lambda Property
+    private String _lamdaProperty_String = "LamdaProperty_String";
+    [Export]
+    public String LamdaProperty_String
+    {
+        get => _lamdaProperty_String;
+        set => _lamdaProperty_String = value;
+    }
+
+    // Auto Property
+    [Export] private Boolean property_Boolean { get; set; } = true;
+    [Export] private Char property_Char { get; set; } = 'f';
+    [Export] private SByte property_SByte { get; set; } = 10;
+    [Export] private Int16 property_Int16 { get; set; } = 10;
+    [Export] private Int32 property_Int32 { get; set; } = 10;
+    [Export] private Int64 property_Int64 { get; set; } = 10;
+    [Export] private Byte property_Byte { get; set; } = 10;
+    [Export] private UInt16 property_UInt16 { get; set; } = 10;
+    [Export] private UInt32 property_UInt32 { get; set; } = 10;
+    [Export] private UInt64 property_UInt64 { get; set; } = 10;
+    [Export] private Single property_Single { get; set; } = 10;
+    [Export] private Double property_Double { get; set; } = 10;
+    [Export] private String property_String { get; set; } = "foo";
+
+    // Godot structs
+    [Export] private Vector2 property_Vector2 { get; set; } = new(10f, 10f);
+    [Export] private Vector2I property_Vector2I { get; set; } = Vector2I.Up;
+    [Export] private Rect2 property_Rect2 { get; set; } = new(new Vector2(10f, 10f), new Vector2(10f, 10f));
+    [Export] private Rect2I property_Rect2I { get; set; } = new(new Vector2I(10, 10), new Vector2I(10, 10));
+    [Export] private Transform2D property_Transform2D { get; set; } = Transform2D.Identity;
+    [Export] private Vector3 property_Vector3 { get; set; } = new(10f, 10f, 10f);
+    [Export] private Vector3I property_Vector3I { get; set; } = Vector3I.Back;
+    [Export] private Basis property_Basis { get; set; } = new Basis(Quaternion.Identity);
+    [Export] private Quaternion property_Quaternion { get; set; } = new Quaternion(Basis.Identity);
+    [Export] private Transform3D property_Transform3D { get; set; } = Transform3D.Identity;
+    [Export] private Vector4 property_Vector4 { get; set; } = new(10f, 10f, 10f, 10f);
+    [Export] private Vector4I property_Vector4I { get; set; } = Vector4I.One;
+    [Export] private Projection property_Projection { get; set; } = Projection.Identity;
+    [Export] private Aabb property_Aabb { get; set; } = new Aabb(10f, 10f, 10f, new Vector3(1f, 1f, 1f));
+    [Export] private Color property_Color { get; set; } = Colors.Aquamarine;
+    [Export] private Plane property_Plane { get; set; } = Plane.PlaneXZ;
+    [Export] private Callable property_Callable { get; set; } = new Callable(Engine.GetMainLoop(), "_process");
+    [Export] private Signal property_Signal { get; set; } = new Signal(Engine.GetMainLoop(), "property_list_changed");
+
+    // Enums
+    enum MyEnum
+    {
+        A,
+        B,
+        C
+    }
+
+    [Export] private MyEnum property_Enum { get; set; } = MyEnum.C;
+
+    [Flags]
+    enum MyFlagsEnum
+    {
+        A,
+        B,
+        C
+    }
+
+    [Export] private MyFlagsEnum property_FlagsEnum { get; set; } = MyFlagsEnum.C;
+
+    // Arrays
+    [Export] private Byte[] property_ByteArray { get; set; } = { 0, 1, 2, 3, 4, 5, 6 };
+    [Export] private Int32[] property_Int32Array { get; set; } = { 0, 1, 2, 3, 4, 5, 6 };
+    [Export] private Int64[] property_Int64Array { get; set; } = { 0, 1, 2, 3, 4, 5, 6 };
+    [Export] private Single[] property_SingleArray { get; set; } = { 0f, 1f, 2f, 3f, 4f, 5f, 6f };
+    [Export] private Double[] property_DoubleArray { get; set; } = { 0d, 1d, 2d, 3d, 4d, 5d, 6d };
+    [Export] private String[] property_StringArray { get; set; } = { "foo", "bar" };
+    [Export(PropertyHint.Enum, "A,B,C")] private String[] property_StringArrayEnum { get; set; } = { "foo", "bar" };
+    [Export] private Vector2[] property_Vector2Array { get; set; } = { Vector2.Up, Vector2.Down, Vector2.Left, Vector2.Right };
+    [Export] private Vector3[] property_Vector3Array { get; set; } = { Vector3.Up, Vector3.Down, Vector3.Left, Vector3.Right };
+    [Export] private Color[] property_ColorArray { get; set; } = { Colors.Aqua, Colors.Aquamarine, Colors.Azure, Colors.Beige };
+    [Export] private GodotObject[] property_GodotObjectOrDerivedArray { get; set; } = { null };
+    [Export] private StringName[] field_StringNameArray { get; set; } = { "foo", "bar" };
+    [Export] private NodePath[] field_NodePathArray { get; set; } = { "foo", "bar" };
+    [Export] private Rid[] field_RidArray { get; set; } = { default, default, default };
+
+    // Variant
+    [Export] private Variant property_Variant { get; set; } = "foo";
+
+    // Classes
+    [Export] private GodotObject property_GodotObjectOrDerived { get; set; }
+    [Export] private Godot.Texture property_GodotResourceTexture { get; set; }
+    [Export] private StringName property_StringName { get; set; } = new StringName("foo");
+    [Export] private NodePath property_NodePath { get; set; } = new NodePath("foo");
+    [Export] private Rid property_Rid { get; set; }
+
+    [Export]
+    private Godot.Collections.Dictionary property_GodotDictionary { get; set; } = new() { { "foo", 10 }, { Vector2.Up, Colors.Chocolate } };
+
+    [Export]
+    private Godot.Collections.Array property_GodotArray { get; set; } = new() { "foo", 10, Vector2.Up, Colors.Chocolate };
+
+    [Export]
+    private Godot.Collections.Dictionary<string, bool> property_GodotGenericDictionary { get; set; } = new() { { "foo", true }, { "bar", false } };
+
+    [Export]
+    private Godot.Collections.Array<int> property_GodotGenericArray { get; set; } = new() { 0, 1, 2, 3, 4, 5, 6 };
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/Foo.cs

@@ -0,0 +1,10 @@
+using Godot;
+
+partial class Foo : GodotObject
+{
+}
+
+// Foo again in the same file
+partial class Foo
+{
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/Generic.cs

@@ -0,0 +1,18 @@
+using Godot;
+
+partial class Generic<T> : GodotObject
+{
+    private int _field;
+}
+
+// Generic again but different generic parameters
+partial class Generic<T, R> : GodotObject
+{
+    private int _field;
+}
+
+// Generic again but without generic parameters
+partial class Generic : GodotObject
+{
+    private int _field;
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/Methods.cs

@@ -0,0 +1,26 @@
+using Godot;
+
+public partial class Methods : GodotObject
+{
+    private void MethodWithOverload()
+    {
+    }
+
+    private void MethodWithOverload(int a)
+    {
+    }
+
+    private void MethodWithOverload(int a, int b)
+    {
+    }
+
+    // Should be ignored. The previous one is picked.
+    private void MethodWithOverload(float a, float b)
+    {
+    }
+
+    // Generic methods should be ignored.
+    private void GenericMethod<T>(T t)
+    {
+    }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/MixedReadOnlyWriteOnly.cs

@@ -0,0 +1,12 @@
+using Godot;
+
+public partial class MixedReadOnlyWriteOnly : GodotObject
+{
+    public readonly string readonly_field = "foo";
+    public string readonly_auto_property { get; } = "foo";
+    public string readonly_property { get => "foo"; }
+    public string initonly_auto_property { get; init; }
+
+    bool writeonly_backing_field = false;
+    public bool writeonly_property { set => writeonly_backing_field = value; }
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/MoreExportedFields.cs

@@ -0,0 +1,8 @@
+using Godot;
+using System;
+
+public partial class ExportedFields : GodotObject
+{
+    // Note we use Array and not System.Array. This tests the generated namespace qualification.
+    [Export] private Int64[] field_empty_Int64Array = Array.Empty<Int64>();
+}

modules/mono/editor/Godot.NET.Sdk/Godot.SourceGenerators.Tests/TestData/Sources/ScriptBoilerplate.cs

@@ -0,0 +1,33 @@
+using Godot;
+
+public partial class ScriptBoilerplate : Node
+{
+    private NodePath _nodePath;
+    private int _velocity;
+
+    public override void _Process(double delta)
+    {
+        _ = delta;
+
+        base._Process(delta);
+    }
+
+    public int Bazz(StringName name)
+    {
+        _ = name;
+        return 1;
+    }
+
+    public void IgnoreThisMethodWithByRefParams(ref int a)
+    {
+        _ = a;
+    }
+}
+
+partial struct OuterClass
+{
+    public partial class NestedClass : RefCounted
+    {
+        public override Variant _Get(StringName property) => default;
+    }
+}