diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationCSharpTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationCSharpTest.cs
new file mode 100644
index 00000000..a187c518
--- /dev/null
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationCSharpTest.cs
@@ -0,0 +1,579 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+
+using System.Threading.Tasks;
+
+namespace ClangSharp.UnitTests;
+
+public abstract class CXXMethodDeclarationCSharpTest : CXXMethodDeclarationTest
+{
+    protected override Task ConstructorTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int _value;
+
+    MyStruct(int value)
+    {
+        _value = value;
+    }
+};
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int _value;
+
+        public MyStruct(int value)
+        {
+            _value = value;
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task ConstructorWithInitializeTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int _x;
+    int _y;
+    int _z;
+
+    MyStruct(int x) : _x(x)
+    {
+    }
+
+    MyStruct(int x, int y) : _x(x), _y(y)
+    {
+    }
+
+    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
+    {
+    }
+};
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int _x;
+
+        public int _y;
+
+        public int _z;
+
+        public MyStruct(int x)
+        {
+            _x = x;
+        }
+
+        public MyStruct(int x, int y)
+        {
+            _x = x;
+            _y = y;
+        }
+
+        public MyStruct(int x, int y, int z)
+        {
+            _x = x;
+            _y = y;
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task ConversionTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    operator int()
+    {
+        return value;
+    }
+};
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int value;
+
+        public int ToInt32()
+        {
+            return value;
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task DestructorTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    ~MyStruct()
+    {
+    }
+};
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public void Dispose()
+        {
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task MacrosExpansionTestImpl()
+    {
+        var inputContents = @"typedef struct
+{
+    unsigned char *buf;
+    int size;
+} context_t;
+
+int buf_close(void *pContext)
+{
+    ((context_t*)pContext)->buf=0;
+    return 0;
+}
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public unsafe partial struct context_t
+    {
+        [NativeTypeName(""unsigned char *"")]
+        public byte* buf;
+
+        public int size;
+    }
+
+    public static unsafe partial class Methods
+    {
+        public static int buf_close(void* pContext)
+        {
+            ((context_t*)(pContext))->buf = null;
+            return 0;
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task MemberCallTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    int MyFunction1()
+    {
+        return value;
+    }
+
+    int MyFunction2()
+    {
+        return MyFunction1();
+    }
+
+    int MyFunction3()
+    {
+        return this->MyFunction1();
+    }
+};
+
+int MyFunctionA(MyStruct x)
+{
+    return x.MyFunction1();
+}
+
+int MyFunctionB(MyStruct* x)
+{
+    return x->MyFunction2();
+}
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int value;
+
+        public int MyFunction1()
+        {
+            return value;
+        }
+
+        public int MyFunction2()
+        {
+            return MyFunction1();
+        }
+
+        public int MyFunction3()
+        {
+            return this.MyFunction1();
+        }
+    }
+
+    public static unsafe partial class Methods
+    {
+        public static int MyFunctionA(MyStruct x)
+        {
+            return x.MyFunction1();
+        }
+
+        public static int MyFunctionB(MyStruct* x)
+        {
+            return x->MyFunction2();
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task MemberTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    int MyFunction()
+    {
+        return value;
+    }
+};
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int value;
+
+        public int MyFunction()
+        {
+            return value;
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task NewKeywordTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int Equals() { return 0; }
+    int Equals(int obj) { return 0; }
+    int Dispose() { return 0; }
+    int Dispose(int obj) { return 0; }
+    int GetHashCode() { return 0; }
+    int GetHashCode(int obj) { return 0; }
+    int GetType() { return 0; }
+    int GetType(int obj) { return 0; }
+    int MemberwiseClone() { return 0; }
+    int MemberwiseClone(int obj) { return 0; }
+    int ReferenceEquals() { return 0; }
+    int ReferenceEquals(int obj) { return 0; }
+    int ToString() { return 0; }
+    int ToString(int obj) { return 0; }
+};";
+
+        var expectedOutputContents = $@"namespace ClangSharp.Test
+{{
+    public partial struct MyStruct
+    {{
+        public int Equals()
+        {{
+            return 0;
+        }}
+
+        public int Equals(int obj)
+        {{
+            return 0;
+        }}
+
+        public int Dispose()
+        {{
+            return 0;
+        }}
+
+        public int Dispose(int obj)
+        {{
+            return 0;
+        }}
+
+        public new int GetHashCode()
+        {{
+            return 0;
+        }}
+
+        public int GetHashCode(int obj)
+        {{
+            return 0;
+        }}
+
+        public new int GetType()
+        {{
+            return 0;
+        }}
+
+        public int GetType(int obj)
+        {{
+            return 0;
+        }}
+
+        public new int MemberwiseClone()
+        {{
+            return 0;
+        }}
+
+        public int MemberwiseClone(int obj)
+        {{
+            return 0;
+        }}
+
+        public int ReferenceEquals()
+        {{
+            return 0;
+        }}
+
+        public int ReferenceEquals(int obj)
+        {{
+            return 0;
+        }}
+
+        public new int ToString()
+        {{
+            return 0;
+        }}
+
+        public int ToString(int obj)
+        {{
+            return 0;
+        }}
+    }}
+}}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task OperatorTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    MyStruct(int value) : value(value)
+    {
+    }
+
+    MyStruct operator+(MyStruct rhs)
+    {
+        return MyStruct(value + rhs.value);
+    }
+};
+
+MyStruct operator-(MyStruct lhs, MyStruct rhs)
+{
+    return MyStruct(lhs.value - rhs.value);
+}
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int value;
+
+        public MyStruct(int value)
+        {
+            this.value = value;
+        }
+
+        public MyStruct Add(MyStruct rhs)
+        {
+            return new MyStruct(value + rhs.value);
+        }
+    }
+
+    public static partial class Methods
+    {
+        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
+        {
+            return new MyStruct(lhs.value - rhs.value);
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task OperatorCallTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    MyStruct(int value) : value(value)
+    {
+    }
+
+    MyStruct operator+(MyStruct rhs)
+    {
+        return MyStruct(value + rhs.value);
+    }
+};
+
+MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
+{
+    return lhs + rhs;
+}
+
+MyStruct operator-(MyStruct lhs, MyStruct rhs)
+{
+    return MyStruct(lhs.value - rhs.value);
+}
+
+MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
+{
+    return lhs - rhs;
+}
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int value;
+
+        public MyStruct(int value)
+        {
+            this.value = value;
+        }
+
+        public MyStruct Add(MyStruct rhs)
+        {
+            return new MyStruct(value + rhs.value);
+        }
+    }
+
+    public static partial class Methods
+    {
+        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
+        {
+            return lhs.Add(rhs);
+        }
+
+        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
+        {
+            return new MyStruct(lhs.value - rhs.value);
+        }
+
+        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
+        {
+            return Subtract(lhs, rhs);
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task ThisTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    int MyFunction()
+    {
+        return this->value;
+    }
+};
+";
+
+        var expectedOutputContents = @"namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        public int value;
+
+        public int MyFunction()
+        {
+            return this.value;
+        }
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    void* MyVoidStarMethod()
+    {
+        return nullptr;
+    }
+};
+
+extern ""C"" void MyFunction();";
+
+        var expectedOutputContents = @"using System.Runtime.InteropServices;
+
+namespace ClangSharp.Test
+{
+    public unsafe partial struct MyStruct
+    {
+        public void* MyVoidStarMethod()
+        {
+            return null;
+        }
+    }
+
+    public static partial class Methods
+    {
+        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void MyFunction();
+    }
+}
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+}
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationTest.cs
index 05f77d4c..6e81b3a5 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationTest.cs
@@ -25,6 +25,9 @@ public abstract class CXXMethodDeclarationTest : PInvokeGeneratorTest
     [Test]
     public Task InstanceTest() => InstanceTestImpl();
 
