Fix all memory leaks in tests

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

tests/CLI/CLI.Tests.cs

@@ -8,20 +8,26 @@ public class CLITests : GeneratorTestFixture
     public void TestTypes()
     {
         // Attributed types
-        var sum = new Types().AttributedSum(3, 4);
+        using (var types = new Types())
-        Assert.That(sum, Is.EqualTo(7));
+        {
+            var sum = types.AttributedSum(3, 4);
+            Assert.That(sum, Is.EqualTo(7));
+        }
     }
 
     [Test]
     public void TestStdString()
     {
-        Assert.AreEqual("test_test", new Date(0, 0, 0).TestStdString("test"));
+        using (var date = new Date(0, 0, 0))
+        {
+            Assert.AreEqual("test_test", date.TestStdString("test"));
+        }
     }
 
     [Test]
     public void GetEmployeeNameFromOrgTest()
     {
-        using (EmployeeOrg org = new EmployeeOrg())
+        using (var org = new EmployeeOrg())
         {
             Assert.AreEqual("Employee", org.Employee.Name);
         }
@@ -30,7 +36,7 @@ public class CLITests : GeneratorTestFixture
     [Test]
     public void TestConsumerOfEnumNestedInClass()
     {
-        using (NestedEnumConsumer consumer = new NestedEnumConsumer())
+        using (var consumer = new NestedEnumConsumer())
         {
             Assert.AreEqual(ClassWithNestedEnum.NestedEnum.E1, consumer.GetPassedEnum(ClassWithNestedEnum.NestedEnum.E1));
         }
@@ -39,7 +45,7 @@ public class CLITests : GeneratorTestFixture
     [Test]
     public void TestChangePassedMappedTypeNonConstRefParam()
     {
-        using (TestMappedTypeNonConstRefParamConsumer consumer = new TestMappedTypeNonConstRefParamConsumer())
+        using (var consumer = new TestMappedTypeNonConstRefParamConsumer())
         {
             string val = "Initial";
             consumer.ChangePassedMappedTypeNonConstRefParam(ref val);

tests/CSharp/CSharp.Tests.cs

@@ -113,18 +113,24 @@ public unsafe class CSharpTests : GeneratorTestFixture
     [Test]
     public void TestIndexer()
     {
-        var foo = new Foo();
+        using (var foo = new Foo())
-
+        {
-        Assert.That(foo[0], Is.EqualTo(50));
+            Assert.That(foo[0], Is.EqualTo(50));
-        foo[0] = 250;
+            foo[0] = 250;
-        Assert.That(foo[0], Is.EqualTo(250));
+            Assert.That(foo[0], Is.EqualTo(250));
 
-        Assert.That(foo[(uint) 0], Is.EqualTo(15));
+            Assert.That(foo[(uint) 0], Is.EqualTo(15));
+        }
 
-        var bar = new Bar();
+        using (var bar = new Bar())
-        Assert.That(bar[0].A, Is.EqualTo(10));
+        {
-        bar[0] = new Foo { A = 25 };
+            Assert.That(bar[0].A, Is.EqualTo(10));
-        Assert.That(bar[0].A, Is.EqualTo(25));
+            using (Foo foo = new Foo { A = 25 })
+            {
+                bar[0] = foo;
+                Assert.That(bar[0].A, Is.EqualTo(25));
+            }
+        }
     }
 
     [Test]
@@ -143,8 +149,11 @@ public unsafe class CSharpTests : GeneratorTestFixture
             var bar = (IBar) baz;
             Assert.That(bar.Method, Is.EqualTo(2));
             Assert.That(baz[0], Is.EqualTo(50));
-            bar[0] = new Foo { A = 1000 };
+            using (Foo foo = new Foo { A = 1000 })
-            Assert.That(bar[0].A, Is.EqualTo(1000));
+            {
+                bar[0] = foo;
+                Assert.That(bar[0].A, Is.EqualTo(1000));
+            }
             Assert.That(baz.FarAwayFunc, Is.EqualTo(20));
             Assert.That(baz.TakesQux(baz), Is.EqualTo(20));
             Assert.That(baz.ReturnQux().FarAwayFunc, Is.EqualTo(20));
@@ -160,12 +169,14 @@ public unsafe class CSharpTests : GeneratorTestFixture
     [Test]
     public void TestProperties()
     {
-        var proprietor = new Proprietor();
+        using (var proprietor = new Proprietor())
-        Assert.That(proprietor.Parent, Is.EqualTo(0));
+        {
-        proprietor.Value = 20;
+            Assert.That(proprietor.Parent, Is.EqualTo(0));
-        Assert.That(proprietor.Value, Is.EqualTo(20));
+            proprietor.Value = 20;
-        proprietor.Prop = 50;
+            Assert.That(proprietor.Value, Is.EqualTo(20));
-        Assert.That(proprietor.Prop, Is.EqualTo(50));
+            proprietor.Prop = 50;
+            Assert.That(proprietor.Prop, Is.EqualTo(50));
+        }
         using (var qux = new Qux())
         {
             using (var p = new P((IQux) qux) { Value = 20 })
@@ -200,21 +211,25 @@ public unsafe class CSharpTests : GeneratorTestFixture
         CSharp.TestDestructors.InitMarker();
         Assert.AreEqual(0, CSharp.TestDestructors.Marker);
 
-        var dtors = new TestDestructors();
+        using (var dtors = new TestDestructors())
-        Assert.AreEqual(0xf00d, CSharp.TestDestructors.Marker);
+        {
-        dtors.Dispose();
+            Assert.AreEqual(0xf00d, CSharp.TestDestructors.Marker);
+            dtors.Dispose();
+        }
         Assert.AreEqual(0xcafe, CSharp.TestDestructors.Marker);
     }
 
     [Test]
     public unsafe void TestArrayOfPointersToPrimitives()
     {
-        var bar = new Bar();
+        using (var bar = new Bar())
-        var array = new IntPtr[1];
+        {
-        int i = 5;
+            var array = new IntPtr[1];
-        array[0] = new IntPtr(&i);
+            int i = 5;
-        bar.ArrayOfPrimitivePointers = array;
+            array[0] = new IntPtr(&i);
-        Assert.That(i, Is.EqualTo(*(int*) bar.ArrayOfPrimitivePointers[0]));
+            bar.ArrayOfPrimitivePointers = array;
+            Assert.That(i, Is.EqualTo(*(int*) bar.ArrayOfPrimitivePointers[0]));
+        }
     }
 
     [Test]
@@ -229,9 +244,11 @@ public unsafe class CSharpTests : GeneratorTestFixture
     [Test]
     public void TestPropertiesConflictingWithMethod()
     {
-        var p = new P((IQux) new Qux()) { Test = true };
+        using (var p = new P((IQux) new Qux()) { Test = true })
-        Assert.That(p.Test, Is.True);
+        {
-        p.GetTest();
+            Assert.That(p.Test, Is.True);
+            p.GetTest();
+        }
     }
 
     [Test]
@@ -310,43 +327,51 @@ public unsafe class CSharpTests : GeneratorTestFixture
     [Test]
     public void TestCopyCtor()
     {
-        Qux q1 = new Qux();
+        using (Qux q1 = new Qux())
-        for (int i = 0; i < q1.Array.Length; i++)
         {
-            q1.Array[i] = i;
+            for (int i = 0; i < q1.Array.Length; i++)
-        }
+            {
-        Qux q2 = new Qux(q1);
+                q1.Array[i] = i;
-        for (int i = 0; i < q2.Array.Length; i++)
+            }
-        {
+            using (Qux q2 = new Qux(q1))
-            Assert.AreEqual(q1.Array[i], q2.Array[i]);
+            {
+                for (int i = 0; i < q2.Array.Length; i++)
+                {
+                    Assert.AreEqual(q1.Array[i], q2.Array[i]);
+                }
+            }
         }
     }
 
     [Test]
     public void TestBooleanArray()
     {
-        Foo foo = new Foo { A = 10 };
+        using (Foo foo = new Foo { A = 10 })
-        var new_values = new bool[5];
-        for(int i = 0; i < new_values.Length; ++i)
         {
-            new_values[i] = i % 2 == 0;
+            var new_values = new bool[5];
+            for (int i = 0; i < new_values.Length; ++i)
+            {
+                new_values[i] = i % 2 == 0;
+            }
+            foo.Btest = new_values;
+            Assert.AreEqual(true, foo.Btest[0]);
+            Assert.AreEqual(false, foo.Btest[1]);
+            Assert.AreEqual(true, foo.Btest[2]);
+            Assert.AreEqual(false, foo.Btest[3]);
+            Assert.AreEqual(true, foo.Btest[4]);
         }
-        foo.Btest = new_values;
-        Assert.AreEqual(true, foo.Btest[0]);
-        Assert.AreEqual(false, foo.Btest[1]);
-        Assert.AreEqual(true, foo.Btest[2]);
-        Assert.AreEqual(false, foo.Btest[3]);
-        Assert.AreEqual(true, foo.Btest[4]);
     }
 
 
     [Test]
     public void TestImplicitCtor()
     {
-        Foo foo = new Foo { A = 10 };
+        using (Foo foo = new Foo { A = 10 })
-        using (MethodsWithDefaultValues m = foo)
         {
-            Assert.AreEqual(foo.A, m.A);
+            using (MethodsWithDefaultValues m = foo)
+            {
+                Assert.AreEqual(foo.A, m.A);
+            }
         }
         using (MethodsWithDefaultValues m1 = 5)
         {
@@ -431,9 +456,11 @@ public unsafe class CSharpTests : GeneratorTestFixture
     [Test]
     public void TestCallingVirtualDtor()
     {
-        var callDtorVirtually = new CallDtorVirtually();
+        using (var callDtorVirtually = new CallDtorVirtually())
-        var hasVirtualDtor1 = CallDtorVirtually.GetHasVirtualDtor1(callDtorVirtually);
+        {
-        hasVirtualDtor1.Dispose();
+            var hasVirtualDtor1 = CallDtorVirtually.GetHasVirtualDtor1(callDtorVirtually);
+            hasVirtualDtor1.Dispose();
+        }
         Assert.That(CallDtorVirtually.Destroyed, Is.True);
     }
 
@@ -451,43 +478,46 @@ public unsafe class CSharpTests : GeneratorTestFixture
         Assert.AreEqual(dervClass.M, 2);
         dervClass = new TestParamToInterfacePass(dervClass + baseInterface);
         Assert.AreEqual(dervClass.M, 2);
+        baseClass.Dispose();
     }
-    
+
     [Test]
     public unsafe void TestMultiOverLoadPtrToRef()
     {
         var r = 0;
         MultiOverloadPtrToRef m = &r;
         m.Dispose();
-        var obj = new MultiOverloadPtrToRef(ref r);
+        using (var obj = new MultiOverloadPtrToRef(ref r))
-        var p = obj.ReturnPrimTypePtr();
+        {
-        Assert.AreEqual(0, p[0]);
+            var p = obj.ReturnPrimTypePtr();
-        Assert.AreEqual(0, p[1]);
+            Assert.AreEqual(0, p[0]);
-        Assert.AreEqual(0, p[2]);
+            Assert.AreEqual(0, p[1]);
+            Assert.AreEqual(0, p[2]);
 
-        obj.TakePrimTypePtr(ref *p);
+            obj.TakePrimTypePtr(ref *p);
-        Assert.AreEqual(100, p[0]);
+            Assert.AreEqual(100, p[0]);
-        Assert.AreEqual(200, p[1]);
+            Assert.AreEqual(200, p[1]);
-        Assert.AreEqual(300, p[2]);
+            Assert.AreEqual(300, p[2]);
 
-        int[] array = { 1, 2, 3 };
+            int[] array = { 1, 2, 3 };
-        fixed (int* p1 = array)
+            fixed (int* p1 = array)
-        {
+            {
-            obj.TakePrimTypePtr(ref *p1);
+                obj.TakePrimTypePtr(ref *p1);
-            Assert.AreEqual(100, p1[0]);
+                Assert.AreEqual(100, p1[0]);
-            Assert.AreEqual(200, p1[1]);
+                Assert.AreEqual(200, p1[1]);
-            Assert.AreEqual(300, p1[2]);
+                Assert.AreEqual(300, p1[2]);
-        }
+            }
 
-        Assert.AreEqual(100, array[0]);
+            Assert.AreEqual(100, array[0]);
-        Assert.AreEqual(200, array[1]);
+            Assert.AreEqual(200, array[1]);
-        Assert.AreEqual(300, array[2]);
+            Assert.AreEqual(300, array[2]);
 
-        float pThree = 0;
+            float pThree = 0;
-        var refInt = 0;
+            var refInt = 0;
-        obj.FuncPrimitivePtrToRef(ref refInt, null, ref pThree);
+            obj.FuncPrimitivePtrToRef(ref refInt, null, ref pThree);
-        obj.FuncPrimitivePtrToRefWithDefVal(ref refInt, null, null, ref refInt);
+            obj.FuncPrimitivePtrToRefWithDefVal(ref refInt, null, null, ref refInt);
-        obj.FuncPrimitivePtrToRefWithMultiOverload(ref refInt, null, null, ref refInt);
+            obj.FuncPrimitivePtrToRefWithMultiOverload(ref refInt, null, null, ref refInt);
+        }
     }
 
     [Test]
@@ -506,23 +536,37 @@ public unsafe class CSharpTests : GeneratorTestFixture
         Assert.AreEqual(7, retFoos[2].A);
         Assert.AreEqual(8, retFoos[3].A);
 
+        foreach (Foo foo in foos)
+        {
+            foo.Dispose();
+        }
+
         Foo[] foosMore = new Foo[2];
         foosMore[0] = new Foo();
         foosMore[1] = new Foo();
         var ex = Assert.Throws<ArgumentOutOfRangeException>(() => bar.Foos = foosMore);
         Assert.AreEqual("value", ex.ParamName);
         Assert.AreEqual("The dimensions of the provided array don't match the required size." + Environment.NewLine + "Parameter name: value", ex.Message);
+
+        foreach (Foo foo in foosMore)
+        {
+            foo.Dispose();
+        }
     }
 
     [Test]
     public void TestOutTypeInterfacePassTry()
     {
-        var interfaceClassObj = new TestParamToInterfacePassBaseTwo();
+        using (var interfaceClassObj = new TestParamToInterfacePassBaseTwo())
-        ITestParamToInterfacePassBaseTwo interfaceType = interfaceClassObj;
+        {
-        var obj = new TestOutTypeInterfaces();
+            ITestParamToInterfacePassBaseTwo interfaceType = interfaceClassObj;
-        obj.FuncTryInterfaceTypeOut(out interfaceType);
+            using (var obj = new TestOutTypeInterfaces())
-        ITestParamToInterfacePassBaseTwo interfaceTypePtr;
+            {
-        obj.FuncTryInterfaceTypePtrOut(out interfaceTypePtr);
+                obj.FuncTryInterfaceTypeOut(out interfaceType);
+                ITestParamToInterfacePassBaseTwo interfaceTypePtr;
+                obj.FuncTryInterfaceTypePtrOut(out interfaceTypePtr);
+            }
+        }
     }
 
     [Test]
@@ -1030,9 +1074,11 @@ public unsafe class CSharpTests : GeneratorTestFixture
     [Test]
     public void TestForwardDeclaredStruct()
     {
-        var forwardDeclaredStruct = CSharp.CSharp.CreateForwardDeclaredStruct(10);
+        using (var forwardDeclaredStruct = CSharp.CSharp.CreateForwardDeclaredStruct(10))
-        var i = CSharp.CSharp.UseForwardDeclaredStruct(forwardDeclaredStruct);
+        {
-        Assert.AreEqual(forwardDeclaredStruct.I, i);
+            var i = CSharp.CSharp.UseForwardDeclaredStruct(forwardDeclaredStruct);
+            Assert.AreEqual(forwardDeclaredStruct.I, i);
+        }
     }
 
     [Test]

tests/Common/Common.Tests.cs

@@ -74,165 +74,179 @@ public class CommonTests : GeneratorTestFixture
     [Test]
     public void TestHello()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-        hello.PrintHello("Hello world");
+        {
+            hello.PrintHello("Hello world");
 
-        Assert.That(hello.Add(1, 1), Is.EqualTo(2));
+            Assert.That(hello.Add(1, 1), Is.EqualTo(2));
-        Assert.That(hello.Add(5, 5), Is.EqualTo(10));
+            Assert.That(hello.Add(5, 5), Is.EqualTo(10));
 
-        Assert.IsTrue(hello.Test1(3, 3.0f));
+            Assert.IsTrue(hello.Test1(3, 3.0f));
-        Assert.IsFalse(hello.Test1(2, 3.0f));
+            Assert.IsFalse(hello.Test1(2, 3.0f));
 
-        var foo = new Foo { A = 4, B = 7 };
+            var foo = new Foo { A = 4, B = 7 };
-        Assert.That(hello.AddFoo(foo), Is.EqualTo(11));
+            Assert.That(hello.AddFoo(foo), Is.EqualTo(11));
-        Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11));
+            Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11));
-        Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11));
+            Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11));
-        Assert.That(hello.AddFooRef(foo), Is.EqualTo(11));
+            Assert.That(hello.AddFooRef(foo), Is.EqualTo(11));
-        unsafe
+            unsafe
-        {
-            var pointer = foo.SomePointer;
-            var pointerPointer = foo.SomePointerPointer;
-            for (int i = 0; i < 4; i++)
             {
-                Assert.AreEqual(i, pointer[i]);
+                var pointer = foo.SomePointer;
-                Assert.AreEqual(i, (*pointerPointer)[i]);
+                var pointerPointer = foo.SomePointerPointer;
+                for (int i = 0; i < 4; i++)
+                {
+                    Assert.AreEqual(i, pointer[i]);
+                    Assert.AreEqual(i, (*pointerPointer)[i]);
+                }
             }
-        }
 
