From 499b4aac057d9111d55175a07d0091a3e0d6fa7a Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Mon, 13 Apr 2020 03:49:46 +0300 Subject: [PATCH] Fix all memory leaks in tests Signed-off-by: Dimitar Dobrev --- tests/CLI/CLI.Tests.cs | 18 +- tests/CSharp/CSharp.Tests.cs | 224 +++++---- tests/Common/Common.Tests.cs | 444 ++++++++++-------- .../NamespacesDerived.Tests.cs | 8 +- tests/VTables/VTables.Tests.cs | 47 +- 5 files changed, 439 insertions(+), 302 deletions(-) diff --git a/tests/CLI/CLI.Tests.cs b/tests/CLI/CLI.Tests.cs index 49845cc3e8..86330eb8be 100644 --- a/tests/CLI/CLI.Tests.cs +++ b/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); - Assert.That(sum, Is.EqualTo(7)); + using (var types = new Types()) + { + 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 void GetEmployeeNameFromOrgTest() [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 void TestConsumerOfEnumNestedInClass() [Test] public void TestChangePassedMappedTypeNonConstRefParam() { - using (TestMappedTypeNonConstRefParamConsumer consumer = new TestMappedTypeNonConstRefParamConsumer()) + using (var consumer = new TestMappedTypeNonConstRefParamConsumer()) { string val = "Initial"; consumer.ChangePassedMappedTypeNonConstRefParam(ref val); diff --git a/tests/CSharp/CSharp.Tests.cs b/tests/CSharp/CSharp.Tests.cs index f06c4e1f36..b2f18795a0 100644 --- a/tests/CSharp/CSharp.Tests.cs +++ b/tests/CSharp/CSharp.Tests.cs @@ -113,18 +113,24 @@ public void TestReturnCharPointer() [Test] public void TestIndexer() { - var foo = new Foo(); - - Assert.That(foo[0], Is.EqualTo(50)); - foo[0] = 250; - Assert.That(foo[0], Is.EqualTo(250)); + using (var foo = new Foo()) + { + Assert.That(foo[0], Is.EqualTo(50)); + foo[0] = 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(); - Assert.That(bar[0].A, Is.EqualTo(10)); - bar[0] = new Foo { A = 25 }; - Assert.That(bar[0].A, Is.EqualTo(25)); + using (var bar = new Bar()) + { + Assert.That(bar[0].A, Is.EqualTo(10)); + using (Foo foo = new Foo { A = 25 }) + { + bar[0] = foo; + Assert.That(bar[0].A, Is.EqualTo(25)); + } + } } [Test] @@ -143,8 +149,11 @@ public void TestMultipleInheritance() var bar = (IBar) baz; Assert.That(bar.Method, Is.EqualTo(2)); Assert.That(baz[0], Is.EqualTo(50)); - bar[0] = new Foo { A = 1000 }; - Assert.That(bar[0].A, Is.EqualTo(1000)); + using (Foo foo = new Foo { A = 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 void TestMultipleInheritance() [Test] public void TestProperties() { - var proprietor = new Proprietor(); - Assert.That(proprietor.Parent, Is.EqualTo(0)); - proprietor.Value = 20; - Assert.That(proprietor.Value, Is.EqualTo(20)); - proprietor.Prop = 50; - Assert.That(proprietor.Prop, Is.EqualTo(50)); + using (var proprietor = new Proprietor()) + { + Assert.That(proprietor.Parent, Is.EqualTo(0)); + proprietor.Value = 20; + Assert.That(proprietor.Value, Is.EqualTo(20)); + 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 void TestDestructors() CSharp.TestDestructors.InitMarker(); Assert.AreEqual(0, CSharp.TestDestructors.Marker); - var dtors = new TestDestructors(); - Assert.AreEqual(0xf00d, CSharp.TestDestructors.Marker); - dtors.Dispose(); + using (var dtors = new TestDestructors()) + { + Assert.AreEqual(0xf00d, CSharp.TestDestructors.Marker); + dtors.Dispose(); + } Assert.AreEqual(0xcafe, CSharp.TestDestructors.Marker); } [Test] public unsafe void TestArrayOfPointersToPrimitives() { - var bar = new Bar(); - var array = new IntPtr[1]; - int i = 5; - array[0] = new IntPtr(&i); - bar.ArrayOfPrimitivePointers = array; - Assert.That(i, Is.EqualTo(*(int*) bar.ArrayOfPrimitivePointers[0])); + using (var bar = new Bar()) + { + var array = new IntPtr[1]; + int i = 5; + array[0] = new IntPtr(&i); + bar.ArrayOfPrimitivePointers = array; + Assert.That(i, Is.EqualTo(*(int*) bar.ArrayOfPrimitivePointers[0])); + } } [Test] @@ -229,9 +244,11 @@ public void TestCopyConstructorValue() [Test] public void TestPropertiesConflictingWithMethod() { - var p = new P((IQux) new Qux()) { Test = true }; - Assert.That(p.Test, Is.True); - p.GetTest(); + using (var p = new P((IQux) new Qux()) { Test = true }) + { + Assert.That(p.Test, Is.True); + p.GetTest(); + } } [Test] @@ -310,43 +327,51 @@ public void TestQFlags() [Test] public void TestCopyCtor() { - Qux q1 = new Qux(); - for (int i = 0; i < q1.Array.Length; i++) + using (Qux q1 = new Qux()) { - q1.Array[i] = i; - } - Qux q2 = new Qux(q1); - for (int i = 0; i < q2.Array.Length; i++) - { - Assert.AreEqual(q1.Array[i], q2.Array[i]); + for (int i = 0; i < q1.Array.Length; i++) + { + q1.Array[i] = i; + } + using (Qux q2 = new Qux(q1)) + { + 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 }; - var new_values = new bool[5]; - for(int i = 0; i < new_values.Length; ++i) + using (Foo foo = new Foo { A = 10 }) { - 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 (MethodsWithDefaultValues m = foo) + using (Foo foo = new Foo { A = 10 }) { - 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 void TestNativeToManagedMapWithOwnObjects() [Test] public void TestCallingVirtualDtor() { - var callDtorVirtually = new CallDtorVirtually(); - var hasVirtualDtor1 = CallDtorVirtually.GetHasVirtualDtor1(callDtorVirtually); - hasVirtualDtor1.Dispose(); + using (var callDtorVirtually = new CallDtorVirtually()) + { + var hasVirtualDtor1 = CallDtorVirtually.GetHasVirtualDtor1(callDtorVirtually); + hasVirtualDtor1.Dispose(); + } Assert.That(CallDtorVirtually.Destroyed, Is.True); } @@ -451,43 +478,46 @@ public void TestParamTypeToInterfacePass() 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); - var p = obj.ReturnPrimTypePtr(); - Assert.AreEqual(0, p[0]); - Assert.AreEqual(0, p[1]); - Assert.AreEqual(0, p[2]); + using (var obj = new MultiOverloadPtrToRef(ref r)) + { + var p = obj.ReturnPrimTypePtr(); + Assert.AreEqual(0, p[0]); + Assert.AreEqual(0, p[1]); + Assert.AreEqual(0, p[2]); - obj.TakePrimTypePtr(ref *p); - Assert.AreEqual(100, p[0]); - Assert.AreEqual(200, p[1]); - Assert.AreEqual(300, p[2]); + obj.TakePrimTypePtr(ref *p); + Assert.AreEqual(100, p[0]); + Assert.AreEqual(200, p[1]); + Assert.AreEqual(300, p[2]); - int[] array = { 1, 2, 3 }; - fixed (int* p1 = array) - { - obj.TakePrimTypePtr(ref *p1); - Assert.AreEqual(100, p1[0]); - Assert.AreEqual(200, p1[1]); - Assert.AreEqual(300, p1[2]); - } + int[] array = { 1, 2, 3 }; + fixed (int* p1 = array) + { + obj.TakePrimTypePtr(ref *p1); + Assert.AreEqual(100, p1[0]); + Assert.AreEqual(200, p1[1]); + Assert.AreEqual(300, p1[2]); + } - Assert.AreEqual(100, array[0]); - Assert.AreEqual(200, array[1]); - Assert.AreEqual(300, array[2]); + Assert.AreEqual(100, array[0]); + Assert.AreEqual(200, array[1]); + Assert.AreEqual(300, array[2]); - float pThree = 0; - var refInt = 0; - obj.FuncPrimitivePtrToRef(ref refInt, null, ref pThree); - obj.FuncPrimitivePtrToRefWithDefVal(ref refInt, null, null, ref refInt); - obj.FuncPrimitivePtrToRefWithMultiOverload(ref refInt, null, null, ref refInt); + float pThree = 0; + var refInt = 0; + obj.FuncPrimitivePtrToRef(ref refInt, null, ref pThree); + obj.FuncPrimitivePtrToRefWithDefVal(ref refInt, null, null, ref refInt); + obj.FuncPrimitivePtrToRefWithMultiOverload(ref refInt, null, null, ref refInt); + } } [Test] @@ -506,23 +536,37 @@ public void TestFixedArrayRefType() 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(() => 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(); - ITestParamToInterfacePassBaseTwo interfaceType = interfaceClassObj; - var obj = new TestOutTypeInterfaces(); - obj.FuncTryInterfaceTypeOut(out interfaceType); - ITestParamToInterfacePassBaseTwo interfaceTypePtr; - obj.FuncTryInterfaceTypePtrOut(out interfaceTypePtr); + using (var interfaceClassObj = new TestParamToInterfacePassBaseTwo()) + { + ITestParamToInterfacePassBaseTwo interfaceType = interfaceClassObj; + using (var obj = new TestOutTypeInterfaces()) + { + obj.FuncTryInterfaceTypeOut(out interfaceType); + ITestParamToInterfacePassBaseTwo interfaceTypePtr; + obj.FuncTryInterfaceTypePtrOut(out interfaceTypePtr); + } + } } [Test] @@ -1030,9 +1074,11 @@ public void TestGenerationOfIncompleteClasses() [Test] public void TestForwardDeclaredStruct() { - var forwardDeclaredStruct = CSharp.CSharp.CreateForwardDeclaredStruct(10); - var i = CSharp.CSharp.UseForwardDeclaredStruct(forwardDeclaredStruct); - Assert.AreEqual(forwardDeclaredStruct.I, i); + using (var forwardDeclaredStruct = CSharp.CSharp.CreateForwardDeclaredStruct(10)) + { + var i = CSharp.CSharp.UseForwardDeclaredStruct(forwardDeclaredStruct); + Assert.AreEqual(forwardDeclaredStruct.I, i); + } } [Test] diff --git a/tests/Common/Common.Tests.cs b/tests/Common/Common.Tests.cs index 16ca283d1b..1edfb4a260 100644 --- a/tests/Common/Common.Tests.cs +++ b/tests/Common/Common.Tests.cs @@ -74,165 +74,179 @@ public unsafe void TestCodeGeneration() [Test] public void TestHello() { - var hello = new Hello(); - hello.PrintHello("Hello world"); + using (var hello = new Hello()) + { + hello.PrintHello("Hello world"); - Assert.That(hello.Add(1, 1), Is.EqualTo(2)); - Assert.That(hello.Add(5, 5), Is.EqualTo(10)); + Assert.That(hello.Add(1, 1), Is.EqualTo(2)); + Assert.That(hello.Add(5, 5), Is.EqualTo(10)); - Assert.IsTrue(hello.Test1(3, 3.0f)); - Assert.IsFalse(hello.Test1(2, 3.0f)); + Assert.IsTrue(hello.Test1(3, 3.0f)); + Assert.IsFalse(hello.Test1(2, 3.0f)); - var foo = new Foo { A = 4, B = 7 }; - 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.AddFooRef(foo), Is.EqualTo(11)); - unsafe - { - var pointer = foo.SomePointer; - var pointerPointer = foo.SomePointerPointer; - for (int i = 0; i < 4; i++) + var foo = new Foo { A = 4, B = 7 }; + 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.AddFooRef(foo), Is.EqualTo(11)); + unsafe { - Assert.AreEqual(i, pointer[i]); - Assert.AreEqual(i, (*pointerPointer)[i]); + var pointer = foo.SomePointer; + 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 }; - Assert.That(hello.AddBar(bar), Is.EqualTo(11)); - Assert.That(bar.RetItem1(), Is.EqualTo(Bar.Item.Item1)); + var bar = new Bar { A = 4, B = 7 }; + Assert.That(hello.AddBar(bar), Is.EqualTo(11)); + Assert.That(bar.RetItem1(), Is.EqualTo(Bar.Item.Item1)); - var retFoo = hello.RetFoo(7, 2.0f); - Assert.That(retFoo.A, Is.EqualTo(7)); - Assert.That(retFoo.B, Is.EqualTo(2.0)); + using (var retFoo = hello.RetFoo(7, 2.0f)) + { + 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 }; - Assert.That(hello.AddFoo(foo2), Is.EqualTo(6)); - Assert.That(hello.AddFoo2(foo2), Is.EqualTo(9)); + 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)); + } - var bar2 = new Bar2 { A = 4, B = 7, C = 3 }; - Assert.That(hello.AddBar2(bar2), Is.EqualTo(14)); + var bar2 = new Bar2 { A = 4, B = 7, C = 3 }; + Assert.That(hello.AddBar2(bar2), Is.EqualTo(14)); - Assert.That(hello.RetEnum(Enum.A), Is.EqualTo(0)); - Assert.That(hello.RetEnum(Enum.B), Is.EqualTo(2)); - Assert.That(hello.RetEnum(Enum.C), Is.EqualTo(5)); - //Assert.That(hello.RetEnum(Enum.D), Is.EqualTo(-2147483648)); - Assert.That(hello.RetEnum(Enum.E), Is.EqualTo(1)); - Assert.That(hello.RetEnum(Enum.F), Is.EqualTo(-9)); + Assert.That(hello.RetEnum(Enum.A), Is.EqualTo(0)); + Assert.That(hello.RetEnum(Enum.B), Is.EqualTo(2)); + Assert.That(hello.RetEnum(Enum.C), Is.EqualTo(5)); + //Assert.That(hello.RetEnum(Enum.D), Is.EqualTo(-2147483648)); + Assert.That(hello.RetEnum(Enum.E), Is.EqualTo(1)); + Assert.That(hello.RetEnum(Enum.F), Is.EqualTo(-9)); + } } [Test] public void TestPrimitiveConstCharStringInOut() { - var hello = new Hello(); - - string str; - hello.StringOut(out str); - Assert.That(str, Is.EqualTo("HelloStringOut")); - hello.StringOutRef(out str); - Assert.That(str, Is.EqualTo("HelloStringOutRef")); - str = "Hello"; - hello.StringInOut(ref str); - Assert.That(str, Is.EqualTo("StringInOut")); - str = "Hello"; - hello.StringInOutRef(ref str); - Assert.That(str, Is.EqualTo("StringInOutRef")); - hello.StringTypedef(str); + using (var hello = new Hello()) + { + hello.StringOut(out string str); + Assert.That(str, Is.EqualTo("HelloStringOut")); + hello.StringOutRef(out str); + Assert.That(str, Is.EqualTo("HelloStringOutRef")); + str = "Hello"; + hello.StringInOut(ref str); + Assert.That(str, Is.EqualTo("StringInOut")); + str = "Hello"; + hello.StringInOutRef(ref str); + Assert.That(str, Is.EqualTo("StringInOutRef")); + hello.StringTypedef(str); + } } [Test] public void TestPrimitiveOutParameters() { - var hello = new Hello(); - - float f; - Assert.That(hello.TestPrimitiveOut(out f), Is.True); - Assert.That(f, Is.EqualTo(10.0f)); + using (var hello = new Hello()) + { + Assert.That(hello.TestPrimitiveOut(out float f), Is.True); + Assert.That(f, Is.EqualTo(10.0f)); + } } [Test] public void TestPrimitiveOutRefParameters() { - var hello = new Hello(); - - float f; - Assert.That(hello.TestPrimitiveOutRef(out f), Is.True); - Assert.That(f, Is.EqualTo(10.0f)); + using (var hello = new Hello()) + { + Assert.That(hello.TestPrimitiveOutRef(out float f), Is.True); + Assert.That(f, Is.EqualTo(10.0f)); + } } public void TestPrimitiveInOutParameters() { - var hello = new Hello(); - - int i = 10; - Assert.That(hello.TestPrimitiveInOut(ref i), Is.True); - Assert.That(i, Is.EqualTo(20)); + using (var hello = new Hello()) + { + int i = 10; + Assert.That(hello.TestPrimitiveInOut(ref i), Is.True); + Assert.That(i, Is.EqualTo(20)); + } } [Test] public void TestPrimitiveInOutRefParameters() { - var hello = new Hello(); - - int i = 10; - Assert.That(hello.TestPrimitiveInOutRef(ref i), Is.True); - Assert.That(i, Is.EqualTo(20)); + using (var hello = new Hello()) + { + int i = 10; + Assert.That(hello.TestPrimitiveInOutRef(ref i), Is.True); + Assert.That(i, Is.EqualTo(20)); + } } [Test] public void TestEnumOut() { - var hello = new Hello(); - - Enum e; - hello.EnumOut((int) Enum.C, out e); - Assert.That(e, Is.EqualTo(Enum.C)); + using (var hello = new Hello()) + { + hello.EnumOut((int) Enum.C, out Enum e); + Assert.That(e, Is.EqualTo(Enum.C)); + } } [Test] public void TestEnumOutRef() { - var hello = new Hello(); - - Enum e; - hello.EnumOutRef((int) Enum.C, out e); - Assert.That(e, Is.EqualTo(Enum.C)); + using (var hello = new Hello()) + { + hello.EnumOutRef((int) Enum.C, out Enum e); + Assert.That(e, Is.EqualTo(Enum.C)); + } } [Test] public void TestEnumInOut() { - var hello = new Hello(); - - var e = Enum.E; - hello.EnumInOut(ref e); - Assert.That(e, Is.EqualTo(Enum.F)); + using (var hello = new Hello()) + { + var e = Enum.E; + hello.EnumInOut(ref e); + Assert.That(e, Is.EqualTo(Enum.F)); + } } [Test] public void TestEnumInOutRef() { - var hello = new Hello(); - - var e = Enum.E; - hello.EnumInOut(ref e); - Assert.That(e, Is.EqualTo(Enum.F)); + using (var hello = new Hello()) + { + var e = Enum.E; + hello.EnumInOut(ref e); + Assert.That(e, Is.EqualTo(Enum.F)); + } } [Test] public void TestNullRef() { - var hello = new Hello(); - Assert.That(hello.RetNull(), Is.Null); + using (var hello = new Hello()) + { + Assert.That(hello.RetNull(), Is.Null); + } } [Test] public void TestAmbiguous() { - var def = new DefaultParameters(); - def.Foo(1, 2); - def.Bar(); + using (var def = new DefaultParameters()) + { + def.Foo(1, 2); + def.Bar(); + } using (Foo foo = new Foo()) { Common.HasPointerParam(foo, 0); @@ -243,52 +257,66 @@ public void TestAmbiguous() [Test] public void TestLeftShiftOperator() { - var foo2 = new Foo2 { C = 2 }; - Foo2 result = foo2 << 3; - foo2.TestKeywordParam(IntPtr.Zero, Bar.Item.Item1, 1); - Assert.That(result.C, Is.EqualTo(16)); + using (var foo2 = new Foo2 { C = 2 }) + { + Foo2 result = foo2 << 3; + foo2.TestKeywordParam(IntPtr.Zero, Bar.Item.Item1, 1); + Assert.That(result.C, Is.EqualTo(16)); + } } [Test] public void TestAbstractReturnType() { - var returnsAbstractFoo = new ReturnsAbstractFoo(); - var abstractFoo = returnsAbstractFoo.Foo; - Assert.AreEqual(abstractFoo.PureFunction(1), 5); - Assert.AreEqual(abstractFoo.PureFunction1, 10); - var ok = false; - Assert.AreEqual(abstractFoo.PureFunction2(ref ok), 15); + using (var returnsAbstractFoo = new ReturnsAbstractFoo()) + { + var abstractFoo = returnsAbstractFoo.Foo; + Assert.AreEqual(abstractFoo.PureFunction(1), 5); + Assert.AreEqual(abstractFoo.PureFunction1, 10); + var ok = false; + Assert.AreEqual(abstractFoo.PureFunction2(ref ok), 15); + } } [Test] public void TestANSI() { - var foo = new Foo(); - Assert.That(foo.ANSI, Is.EqualTo("ANSI")); + using (var foo = new Foo()) + { + Assert.That(foo.ANSI, Is.EqualTo("ANSI")); + } } [Test] public void TestMoveOperatorToClass() { // Unary operator - var unary = new TestMoveOperatorToClass() { A = 4, B = 7 }; - var unaryMinus = -unary; + using (var unary = new TestMoveOperatorToClass() { A = 4, B = 7 }) + { + var unaryMinus = -unary; - Assert.That(unaryMinus.A, Is.EqualTo(-unary.A)); - Assert.That(unaryMinus.B, Is.EqualTo(-unary.B)); + Assert.That(unaryMinus.A, Is.EqualTo(-unary.A)); + Assert.That(unaryMinus.B, Is.EqualTo(-unary.B)); + } // Binary operator - var bin = new TestMoveOperatorToClass { A = 4, B = 7 }; - var bin1 = new TestMoveOperatorToClass { A = 5, B = 10 }; - var binSum = bin + bin1; + using (var bin = new TestMoveOperatorToClass { A = 4, B = 7 }) + { + 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.B, Is.EqualTo(bin.B + bin1.B)); + Assert.That(binSum.A, Is.EqualTo(bin.A + bin1.A)); + Assert.That(binSum.B, Is.EqualTo(bin.B + bin1.B)); + } + } // Multiple argument operator - var multiArg = new TestMoveOperatorToClass { A = 4, B = 7 }; - var multiArgStar = multiArg * 2; - Assert.That(multiArgStar, Is.EqualTo(8)); + using (var multiArg = new TestMoveOperatorToClass { A = 4, B = 7 }) + { + var multiArgStar = multiArg * 2; + Assert.That(multiArgStar, Is.EqualTo(8)); + } } [Test] @@ -302,10 +330,12 @@ public void TestMoveFunctionToClass() public void TestMethodWithFixedInstance() { var bar = new Bar2 { A = 1, B = 2, C = 3 }; - Foo2 foo = bar.NeedFixedInstance; - Assert.AreEqual(foo.A, 1); - Assert.AreEqual(foo.B, 2); - Assert.AreEqual(foo.C, 3); + using (Foo2 foo = bar.NeedFixedInstance) + { + Assert.AreEqual(foo.A, 1); + Assert.AreEqual(foo.B, 2); + Assert.AreEqual(foo.C, 3); + } } [Test] @@ -331,18 +361,20 @@ public void TestConversionOperator() [Test] public void TestDelegates() { - var delegates = new TestDelegates(); - var doubleSum = delegates.A(2) + delegates.B(2); - Assert.AreEqual(8, doubleSum); + using (var delegates = new TestDelegates()) + { + var doubleSum = delegates.A(2) + delegates.B(2); + Assert.AreEqual(8, doubleSum); - var stdcall = delegates.StdCall(i => i); - Assert.AreEqual(1, stdcall); + var stdcall = delegates.StdCall(i => i); + Assert.AreEqual(1, stdcall); - var cdecl = delegates.CDecl(i => i); - Assert.AreEqual(1, cdecl); + var cdecl = delegates.CDecl(i => i); + Assert.AreEqual(1, cdecl); - var emptydelegeate = delegates.MarshalNullDelegate; - Assert.AreEqual(emptydelegeate, null); + var emptydelegeate = delegates.MarshalNullDelegate; + Assert.AreEqual(emptydelegeate, null); + } } [Test] @@ -423,10 +455,12 @@ public void TestCopyConstructor() [Test] public void TestCharMarshalling() { - Foo2 foo2 = new Foo2(); - for (char c = char.MinValue; c <= sbyte.MaxValue; c++) - Assert.That(foo2.TestCharMarshalling(c), Is.EqualTo(c)); - Assert.Catch(() => foo2.TestCharMarshalling('ж')); + using (Foo2 foo2 = new Foo2()) + { + for (char c = char.MinValue; c <= sbyte.MaxValue; c++) + Assert.That(foo2.TestCharMarshalling(c), Is.EqualTo(c)); + Assert.Catch(() => foo2.TestCharMarshalling('ж')); + } } [Test] @@ -545,66 +579,78 @@ public void TestProperties() public void TestVariable() { // Test field property - var @var = new TestVariables(); - @var.SetValue(10); + using (var @var = new TestVariables()) + { + @var.SetValue(10); + } Assert.That(TestVariables.VALUE, Is.EqualTo(10)); } [Test] public void TestWideStrings() { - var ws = new TestWideStrings(); - var s = ws.WidePointer; - Assert.That(ws.WidePointer, Is.EqualTo("Hello")); - Assert.That(ws.WideNullPointer, Is.EqualTo(null)); + using (var ws = new TestWideStrings()) + { + var s = ws.WidePointer; + 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); - Assert.That(arrays.Value, Is.EqualTo(MyEnum.A)); + using (var arrays = new TestArraysPointers(ref values, 1)) + { + Assert.That(arrays.Value, Is.EqualTo(MyEnum.A)); + } } [Test] public unsafe void TestGetterSetterToProperties() { - var @class = new TestGetterSetterToProperties(); - Assert.That(@class.Width, Is.EqualTo(640)); - Assert.That(@class.Height, Is.EqualTo(480)); + using (var @class = new TestGetterSetterToProperties()) + { + Assert.That(@class.Width, Is.EqualTo(640)); + Assert.That(@class.Height, Is.EqualTo(480)); + } } [Test] public unsafe void TestSingleArgumentCtorToCastOperator() { - var classA = new ClassA(10); - ClassB classB = classA; - Assert.AreEqual(classA.Value, classB.Value); - ClassC classC = (ClassC) classB; - Assert.AreEqual(classB.Value, classC.Value); + using (var classA = new ClassA(10)) + { + ClassB classB = classA; + Assert.AreEqual(classA.Value, classB.Value); + ClassC classC = (ClassC) classB; + Assert.AreEqual(classB.Value, classC.Value); + } } [Test] public unsafe void TestFieldRef() { - var classD = new ClassD(10); - var fieldRef = classD.Field; - fieldRef.Value = 20; - Assert.AreEqual(20, classD.Field.Value); + using (var classD = new ClassD(10)) + { + var fieldRef = classD.Field; + 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 unsafe void TestNullPtrType() public void TestCtorByValue() { var bar = new Bar { A = 4, B = 5.5f }; - var foo2 = new Foo2 { C = 4, ValueTypeField = bar }; - var result = foo2 << 2; - Assert.AreEqual(foo2.C << 2, result.C); - Assert.AreEqual(bar.A << 2, result.ValueTypeField.A); - Assert.AreEqual(bar.B, result.ValueTypeField.B); + using (var foo2 = new Foo2 { C = 4, ValueTypeField = bar }) + { + var result = foo2 << 2; + Assert.AreEqual(foo2.C << 2, result.C); + 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(); - int value = testDelegates.MarshalAnonymousDelegate(i => i * 2); - Assert.AreEqual(2, value); - int value5 = testDelegates.MarshalAnonymousDelegate5(i => i * 2); - Assert.AreEqual(4, value5); - int value6 = testDelegates.MarshalAnonymousDelegate6(i => i * 2); - Assert.AreEqual(6, value6); + using (var testDelegates = new TestDelegates()) + { + int value = testDelegates.MarshalAnonymousDelegate(i => i * 2); + Assert.AreEqual(2, value); + int value5 = testDelegates.MarshalAnonymousDelegate5(i => i * 2); + Assert.AreEqual(4, value5); + int value6 = testDelegates.MarshalAnonymousDelegate6(i => i * 2); + Assert.AreEqual(6, value6); + } } [Test] public void TestGetAnonymousDelegate() { - var testDelegates = new TestDelegates(); - var @delegate = testDelegates.MarshalAnonymousDelegate4; - int value = @delegate.Invoke(1); - Assert.AreEqual(2, value); + using (var testDelegates = new TestDelegates()) + { + var @delegate = testDelegates.MarshalAnonymousDelegate4; + int value = @delegate.Invoke(1); + Assert.AreEqual(2, value); + } } [Test] public void TestFixedArrays() { - var foo = new Foo(); - var array = new[] { 1, 2, 3 }; - foo.FixedArray = array; - for (int i = 0; i < foo.FixedArray.Length; i++) - Assert.That(array[i], Is.EqualTo(foo.FixedArray[i])); + using (var foo = new Foo()) + { + var array = new[] { 1, 2, 3 }; + foo.FixedArray = array; + 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,28 @@ public void TestEqualityOperator() [Test] public void TestFriendOperator() { - HasFriend h1 = 5; - HasFriend h2 = 10; - Assert.AreEqual(15, (h1 + h2).M); - Assert.AreEqual(-5, (h1 - h2).M); + using (HasFriend h1 = 5) + { + using (HasFriend h2 = 10) + { + 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); + differentConstOverloads1.Dispose(); Assert.IsTrue(differentConstOverloads == 5); Assert.IsFalse(differentConstOverloads == 4); Assert.IsTrue(differentConstOverloads == "abcde"); Assert.IsFalse(differentConstOverloads == "abcd"); + differentConstOverloads.Dispose(); } [Test] @@ -736,7 +803,10 @@ public void TestRenamingVariableNamedAfterKeyword() [Test] public void TestMarshallingEmptyType() { - var empty = new ReturnsEmpty().Empty; + using (ReturnsEmpty returnsEmpty = new ReturnsEmpty()) + { + returnsEmpty.Empty.Dispose(); + } } [Test] diff --git a/tests/NamespacesDerived/NamespacesDerived.Tests.cs b/tests/NamespacesDerived/NamespacesDerived.Tests.cs index e7cd98ca62..0b2e147af1 100644 --- a/tests/NamespacesDerived/NamespacesDerived.Tests.cs +++ b/tests/NamespacesDerived/NamespacesDerived.Tests.cs @@ -13,9 +13,11 @@ public void TestCodeGeneration() [Test] public void TestNonRenamedMethod() { - var derived = new Derived(); - var parent = derived.Parent; - derived.parent(0); + using (var derived = new Derived()) + { + var parent = derived.Parent; + derived.parent(0); + } } [Test] diff --git a/tests/VTables/VTables.Tests.cs b/tests/VTables/VTables.Tests.cs index 9395f8d8f6..974bf4130e 100644 --- a/tests/VTables/VTables.Tests.cs +++ b/tests/VTables/VTables.Tests.cs @@ -36,14 +36,18 @@ public class VTablesTests : GeneratorTestFixture [Test] public void TestFoo() { - var foo = new Foo(); - Assert.That(foo.vfoo, Is.EqualTo(5)); - Assert.That(foo.Vbar, Is.EqualTo(5)); - Assert.That(foo.CallFoo(), Is.EqualTo(7)); - Assert.That(foo.CallVirtualWithParameter(6514), Is.EqualTo(6514 + 1)); + using (var foo = new Foo()) + { + Assert.That(foo.vfoo, Is.EqualTo(5)); + Assert.That(foo.Vbar, Is.EqualTo(5)); + Assert.That(foo.CallFoo(), Is.EqualTo(7)); + Assert.That(foo.CallVirtualWithParameter(6514), Is.EqualTo(6514 + 1)); + } - var foo2 = new FooDerived(); - Assert.That(foo2.CallFoo(), Is.EqualTo(12)); + using (var foo2 = new FooDerived()) + { + Assert.That(foo2.CallFoo(), Is.EqualTo(12)); + } } void TestVirtualFunction(BaseClassVirtual obj, int actual) @@ -60,23 +64,32 @@ public void TestVirtualFuntionRetVal() { // Virtual Functions Object Slicing case // See http://stackoverflow.com/questions/3479712/virtual-functions-object-slicing - var baseVirtual = BaseClassVirtual.Base; - TestVirtualFunction(baseVirtual, 5); + using (var baseVirtual = BaseClassVirtual.Base) + { + TestVirtualFunction(baseVirtual, 5); + } BaseClassVirtual baseClass = new DerivedClassVirtual(); TestVirtualFunction(baseClass, 10); + baseClass.Dispose(); - var basePtr = BaseClassVirtual.BasePtr; - TestVirtualFunction(basePtr, 10); + using (var basePtr = BaseClassVirtual.BasePtr) + { + TestVirtualFunction(basePtr, 10); + } - var managed = new ManagedDerivedClassVirtual(); - TestVirtualFunction(managed, 15); + using (var managed = new ManagedDerivedClassVirtual()) + { + TestVirtualFunction(managed, 15); - baseClass = managed; - TestVirtualFunction(baseClass, 15); + baseClass = managed; + TestVirtualFunction(baseClass, 15); + } - var retBase = new ManagedDerivedClassVirtualRetBase(); - TestVirtualFunction(retBase, 10); + using (var retBase = new ManagedDerivedClassVirtualRetBase()) + { + TestVirtualFunction(retBase, 10); + } } [Test]