+    [Test]
+    public Task MacrosExpansionTest() => MacrosExpansionTestImpl();
+
     [Test]
     public Task MemberCallTest() => MemberCallTestImpl();
 
@@ -64,46 +67,6 @@ public abstract class CXXMethodDeclarationTest : PInvokeGeneratorTest
     [Test]
     public Task VirtualWithVtblIndexAttributeTest() => VirtualWithVtblIndexAttributeTestImpl();
 
-    [Test]
-    public virtual Task MacrosExpansionTest()
-    {
-        var inputContents = @"typedef struct
-{
-	unsigned char *buf;
-	int size;
-} context_t;
-
-int buf_close(void *pContext)
-{
-	((context_t*)pContext)->buf=0;
-	return 0;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public unsafe partial struct context_t
-    {
-        [NativeTypeName(""unsigned char *"")]
-        public byte* buf;
-
-        public int size;
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int buf_close(void* pContext)
-        {
-            ((context_t*)(pContext))->buf = null;
-            return 0;
-        }
-    }
-}
-";
-
-        return ValidateBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected abstract Task ConstructorTestImpl();
 
     protected abstract Task ConstructorWithInitializeTestImpl();
@@ -116,6 +79,8 @@ public static int buf_close(void* pContext)
 
     protected abstract Task InstanceTestImpl();
 
+    protected abstract Task MacrosExpansionTestImpl();
+
     protected abstract Task MemberCallTestImpl();
 
     protected abstract Task MemberTestImpl();
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationXmlTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationXmlTest.cs
index 6c828d97..0a37bdf1 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationXmlTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/CXXMethodDeclarationXmlTest.cs
@@ -1,25 +1,204 @@
 // Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
 
 using System.Threading.Tasks;
-using NUnit.Framework;
 
 namespace ClangSharp.UnitTests;
 
 public abstract class CXXMethodDeclarationXmlTest: CXXMethodDeclarationTest
 {
-    [Test]
-    public override Task MacrosExpansionTest()
+    protected override Task ConstructorTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int _value;
+
+    MyStruct(int value)
+    {
+        _value = value;
+    }
+};
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""_value"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""MyStruct"" access=""public"">
+        <type>void</type>
+        <param name=""value"">
+          <type>int</type>
+        </param>
+        <code>_value = value;</code>
+      </function>
+    </struct>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task ConstructorWithInitializeTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int _x;
+    int _y;
+    int _z;
+
+    MyStruct(int x) : _x(x)
+    {
+    }
+
+    MyStruct(int x, int y) : _x(x), _y(y)
+    {
+    }
+
+    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
+    {
+    }
+};
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""_x"" access=""public"">
+        <type>int</type>
+      </field>
+      <field name=""_y"" access=""public"">
+        <type>int</type>
+      </field>
+      <field name=""_z"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""MyStruct"" access=""public"">
+        <type>void</type>
+        <param name=""x"">
+          <type>int</type>
+        </param>
+        <init field=""_x"" hint=""x"">
+          <code>x</code>
+        </init>
+        <code></code>
+      </function>
+      <function name=""MyStruct"" access=""public"">
+        <type>void</type>
+        <param name=""x"">
+          <type>int</type>
+        </param>
+        <param name=""y"">
+          <type>int</type>
+        </param>
+        <init field=""_x"" hint=""x"">
+          <code>x</code>
+        </init>
+        <init field=""_y"" hint=""y"">
+          <code>y</code>
+        </init>
+        <code></code>
+      </function>
+      <function name=""MyStruct"" access=""public"">
+        <type>void</type>
+        <param name=""x"">
+          <type>int</type>
+        </param>
+        <param name=""y"">
+          <type>int</type>
+        </param>
+        <param name=""z"">
+          <type>int</type>
+        </param>
+        <init field=""_x"" hint=""x"">
+          <code>x</code>
+        </init>
+        <init field=""_y"" hint=""y"">
+          <code>y</code>
+        </init>
+        <code></code>
+      </function>
+    </struct>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task ConversionTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    operator int()
+    {
+        return value;
+    }
+};
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""value"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""ToInt32"" access=""public"">
+        <type>int</type>
+        <code>return value;</code>
+      </function>
+    </struct>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task DestructorTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    ~MyStruct()
+    {
+    }
+};
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <function name=""Dispose"" access=""public"">
+        <type>void</type>
+        <code></code>
+      </function>
+    </struct>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task MacrosExpansionTestImpl()
     {
         var inputContents = @"typedef struct
 {
-	unsigned char *buf;
-	int size;
+    unsigned char *buf;
+    int size;
 } context_t;
 
 int buf_close(void *pcontext)
 {
-	((context_t*)pcontext)->buf=0;
-	return 0;
+    ((context_t*)pcontext)->buf=0;
+    return 0;
 }
 ";
 
@@ -46,6 +225,450 @@ int buf_close(void *pcontext)
     </class>
   </namespace>
 </bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task MemberCallTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    int MyFunction1()
+    {
+        return value;
+    }
+
+    int MyFunction2()
+    {
+        return MyFunction1();
+    }
+
+    int MyFunction3()
+    {
+        return this->MyFunction1();
+    }
+};
+
+int MyFunctionA(MyStruct x)
+{
+    return x.MyFunction1();
+}
+
+int MyFunctionB(MyStruct* x)
+{
+    return x->MyFunction2();
+}
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""value"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""MyFunction1"" access=""public"">
+        <type>int</type>
+        <code>return value;</code>
+      </function>
+      <function name=""MyFunction2"" access=""public"">
+        <type>int</type>
+        <code>return MyFunction1();</code>
+      </function>
+      <function name=""MyFunction3"" access=""public"">
+        <type>int</type>
+        <code>return this.MyFunction1();</code>
+      </function>
+    </struct>
+    <class name=""Methods"" access=""public"" static=""true"">
+      <function name=""MyFunctionA"" access=""public"" static=""true"">
+        <type>int</type>
+        <param name=""x"">
+          <type>MyStruct</type>
+        </param>
+        <code>return x.MyFunction1();</code>
+      </function>
+      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
+        <type>int</type>
+        <param name=""x"">
+          <type>MyStruct*</type>
+        </param>
+        <code>return x-&gt;MyFunction2();</code>
+      </function>
+    </class>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task MemberTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    int MyFunction()
+    {
+        return value;
+    }
+};
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""value"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""MyFunction"" access=""public"">
+        <type>int</type>
+        <code>return value;</code>
+      </function>
+    </struct>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task NewKeywordTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int Equals() { return 0; }
+    int Equals(int obj) { return 0; }
+    int Dispose() { return 0; }
+    int Dispose(int obj) { return 0; }
+    int GetHashCode() { return 0; }
+    int GetHashCode(int obj) { return 0; }
+    int GetType() { return 0; }
+    int GetType(int obj) { return 0; }
+    int MemberwiseClone() { return 0; }
+    int MemberwiseClone(int obj) { return 0; }
+    int ReferenceEquals() { return 0; }
+    int ReferenceEquals(int obj) { return 0; }
+    int ToString() { return 0; }
+    int ToString(int obj) { return 0; }
+};";
+
+        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <function name=""Equals"" access=""public"">
+        <type>int</type>
+        <code>return 0;</code>
+      </function>
+      <function name=""Equals"" access=""public"">
+        <type>int</type>
+        <param name=""obj"">
+          <type>int</type>
+        </param>
+        <code>return 0;</code>
+      </function>
+      <function name=""Dispose"" access=""public"">
+        <type>int</type>
+        <code>return 0;</code>
+      </function>
+      <function name=""Dispose"" access=""public"">
+        <type>int</type>
+        <param name=""obj"">
+          <type>int</type>
+        </param>
+        <code>return 0;</code>
+      </function>
+      <function name=""GetHashCode"" access=""public"">
+        <type>int</type>
+        <code>return 0;</code>
+      </function>
+      <function name=""GetHashCode"" access=""public"">
+        <type>int</type>
+        <param name=""obj"">
+          <type>int</type>
+        </param>
+        <code>return 0;</code>
+      </function>
+      <function name=""GetType"" access=""public"">
+        <type>int</type>
+        <code>return 0;</code>
+      </function>
+      <function name=""GetType"" access=""public"">
+        <type>int</type>
+        <param name=""obj"">
+          <type>int</type>
+        </param>
+        <code>return 0;</code>
+      </function>
+      <function name=""MemberwiseClone"" access=""public"">
+        <type>int</type>
+        <code>return 0;</code>
+      </function>
+      <function name=""MemberwiseClone"" access=""public"">
+        <type>int</type>
+        <param name=""obj"">
+          <type>int</type>
+        </param>
+        <code>return 0;</code>
+      </function>
+      <function name=""ReferenceEquals"" access=""public"">
+        <type>int</type>
+        <code>return 0;</code>
+      </function>
+      <function name=""ReferenceEquals"" access=""public"">
+        <type>int</type>
+        <param name=""obj"">
+          <type>int</type>
+        </param>
+        <code>return 0;</code>
+      </function>
+      <function name=""ToString"" access=""public"">
+        <type>int</type>
+        <code>return 0;</code>
+      </function>
+      <function name=""ToString"" access=""public"">
+        <type>int</type>
+        <param name=""obj"">
+          <type>int</type>
+        </param>
+        <code>return 0;</code>
+      </function>
+    </struct>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task OperatorTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    MyStruct(int value) : value(value)
+    {
+    }
+
+    MyStruct operator+(MyStruct rhs)
+    {
+        return MyStruct(value + rhs.value);
+    }
+};
+
+MyStruct operator-(MyStruct lhs, MyStruct rhs)
+{
+    return MyStruct(lhs.value - rhs.value);
+}
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""value"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""MyStruct"" access=""public"">
+        <type>void</type>
+        <param name=""value"">
+          <type>int</type>
+        </param>
+        <init field=""value"" hint=""value"">
+          <code>value</code>
+        </init>
+        <code></code>
+      </function>
+      <function name=""Add"" access=""public"">
+        <type>MyStruct</type>
+        <param name=""rhs"">
+          <type>MyStruct</type>
+        </param>
+        <code>return new MyStruct(value + rhs.value);</code>
+      </function>
+    </struct>
+    <class name=""Methods"" access=""public"" static=""true"">
+      <function name=""Subtract"" access=""public"" static=""true"">
+        <type>MyStruct</type>
+        <param name=""lhs"">
+          <type>MyStruct</type>
+        </param>
+        <param name=""rhs"">
+          <type>MyStruct</type>
+        </param>
+        <code>return new MyStruct(lhs.value - rhs.value);</code>
+      </function>
+    </class>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task OperatorCallTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    MyStruct(int value) : value(value)
+    {
+    }
+
+    MyStruct operator+(MyStruct rhs)
+    {
+        return MyStruct(value + rhs.value);
+    }
+};
+
+MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
+{
+    return lhs + rhs;
+}
+
+MyStruct operator-(MyStruct lhs, MyStruct rhs)
+{
+    return MyStruct(lhs.value - rhs.value);
+}
+
+MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
+{
+    return lhs - rhs;
+}
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""value"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""MyStruct"" access=""public"">
+        <type>void</type>
+        <param name=""value"">
+          <type>int</type>
+        </param>
+        <init field=""value"" hint=""value"">
+          <code>value</code>
+        </init>
+        <code></code>
+      </function>
+      <function name=""Add"" access=""public"">
+        <type>MyStruct</type>
+        <param name=""rhs"">
+          <type>MyStruct</type>
+        </param>
+        <code>return new MyStruct(value + rhs.value);</code>
+      </function>
+    </struct>
+    <class name=""Methods"" access=""public"" static=""true"">
+      <function name=""MyFunction1"" access=""public"" static=""true"">
+        <type>MyStruct</type>
+        <param name=""lhs"">
+          <type>MyStruct</type>
+        </param>
+        <param name=""rhs"">
+          <type>MyStruct</type>
+        </param>
+        <code>return lhs.Add(rhs);</code>
+      </function>
+      <function name=""Subtract"" access=""public"" static=""true"">
+        <type>MyStruct</type>
+        <param name=""lhs"">
+          <type>MyStruct</type>
+        </param>
+        <param name=""rhs"">
+          <type>MyStruct</type>
+        </param>
+        <code>return new MyStruct(lhs.value - rhs.value);</code>
+      </function>
+      <function name=""MyFunction2"" access=""public"" static=""true"">
+        <type>MyStruct</type>
+        <param name=""lhs"">
+          <type>MyStruct</type>
+        </param>
+        <param name=""rhs"">
+          <type>MyStruct</type>
+        </param>
+        <code>return Subtract(lhs, rhs);</code>
+      </function>
+    </class>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task ThisTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    int value;
+
+    int MyFunction()
+    {
+        return this->value;
+    }
+};
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""value"" access=""public"">
+        <type>int</type>
+      </field>
+      <function name=""MyFunction"" access=""public"">
+        <type>int</type>
+        <code>return this.value;</code>
+      </function>
+    </struct>
+  </namespace>
+</bindings>
+";
+
+        return ValidateBindingsAsync(inputContents, expectedOutputContents);
+    }
+
+    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
+    {
+        var inputContents = @"struct MyStruct
+{
+    void* MyVoidStarMethod()
+    {
+        return nullptr;
+    }
+};
+
+extern ""C"" void MyFunction();";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
+      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
+        <type>void*</type>
+        <code>return null;</code>
+      </function>
+    </struct>
+    <class name=""Methods"" access=""public"" static=""true"">
+      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
+        <type>void</type>
+      </function>
+    </class>
+  </namespace>
+</bindings>
 ";
 
         return ValidateBindingsAsync(inputContents, expectedOutputContents);
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/CXXMethodDeclarationTest.cs
index 5a363544..509a92c0 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("unix")]
-public sealed class CSharpCompatibleUnix_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpCompatibleUnix_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -239,209 +100,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -660,130 +318,6 @@ public partial struct Vtbl
         return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -834,71 +368,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleWindows/CXXMethodDeclarationTest.cs