-        var bar = new Bar { A = 4, B = 7 };
+            var bar = new Bar { A = 4, B = 7 };
-        Assert.That(hello.AddBar(bar), Is.EqualTo(11));
+            Assert.That(hello.AddBar(bar), Is.EqualTo(11));
-        Assert.That(bar.RetItem1(), Is.EqualTo(Bar.Item.Item1));
+            Assert.That(bar.RetItem1(), Is.EqualTo(Bar.Item.Item1));
 
-        var retFoo = hello.RetFoo(7, 2.0f);
+            using (var retFoo = hello.RetFoo(7, 2.0f))
-        Assert.That(retFoo.A, Is.EqualTo(7));
+            {
-        Assert.That(retFoo.B, Is.EqualTo(2.0));
+                Assert.That(retFoo.A, Is.EqualTo(7));
+                Assert.That(retFoo.B, Is.EqualTo(2.0));
+            }
 
-        var foo2 = new Foo2 { A = 4, B = 2, C = 3 };
+            using (var foo2 = new Foo2 { A = 4, B = 2, C = 3 })
-        Assert.That(hello.AddFoo(foo2), Is.EqualTo(6));
+            {
-        Assert.That(hello.AddFoo2(foo2), Is.EqualTo(9));
+                Assert.That(hello.AddFoo(foo2), Is.EqualTo(6));
+                Assert.That(hello.AddFoo2(foo2), Is.EqualTo(9));
+            }
 