index 88bd0b5e..89527a39 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleWindows/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("win")]
-public sealed class CSharpCompatibleWindows_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpCompatibleWindows_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -234,209 +95,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -655,130 +313,6 @@ public partial struct Vtbl
         return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -829,71 +363,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultUnix/CXXMethodDeclarationTest.cs
index 9049cd5d..d06fc90a 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultUnix/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("unix")]
-public sealed class CSharpDefaultUnix_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpDefaultUnix_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpDefaultUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -234,209 +95,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -599,130 +257,6 @@ public partial struct Vtbl<TSelf>
         return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -773,71 +307,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultWindows/CXXMethodDeclarationTest.cs
index a668f2c1..3b6c0c73 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpDefaultWindows/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("win")]
-public sealed class CSharpDefaultWindows_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpDefaultWindows_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -239,209 +100,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -604,130 +262,6 @@ public partial struct Vtbl<TSelf>
         return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -778,71 +312,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestUnix/CXXMethodDeclarationTest.cs
index 6d422c23..a3b7736d 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestUnix/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("unix")]
-public sealed class CSharpLatestUnix_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpLatestUnix_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpLatestUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -234,209 +95,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -599,130 +257,6 @@ public partial struct Vtbl<TSelf>
         return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -773,71 +307,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestWindows/CXXMethodDeclarationTest.cs
index 731613c9..f4ed0603 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestWindows/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("win")]
-public sealed class CSharpLatestWindows_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpLatestWindows_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpLatestWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -234,209 +95,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -599,130 +257,6 @@ public partial struct Vtbl<TSelf>
         return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -773,71 +307,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewUnix/CXXMethodDeclarationTest.cs
index d0e056f3..d8b9a251 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewUnix/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("unix")]
-public sealed class CSharpPreviewUnix_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpPreviewUnix_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpPreviewUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -234,209 +95,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -599,130 +257,6 @@ public partial struct Vtbl<TSelf>
         return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -773,71 +307,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewWindows/CXXMethodDeclarationTest.cs
index a49a18d3..0f1641a6 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewWindows/CXXMethodDeclarationTest.cs
@@ -8,123 +8,8 @@
 namespace ClangSharp.UnitTests;
 
 [Platform("win")]
-public sealed class CSharpPreviewWindows_CXXMethodDeclarationTest : CXXMethodDeclarationTest
+public sealed class CSharpPreviewWindows_CXXMethodDeclarationTest : CXXMethodDeclarationCSharpTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _value;
-
-        public MyStruct(int value)
-        {
-            _value = value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int _x;
-
-        public int _y;
-
-        public int _z;
-
-        public MyStruct(int x)
-        {
-            _x = x;
-        }
-
-        public MyStruct(int x, int y)
-        {
-            _x = x;
-            _y = y;
-        }
-
-        public MyStruct(int x, int y, int z)
-        {
-            _x = x;
-            _y = y;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int ToInt32()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -159,30 +44,6 @@ public unsafe partial struct MyStruct
         return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public void Dispose()
-        {
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -234,209 +95,6 @@ public int MyInt32Method()
         return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction1()
-        {
-            return value;
-        }
-
-        public int MyFunction2()
-        {
-            return MyFunction1();
-        }
-
-        public int MyFunction3()
-        {
-            return this.MyFunction1();
-        }
-    }
-
-    public static unsafe partial class Methods
-    {
-        public static int MyFunctionA(MyStruct x)
-        {
-            return x.MyFunction1();
-        }
-
-        public static int MyFunctionB(MyStruct* x)
-        {
-            return x->MyFunction2();
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"namespace ClangSharp.Test
-{{
-    public partial struct MyStruct
-    {{
-        public int Equals()
-        {{
-            return 0;
-        }}
-
-        public int Equals(int obj)
-        {{
-            return 0;
-        }}
-
-        public int Dispose()
-        {{
-            return 0;
-        }}
-
-        public int Dispose(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetHashCode()
-        {{
-            return 0;
-        }}
-
-        public int GetHashCode(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int GetType()
-        {{
-            return 0;
-        }}
-
-        public int GetType(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int MemberwiseClone()
-        {{
-            return 0;
-        }}
-
-        public int MemberwiseClone(int obj)
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals()
-        {{
-            return 0;
-        }}
-
-        public int ReferenceEquals(int obj)
-        {{
-            return 0;
-        }}
-
-        public new int ToString()
-        {{
-            return 0;
-        }}
-
-        public int ToString(int obj)
-        {{
-            return 0;
-        }}
-    }}
-}}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -599,130 +257,6 @@ public partial struct Vtbl<TSelf>
         return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public MyStruct(int value)
-        {
-            this.value = value;
-        }
-
-        public MyStruct Add(MyStruct rhs)
-        {
-            return new MyStruct(value + rhs.value);
-        }
-    }
-
-    public static partial class Methods
-    {
-        public static MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-        {
-            return lhs.Add(rhs);
-        }
-
-        public static MyStruct Subtract(MyStruct lhs, MyStruct rhs)
-        {
-            return new MyStruct(lhs.value - rhs.value);
-        }
-
-        public static MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-        {
-            return Subtract(lhs, rhs);
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -773,71 +307,6 @@ public static int MyInt32Method()
         return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"namespace ClangSharp.Test
-{
-    public partial struct MyStruct
-    {
-        public int value;
-
-        public int MyFunction()
-        {
-            return this.value;
-        }
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"using System.Runtime.InteropServices;
-
-namespace ClangSharp.Test
-{
-    public unsafe partial struct MyStruct
-    {
-        public void* MyVoidStarMethod()
-        {
-            return null;
-        }
-    }
-
-    public static partial class Methods
-    {
-        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void MyFunction();
-    }
-}
-";
-
-        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/CXXMethodDeclarationTest.cs
index 7485d37c..2b20f321 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("unix")]
 public sealed class XmlCompatibleUnix_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -206,32 +51,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlCompatibleUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -284,223 +103,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -818,168 +420,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -1028,71 +468,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleWindows/CXXMethodDeclarationTest.cs
index bcdda1f4..32f5b3a0 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleWindows/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("win")]
 public sealed class XmlCompatibleWindows_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -207,32 +52,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -285,223 +104,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -819,168 +421,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -1029,71 +469,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultUnix/CXXMethodDeclarationTest.cs
index 5a4859f9..f05bd5fc 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultUnix/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("unix")]
 public sealed class XmlDefaultUnix_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -207,32 +52,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlDefaultUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -285,223 +104,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -711,168 +313,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -921,71 +361,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultWindows/CXXMethodDeclarationTest.cs
index 85afa10c..dc80a866 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlDefaultWindows/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("win")]
 public sealed class XmlDefaultWindows_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -207,32 +52,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlDefaultWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -285,223 +104,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -711,168 +313,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -921,71 +361,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlDefaultWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestUnix/CXXMethodDeclarationTest.cs
index b843483e..4f53a63d 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestUnix/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("unix")]
 public sealed class XmlLatestUnix_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -207,32 +52,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlLatestUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -285,223 +104,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -711,168 +313,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -921,71 +361,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestWindows/CXXMethodDeclarationTest.cs
index d22ffa78..bcc3b0ce 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestWindows/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("win")]
 public sealed class XmlLatestWindows_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -207,32 +52,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlLatestWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -285,223 +104,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -711,168 +313,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -921,71 +361,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewUnix/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewUnix/CXXMethodDeclarationTest.cs
index fd20ea07..a7ce8031 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewUnix/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewUnix/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("unix")]
 public sealed class XmlPreviewUnix_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -205,32 +50,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlPreviewUnixBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -283,223 +102,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -709,168 +311,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -919,71 +359,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewWindows/CXXMethodDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewWindows/CXXMethodDeclarationTest.cs
index 7fa773bb..84a3add5 100644
--- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewWindows/CXXMethodDeclarationTest.cs
+++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewWindows/CXXMethodDeclarationTest.cs
@@ -10,161 +10,6 @@ namespace ClangSharp.UnitTests;
 [Platform("win")]
 public sealed class XmlPreviewWindows_CXXMethodDeclarationTest : CXXMethodDeclarationXmlTest
 {
-    protected override Task ConstructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _value;
-
-    MyStruct(int value)
-    {
-        _value = value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <code>_value = value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConstructorWithInitializeTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int _x;
-    int _y;
-    int _z;
-
-    MyStruct(int x) : _x(x)
-    {
-    }
-
-    MyStruct(int x, int y) : _x(x), _y(y)
-    {
-    }
-
-    MyStruct(int x, int y, int z) : _x(x), _y(y), _z()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""_x"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_y"" access=""public"">
-        <type>int</type>
-      </field>
-      <field name=""_z"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""x"">
-          <type>int</type>
-        </param>
-        <param name=""y"">
-          <type>int</type>
-        </param>
-        <param name=""z"">
-          <type>int</type>
-        </param>
-        <init field=""_x"" hint=""x"">
-          <code>x</code>
-        </init>
-        <init field=""_y"" hint=""y"">
-          <code>y</code>
-        </init>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task ConversionTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    operator int()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""ToInt32"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task DefaultParameterInheritedFromTemplateTestImpl()
     {
         // NOTE: This is a regression test where a struct inherits a function from a template with a default parameter.
@@ -206,32 +51,6 @@ struct MyStruct : public MyTemplate<int>
         return ValidateGeneratedXmlPreviewWindowsBindingsAsync(InputContents, expectedOutputContents);
     }
 
-    protected override Task DestructorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    ~MyStruct()
-    {
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Dispose"" access=""public"">
-        <type>void</type>
-        <code></code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task InstanceTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -284,223 +103,6 @@ int MyInt32Method()
         return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task MemberCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction1()
-    {
-        return value;
-    }
-
-    int MyFunction2()
-    {
-        return MyFunction1();
-    }
-
-    int MyFunction3()
-    {
-        return this->MyFunction1();
-    }
-};
-
-int MyFunctionA(MyStruct x)
-{
-    return x.MyFunction1();
-}
-
-int MyFunctionB(MyStruct* x)
-{
-    return x->MyFunction2();
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction1"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"">
-        <type>int</type>
-        <code>return MyFunction1();</code>
-      </function>
-      <function name=""MyFunction3"" access=""public"">
-        <type>int</type>
-        <code>return this.MyFunction1();</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunctionA"" access=""public"" static=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct</type>
-        </param>
-        <code>return x.MyFunction1();</code>
-      </function>
-      <function name=""MyFunctionB"" access=""public"" static=""true"" unsafe=""true"">
-        <type>int</type>
-        <param name=""x"">
-          <type>MyStruct*</type>
-        </param>
-        <code>return x-&gt;MyFunction2();</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task MemberTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task NewKeywordTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int Equals() { return 0; }
-    int Equals(int obj) { return 0; }
-    int Dispose() { return 0; }
-    int Dispose(int obj) { return 0; }
-    int GetHashCode() { return 0; }
-    int GetHashCode(int obj) { return 0; }
-    int GetType() { return 0; }
-    int GetType(int obj) { return 0; }
-    int MemberwiseClone() { return 0; }
-    int MemberwiseClone(int obj) { return 0; }
-    int ReferenceEquals() { return 0; }
-    int ReferenceEquals(int obj) { return 0; }
-    int ToString() { return 0; }
-    int ToString(int obj) { return 0; }
-};";
-
-        var expectedOutputContents = $@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Equals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""Dispose"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetHashCode"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""GetType"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""MemberwiseClone"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ReferenceEquals"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <code>return 0;</code>
-      </function>
-      <function name=""ToString"" access=""public"">
-        <type>int</type>
-        <param name=""obj"">
-          <type>int</type>
-        </param>
-        <code>return 0;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task NewKeywordVirtualTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -710,168 +312,6 @@ protected override Task NewKeywordVirtualWithExplicitVtblAndMarkerInterfaceTestI
         return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents, PInvokeGeneratorConfigurationOptions.GenerateExplicitVtbls | PInvokeGeneratorConfigurationOptions.GenerateMarkerInterfaces);
     }
 
-    protected override Task OperatorTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task OperatorCallTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    MyStruct(int value) : value(value)
-    {
-    }
-
-    MyStruct operator+(MyStruct rhs)
-    {
-        return MyStruct(value + rhs.value);
-    }
-};
-
-MyStruct MyFunction1(MyStruct lhs, MyStruct rhs)
-{
-    return lhs + rhs;
-}
-
-MyStruct operator-(MyStruct lhs, MyStruct rhs)
-{
-    return MyStruct(lhs.value - rhs.value);
-}
-
-MyStruct MyFunction2(MyStruct lhs, MyStruct rhs)
-{
-    return lhs - rhs;
-}
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyStruct"" access=""public"">
-        <type>void</type>
-        <param name=""value"">
-          <type>int</type>
-        </param>
-        <init field=""value"" hint=""value"">
-          <code>value</code>
-        </init>
-        <code></code>
-      </function>
-      <function name=""Add"" access=""public"">
-        <type>MyStruct</type>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(value + rhs.value);</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction1"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return lhs.Add(rhs);</code>
-      </function>
-      <function name=""Subtract"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return new MyStruct(lhs.value - rhs.value);</code>
-      </function>
-      <function name=""MyFunction2"" access=""public"" static=""true"">
-        <type>MyStruct</type>
-        <param name=""lhs"">
-          <type>MyStruct</type>
-        </param>
-        <param name=""rhs"">
-          <type>MyStruct</type>
-        </param>
-        <code>return Subtract(lhs, rhs);</code>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task StaticTestImpl()
     {
         var inputContents = @"struct MyStruct
@@ -920,71 +360,6 @@ static int MyInt32Method()
         return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
-    protected override Task ThisTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    int value;
-
-    int MyFunction()
-    {
-        return this->value;
-    }
-};
-";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"">
-      <field name=""value"" access=""public"">
-        <type>int</type>
-      </field>
-      <function name=""MyFunction"" access=""public"">
-        <type>int</type>
-        <code>return this.value;</code>
-      </function>
-    </struct>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
-    protected override Task UnsafeDoesNotImpactDllImportTestImpl()
-    {
-        var inputContents = @"struct MyStruct
-{
-    void* MyVoidStarMethod()
-    {
-        return nullptr;
-    }
-};
-
-extern ""C"" void MyFunction();";
-
-        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
-<bindings>
-  <namespace name=""ClangSharp.Test"">
-    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
-      <function name=""MyVoidStarMethod"" access=""public"" unsafe=""true"">
-        <type>void*</type>
-        <code>return null;</code>
-      </function>
-    </struct>
-    <class name=""Methods"" access=""public"" static=""true"">
-      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
-        <type>void</type>
-      </function>
-    </class>
-  </namespace>
-</bindings>
-";
-
-        return ValidateGeneratedXmlPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
-    }
-
     protected override Task VirtualTestImpl()
     {
         var inputContents = @"struct MyStruct