-        var bar2 = new Bar2 { A = 4, B = 7, C = 3 };
+            var bar2 = new Bar2 { A = 4, B = 7, C = 3 };
-        Assert.That(hello.AddBar2(bar2), Is.EqualTo(14));
+            Assert.That(hello.AddBar2(bar2), Is.EqualTo(14));
 
-        Assert.That(hello.RetEnum(Enum.A), Is.EqualTo(0));
+            Assert.That(hello.RetEnum(Enum.A), Is.EqualTo(0));
-        Assert.That(hello.RetEnum(Enum.B), Is.EqualTo(2));
+            Assert.That(hello.RetEnum(Enum.B), Is.EqualTo(2));
-        Assert.That(hello.RetEnum(Enum.C), Is.EqualTo(5));
+            Assert.That(hello.RetEnum(Enum.C), Is.EqualTo(5));
-        //Assert.That(hello.RetEnum(Enum.D), Is.EqualTo(-2147483648));
+            //Assert.That(hello.RetEnum(Enum.D), Is.EqualTo(-2147483648));
-        Assert.That(hello.RetEnum(Enum.E), Is.EqualTo(1));
+            Assert.That(hello.RetEnum(Enum.E), Is.EqualTo(1));
-        Assert.That(hello.RetEnum(Enum.F), Is.EqualTo(-9));
+            Assert.That(hello.RetEnum(Enum.F), Is.EqualTo(-9));
+        }
     }
 
     [Test]
     public void TestPrimitiveConstCharStringInOut()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        string str;
+            hello.StringOut(out string str);
-        hello.StringOut(out str);
+            Assert.That(str, Is.EqualTo("HelloStringOut"));
-        Assert.That(str, Is.EqualTo("HelloStringOut"));
+            hello.StringOutRef(out str);
-        hello.StringOutRef(out str);
+            Assert.That(str, Is.EqualTo("HelloStringOutRef"));
-        Assert.That(str, Is.EqualTo("HelloStringOutRef"));
+            str = "Hello";
-        str = "Hello";
+            hello.StringInOut(ref str);
-        hello.StringInOut(ref str);
+            Assert.That(str, Is.EqualTo("StringInOut"));
-        Assert.That(str, Is.EqualTo("StringInOut"));
+            str = "Hello";
-        str = "Hello";
+            hello.StringInOutRef(ref str);
-        hello.StringInOutRef(ref str);
+            Assert.That(str, Is.EqualTo("StringInOutRef"));
-        Assert.That(str, Is.EqualTo("StringInOutRef"));
+            hello.StringTypedef(str);
-        hello.StringTypedef(str);
+        }
     }
 
     [Test]
     public void TestPrimitiveOutParameters()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        float f;
+            Assert.That(hello.TestPrimitiveOut(out float f), Is.True);
-        Assert.That(hello.TestPrimitiveOut(out f), Is.True);
+            Assert.That(f, Is.EqualTo(10.0f));
-        Assert.That(f, Is.EqualTo(10.0f));
+        }
     }
 
     [Test]
     public void TestPrimitiveOutRefParameters()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        float f;
+            Assert.That(hello.TestPrimitiveOutRef(out float f), Is.True);
-        Assert.That(hello.TestPrimitiveOutRef(out f), Is.True);
+            Assert.That(f, Is.EqualTo(10.0f));
-        Assert.That(f, Is.EqualTo(10.0f));
+        }
     }
 
     public void TestPrimitiveInOutParameters()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        int i = 10;
+            int i = 10;
-        Assert.That(hello.TestPrimitiveInOut(ref i), Is.True);
+            Assert.That(hello.TestPrimitiveInOut(ref i), Is.True);
-        Assert.That(i, Is.EqualTo(20));
+            Assert.That(i, Is.EqualTo(20));
+        }
     }
 
     [Test]
     public void TestPrimitiveInOutRefParameters()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        int i = 10;
+            int i = 10;
-        Assert.That(hello.TestPrimitiveInOutRef(ref i), Is.True);
+            Assert.That(hello.TestPrimitiveInOutRef(ref i), Is.True);
-        Assert.That(i, Is.EqualTo(20));
+            Assert.That(i, Is.EqualTo(20));
+        }
     }
 
     [Test]
     public void TestEnumOut()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        Enum e;
+            hello.EnumOut((int) Enum.C, out Enum e);
-        hello.EnumOut((int) Enum.C, out e);
+            Assert.That(e, Is.EqualTo(Enum.C));
-        Assert.That(e, Is.EqualTo(Enum.C));
+        }
     }
 
     [Test]
     public void TestEnumOutRef()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        Enum e;
+            hello.EnumOutRef((int) Enum.C, out Enum e);
-        hello.EnumOutRef((int) Enum.C, out e);
+            Assert.That(e, Is.EqualTo(Enum.C));
-        Assert.That(e, Is.EqualTo(Enum.C));
+        }
     }
 
     [Test]
     public void TestEnumInOut()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        var e = Enum.E;
+            var e = Enum.E;
-        hello.EnumInOut(ref e);
+            hello.EnumInOut(ref e);
-        Assert.That(e, Is.EqualTo(Enum.F));
+            Assert.That(e, Is.EqualTo(Enum.F));
+        }
     }
 
     [Test]
     public void TestEnumInOutRef()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-
+        {
-        var e = Enum.E;
+            var e = Enum.E;
-        hello.EnumInOut(ref e);
+            hello.EnumInOut(ref e);
-        Assert.That(e, Is.EqualTo(Enum.F));
+            Assert.That(e, Is.EqualTo(Enum.F));
+        }
     }
 
     [Test]
     public void TestNullRef()
     {
-        var hello = new Hello();
+        using (var hello = new Hello())
-        Assert.That(hello.RetNull(), Is.Null);
+        {
+            Assert.That(hello.RetNull(), Is.Null);
+        }
     }
 
     [Test]
     public void TestAmbiguous()
     {
-        var def = new DefaultParameters();
+        using (var def = new DefaultParameters())
-        def.Foo(1, 2);
+        {
-        def.Bar();
+            def.Foo(1, 2);
+            def.Bar();
+        }
         using (Foo foo = new Foo())
         {
             Common.HasPointerParam(foo, 0);
@@ -243,52 +257,66 @@ public class CommonTests : GeneratorTestFixture
     [Test]
     public void TestLeftShiftOperator()
     {
-        var foo2 = new Foo2 { C = 2 };
+        using (var foo2 = new Foo2 { C = 2 })
-        Foo2 result = foo2 << 3;
+        {
-        foo2.TestKeywordParam(IntPtr.Zero, Bar.Item.Item1, 1);
+            Foo2 result = foo2 << 3;
-        Assert.That(result.C, Is.EqualTo(16));
+            foo2.TestKeywordParam(IntPtr.Zero, Bar.Item.Item1, 1);
+            Assert.That(result.C, Is.EqualTo(16));
+        }
     }
 
     [Test]
     public void TestAbstractReturnType()
     {
-        var returnsAbstractFoo = new ReturnsAbstractFoo();
+        using (var returnsAbstractFoo = new ReturnsAbstractFoo())
-        var abstractFoo = returnsAbstractFoo.Foo;
+        {
-        Assert.AreEqual(abstractFoo.PureFunction(1), 5);
+            var abstractFoo = returnsAbstractFoo.Foo;
-        Assert.AreEqual(abstractFoo.PureFunction1, 10);
+            Assert.AreEqual(abstractFoo.PureFunction(1), 5);
-        var ok = false;
+            Assert.AreEqual(abstractFoo.PureFunction1, 10);
-        Assert.AreEqual(abstractFoo.PureFunction2(ref ok), 15);
+            var ok = false;
+            Assert.AreEqual(abstractFoo.PureFunction2(ref ok), 15);
+        }
     }
 
     [Test]
     public void TestANSI()
     {
-        var foo = new Foo();
+        using (var foo = new Foo())
-        Assert.That(foo.ANSI, Is.EqualTo("ANSI"));
+        {
+            Assert.That(foo.ANSI, Is.EqualTo("ANSI"));
+        }
     }
 
     [Test]
     public void TestMoveOperatorToClass()
     {
         // Unary operator
-        var unary = new TestMoveOperatorToClass() { A = 4, B = 7 };
+        using (var unary = new TestMoveOperatorToClass() { A = 4, B = 7 })
-        var unaryMinus = -unary;
+        {
+            var unaryMinus = -unary;
 
-        Assert.That(unaryMinus.A, Is.EqualTo(-unary.A));
+            Assert.That(unaryMinus.A, Is.EqualTo(-unary.A));
-        Assert.That(unaryMinus.B, Is.EqualTo(-unary.B));
+            Assert.That(unaryMinus.B, Is.EqualTo(-unary.B));
+        }
 
         // Binary operator
-        var bin = new TestMoveOperatorToClass { A = 4, B = 7 };
+        using (var bin = new TestMoveOperatorToClass { A = 4, B = 7 })
-        var bin1 = new TestMoveOperatorToClass { A = 5, B = 10 };
+        {
-        var binSum = bin + bin1;
+            using (var bin1 = new TestMoveOperatorToClass { A = 5, B = 10 })
+            {
+                var binSum = bin + bin1;
 
-        Assert.That(binSum.A, Is.EqualTo(bin.A + bin1.A));
+                Assert.That(binSum.A, Is.EqualTo(bin.A + bin1.A));
-        Assert.That(binSum.B, Is.EqualTo(bin.B + bin1.B));
+                Assert.That(binSum.B, Is.EqualTo(bin.B + bin1.B));
+            }
+        }
 
         // Multiple argument operator
-        var multiArg = new TestMoveOperatorToClass { A = 4, B = 7 };
+        using (var multiArg = new TestMoveOperatorToClass { A = 4, B = 7 })
-        var multiArgStar = multiArg * 2;
+        {
-        Assert.That(multiArgStar, Is.EqualTo(8));
+            var multiArgStar = multiArg * 2;
+            Assert.That(multiArgStar, Is.EqualTo(8));
+        }
     }
 
     [Test]
@@ -302,10 +330,12 @@ public class CommonTests : GeneratorTestFixture
     public void TestMethodWithFixedInstance()
     {
         var bar = new Bar2 { A = 1, B = 2, C = 3 };
-        Foo2 foo = bar.NeedFixedInstance;
+        using (Foo2 foo = bar.NeedFixedInstance)
-        Assert.AreEqual(foo.A, 1);
+        {
-        Assert.AreEqual(foo.B, 2);
+            Assert.AreEqual(foo.A, 1);
-        Assert.AreEqual(foo.C, 3);
+            Assert.AreEqual(foo.B, 2);
+            Assert.AreEqual(foo.C, 3);
+        }
     }
 
     [Test]
@@ -331,18 +361,20 @@ public class CommonTests : GeneratorTestFixture
     [Test]
     public void TestDelegates()
     {
-        var delegates = new TestDelegates();
+        using (var delegates = new TestDelegates())
-        var doubleSum = delegates.A(2) + delegates.B(2);
+        {
-        Assert.AreEqual(8, doubleSum);
+            var doubleSum = delegates.A(2) + delegates.B(2);
+            Assert.AreEqual(8, doubleSum);
 
-        var stdcall = delegates.StdCall(i => i);
+            var stdcall = delegates.StdCall(i => i);
-        Assert.AreEqual(1, stdcall);
+            Assert.AreEqual(1, stdcall);
 
-        var cdecl = delegates.CDecl(i => i);
+            var cdecl = delegates.CDecl(i => i);
-        Assert.AreEqual(1, cdecl);
+            Assert.AreEqual(1, cdecl);
 
-        var emptydelegeate = delegates.MarshalNullDelegate;
+            var emptydelegeate = delegates.MarshalNullDelegate;
-        Assert.AreEqual(emptydelegeate, null);
+            Assert.AreEqual(emptydelegeate, null);
+        }
     }
 
     [Test]
@@ -423,10 +455,12 @@ public class CommonTests : GeneratorTestFixture
     [Test]
     public void TestCharMarshalling()
     {
-        Foo2 foo2 = new Foo2();
+        using (Foo2 foo2 = new Foo2())
-        for (char c = char.MinValue; c <= sbyte.MaxValue; c++)
+        {
-            Assert.That(foo2.TestCharMarshalling(c), Is.EqualTo(c));
+            for (char c = char.MinValue; c <= sbyte.MaxValue; c++)
-        Assert.Catch<OverflowException>(() => foo2.TestCharMarshalling('ж'));
+                Assert.That(foo2.TestCharMarshalling(c), Is.EqualTo(c));
+            Assert.Catch<OverflowException>(() => foo2.TestCharMarshalling('ж'));
+        }
     }
 
     [Test]
@@ -545,66 +579,78 @@ public class CommonTests : GeneratorTestFixture
     public void TestVariable()
     {
         // Test field property
-        var @var = new TestVariables();
+        using (var @var = new TestVariables())
-        @var.SetValue(10);
+        {
+            @var.SetValue(10);
+        }
         Assert.That(TestVariables.VALUE, Is.EqualTo(10));
     }
 
     [Test]
     public void TestWideStrings()
     {
-        var ws = new TestWideStrings();
+        using (var ws = new TestWideStrings())
-        var s = ws.WidePointer;
+        {
-        Assert.That(ws.WidePointer, Is.EqualTo("Hello"));
+            var s = ws.WidePointer;
-        Assert.That(ws.WideNullPointer, Is.EqualTo(null));
+            Assert.That(ws.WidePointer, Is.EqualTo("Hello"));
+            Assert.That(ws.WideNullPointer, Is.EqualTo(null));
+        }
     }
 
     [Test]
     public unsafe void TestArraysPointers()
     {
         var values = MyEnum.A;
-        var arrays = new TestArraysPointers(ref values, 1);
+        using (var arrays = new TestArraysPointers(ref values, 1))
-        Assert.That(arrays.Value, Is.EqualTo(MyEnum.A));
+        {
+            Assert.That(arrays.Value, Is.EqualTo(MyEnum.A));
+        }
     }
 
     [Test]
     public unsafe void TestGetterSetterToProperties()
     {
-        var @class = new TestGetterSetterToProperties();
+        using (var @class = new TestGetterSetterToProperties())
-        Assert.That(@class.Width, Is.EqualTo(640));
+        {
-        Assert.That(@class.Height, Is.EqualTo(480));
+            Assert.That(@class.Width, Is.EqualTo(640));
+            Assert.That(@class.Height, Is.EqualTo(480));
+        }
     }
 
     [Test]
     public unsafe void TestSingleArgumentCtorToCastOperator()
     {
-        var classA = new ClassA(10);
+        using (var classA = new ClassA(10))
-        ClassB classB = classA;
+        {
-        Assert.AreEqual(classA.Value, classB.Value);
+            ClassB classB = classA;
-        ClassC classC = (ClassC) classB;
+            Assert.AreEqual(classA.Value, classB.Value);
-        Assert.AreEqual(classB.Value, classC.Value);
+            ClassC classC = (ClassC) classB;
+            Assert.AreEqual(classB.Value, classC.Value);
+        }
     }
 
     [Test]
     public unsafe void TestFieldRef()
     {
-        var classD = new ClassD(10);
+        using (var classD = new ClassD(10))
-        var fieldRef = classD.Field;
+        {
-        fieldRef.Value = 20;
+            var fieldRef = classD.Field;
-        Assert.AreEqual(20, classD.Field.Value);
+            fieldRef.Value = 20;
+            Assert.AreEqual(20, classD.Field.Value);
+        }
     }
 
     [Test]
     public unsafe void TestDecltype()
     {
-        var ret = Common.TestDecltype;
+        int ret = Common.TestDecltype;
         Assert.AreEqual(0, ret);
     }
 
     [Test]
     public unsafe void TestNullPtrType()
     {
-        var ret = Common.TestNullPtrTypeRet;
+        void* ret = Common.TestNullPtrTypeRet;
         Assert.AreEqual(IntPtr.Zero, new IntPtr(ret));
     }
 
@@ -612,54 +658,68 @@ public class CommonTests : GeneratorTestFixture
     public void TestCtorByValue()
     {
         var bar = new Bar { A = 4, B = 5.5f };
-        var foo2 = new Foo2 { C = 4, ValueTypeField = bar };
+        using (var foo2 = new Foo2 { C = 4, ValueTypeField = bar })
-        var result = foo2 << 2;
+        {
-        Assert.AreEqual(foo2.C << 2, result.C);
+            var result = foo2 << 2;
-        Assert.AreEqual(bar.A << 2, result.ValueTypeField.A);
+            Assert.AreEqual(foo2.C << 2, result.C);
-        Assert.AreEqual(bar.B, result.ValueTypeField.B);
+            Assert.AreEqual(bar.A << 2, result.ValueTypeField.A);
+            Assert.AreEqual(bar.B, result.ValueTypeField.B);
+        }
     }
 
     [Test]
     public void TestMarshalUnattributedDelegate()
     {
-        new TestDelegates().MarshalUnattributedDelegate(i => i);
+        using (TestDelegates testDelegates = new TestDelegates())
+        {
+            testDelegates.MarshalUnattributedDelegate(i => i);
+        }
     }
 
     [Test]
     public void TestPassAnonymousDelegate()
     {
-        var testDelegates = new TestDelegates();
+        using (var testDelegates = new TestDelegates())
-        int value = testDelegates.MarshalAnonymousDelegate(i => i * 2);
+        {
-        Assert.AreEqual(2, value);
+            int value = testDelegates.MarshalAnonymousDelegate(i => i * 2);
-        int value5 = testDelegates.MarshalAnonymousDelegate5(i => i * 2);
+            Assert.AreEqual(2, value);
-        Assert.AreEqual(4, value5);
+            int value5 = testDelegates.MarshalAnonymousDelegate5(i => i * 2);
-        int value6 = testDelegates.MarshalAnonymousDelegate6(i => i * 2);
+            Assert.AreEqual(4, value5);
-        Assert.AreEqual(6, value6);
+            int value6 = testDelegates.MarshalAnonymousDelegate6(i => i * 2);
+            Assert.AreEqual(6, value6);
+        }
     }
 
     [Test]
     public void TestGetAnonymousDelegate()
     {
-        var testDelegates = new TestDelegates();
+        using (var testDelegates = new TestDelegates())
-        var @delegate = testDelegates.MarshalAnonymousDelegate4;
+        {
-        int value = @delegate.Invoke(1);
+            var @delegate = testDelegates.MarshalAnonymousDelegate4;
-        Assert.AreEqual(2, value);
+            int value = @delegate.Invoke(1);
+            Assert.AreEqual(2, value);
+        }
     }
 
     [Test]
     public void TestFixedArrays()
     {
-        var foo = new Foo();
+        using (var foo = new Foo())
-        var array = new[] { 1, 2, 3 };
+        {
-        foo.FixedArray = array;
+            var array = new[] { 1, 2, 3 };
-        for (int i = 0; i < foo.FixedArray.Length; i++)
+            foo.FixedArray = array;
-            Assert.That(array[i], Is.EqualTo(foo.FixedArray[i]));
+            for (int i = 0; i < foo.FixedArray.Length; i++)
+                Assert.That(array[i], Is.EqualTo(foo.FixedArray[i]));
+        }
     }
 
     [Test]
     public void TestInternalCtorAmbiguity()
     {
-        new InvokesInternalCtorAmbiguity().InvokeInternalCtor();
+        using (var invokesInternalCtorAmbiguity = new InvokesInternalCtorAmbiguity())
+        {
+            invokesInternalCtorAmbiguity.InvokeInternalCtor();
+        }
     }
 
     [Test]
@@ -693,21 +753,30 @@ public class CommonTests : GeneratorTestFixture
     [Test]
     public void TestFriendOperator()
     {
-        HasFriend h1 = 5;
+        using (HasFriend h1 = 5)
-        HasFriend h2 = 10;
+        {
-        Assert.AreEqual(15, (h1 + h2).M);
+            using (HasFriend h2 = 10)
-        Assert.AreEqual(-5, (h1 - h2).M);
+            {
+                Assert.AreEqual(15, (h1 + h2).M);
+                Assert.AreEqual(-5, (h1 - h2).M);
+            }
+        }
     }
 
     [Test]
     public void TestOperatorOverloads()
     {
         var differentConstOverloads = new DifferentConstOverloads();
-        Assert.IsTrue(differentConstOverloads == new DifferentConstOverloads());
+        var differentConstOverloads1 = new DifferentConstOverloads();
+        Assert.IsTrue(differentConstOverloads == differentConstOverloads1);
+        // HACK: don't replace with a using because it triggers a bug in the Mono compiler
+        // https://travis-ci.org/github/mono/CppSharp/jobs/674224017#L997
+        differentConstOverloads1.Dispose();
         Assert.IsTrue(differentConstOverloads == 5);
         Assert.IsFalse(differentConstOverloads == 4);
         Assert.IsTrue(differentConstOverloads == "abcde");
         Assert.IsFalse(differentConstOverloads == "abcd");
+        differentConstOverloads.Dispose();
     }
 
     [Test]
@@ -736,7 +805,10 @@ public class CommonTests : GeneratorTestFixture
     [Test]
     public void TestMarshallingEmptyType()
     {
-        var empty = new ReturnsEmpty().Empty;
+        using (ReturnsEmpty returnsEmpty = new ReturnsEmpty())
+        {
+            returnsEmpty.Empty.Dispose();
+        }
     }
 
     [Test]

tests/Common/Common.cpp

@@ -380,6 +380,8 @@ int ImplementsAbstractFoo::pureFunction2(bool* ok)
 
 ReturnsAbstractFoo::ReturnsAbstractFoo() {}
 
+ReturnsAbstractFoo::~ReturnsAbstractFoo() {}
+
 const AbstractFoo& ReturnsAbstractFoo::getFoo()
 {
     return i;

tests/Common/Common.h

@@ -274,6 +274,7 @@ class DLL_API ReturnsAbstractFoo
 {
 public:
     ReturnsAbstractFoo();
+    ~ReturnsAbstractFoo();
     const AbstractFoo& getFoo();
 
 private:

tests/NamespacesDerived/NamespacesDerived.Tests.cs

@@ -13,9 +13,11 @@ public class NamespaceDerivedTests
     [Test]
     public void TestNonRenamedMethod()
     {
-        var derived = new Derived();
+        using (var derived = new Derived())
-        var parent = derived.Parent;
+        {
-        derived.parent(0);
+            var parent = derived.Parent;
+            derived.parent(0);
+        }
     }
 
     [Test]

tests/VTables/VTables.Tests.cs

@@ -36,14 +36,18 @@ public class VTablesTests : GeneratorTestFixture
     [Test]
     public void TestFoo()
     {
-        var foo = new Foo();
+        using (var foo = new Foo())
-        Assert.That(foo.vfoo, Is.EqualTo(5));
+        {
-        Assert.That(foo.Vbar, Is.EqualTo(5));
+            Assert.That(foo.vfoo, Is.EqualTo(5));
-        Assert.That(foo.CallFoo(), Is.EqualTo(7));
+            Assert.That(foo.Vbar, Is.EqualTo(5));
-        Assert.That(foo.CallVirtualWithParameter(6514), Is.EqualTo(6514 + 1));
+            Assert.That(foo.CallFoo(), Is.EqualTo(7));
+            Assert.That(foo.CallVirtualWithParameter(6514), Is.EqualTo(6514 + 1));
+        }
 
-        var foo2 = new FooDerived();
+        using (var foo2 = new FooDerived())
-        Assert.That(foo2.CallFoo(), Is.EqualTo(12));
+        {
+            Assert.That(foo2.CallFoo(), Is.EqualTo(12));
+        }
     }
 
     void TestVirtualFunction(BaseClassVirtual obj, int actual)
@@ -60,23 +64,32 @@ public class VTablesTests : GeneratorTestFixture
     {
         // Virtual Functions Object Slicing case
         // See http://stackoverflow.com/questions/3479712/virtual-functions-object-slicing
-        var baseVirtual = BaseClassVirtual.Base;
+        using (var baseVirtual = BaseClassVirtual.Base)
-        TestVirtualFunction(baseVirtual, 5);
+        {
+            TestVirtualFunction(baseVirtual, 5);
+        }
 
         BaseClassVirtual baseClass = new DerivedClassVirtual();
         TestVirtualFunction(baseClass, 10);
+        baseClass.Dispose();
 
-        var basePtr = BaseClassVirtual.BasePtr;
+        using (var basePtr = BaseClassVirtual.BasePtr)
-        TestVirtualFunction(basePtr, 10);
+        {
+            TestVirtualFunction(basePtr, 10);
+        }
 
-        var managed = new ManagedDerivedClassVirtual();
+        using (var managed = new ManagedDerivedClassVirtual())
-        TestVirtualFunction(managed, 15);
+        {
+            TestVirtualFunction(managed, 15);
 
-        baseClass = managed;
+            baseClass = managed;
-        TestVirtualFunction(baseClass, 15);
+            TestVirtualFunction(baseClass, 15);
+        }
 
-        var retBase = new ManagedDerivedClassVirtualRetBase();
+        using (var retBase = new ManagedDerivedClassVirtualRetBase())
-        TestVirtualFunction(retBase, 10);
+        {
+            TestVirtualFunction(retBase, 10);
+        }
     }
 
     [Test]