Add tests for virtual dispatch and inheritance

tests/ByValTests.cs

@@ -6,10 +6,10 @@ using Tests.Support;
 namespace Tests {
 
 	[TestFixture]
-	public class AbiTests {
+	public class ByValTests {
 
 		[Test]
-		public void test_0_class_return ()
+		public void TestClassReturn ()
 		{
 			// Section 3.1.4:
 			// Classes with non-default copy ctors/destructors are returned using a hidden
@@ -27,7 +27,7 @@ namespace Tests {
 
 		// An object as ref argument
 		[Test]
-		public void test_0_class_arg ()
+		public void TestClassArg ()
 		{
 			var c1 = new Class (4);
 			var c2 = new Class (5);
@@ -38,7 +38,7 @@ namespace Tests {
 
 		// A null object as ref argument
 		[Test]
-		public void test_0_class_arg_null ()
+		public void TestClassArgNull ()
 		{
 			var c1 = new Class (4);
 			Assert.That (c1.IsNull (null), "#1");
@@ -46,7 +46,7 @@ namespace Tests {
 
 		// An object as byval argument
 		[Test]
-		public void test_0_class_arg_byval ()
+		public void TestClassArgByval ()
 		{
 			var c1 = new Class (4);
 			var c2 = new Class (5);
@@ -58,7 +58,7 @@ namespace Tests {
 		// A null object as byval argument
 		[Test]
 		[ExpectedException (typeof (ArgumentException))]
-		public void test_0_class_arg_byval_null ()
+		public void TestClassArgByvalNull ()
 		{
 			var c1 = new Class (4);
 			c1.CopyFromValue (null);

tests/Makefile.am

@@ -6,41 +6,47 @@ INTEROP_DLL = \
 
 TEST_DLL = $(BUILD_DIR)/Test.dll
 
-HDR = \
-	Native/ByValTests.h
-
 NATIVE = \
-	Native/NUnit.cpp \
-	Native/ByValTests.cpp
+	ByValTests \
+	VirtualTests
 
 MANAGED =  \
 	ByValTests.cs \
 	Support/CppMockObject.cs \
-	Support/CppNUnitAsserts.cs
+	Support/CppNUnitAsserts.cs \
+	VirtualTests.cs
 	
 REFERENCES =  \
 	-pkg:mono-nunit
 
+NATIVE_SRC = \
+ 	$(addprefix Native/,$(NATIVE))
+
 all: $(TEST_DLL)
 
-test.xml: $(HDR)
-	gccxml -fxml=$@ --gccxml-cxxflags -c $(HDR)
+%.cpp: %.h
+
+%.xml: $(addsuffix .h,$(NATIVE_SRC))
+	gccxml -fxml=$@ --gccxml-cxxflags -c Native/$*.h
 
-$(BUILD_DIR)/libTest.so: $(HEADERS) $(NATIVE)
-	g++ -fPIC --shared -m32 -o $@ $(NATIVE)
+$(BUILD_DIR)/libTest.so: $(addsuffix .cpp,$(NATIVE_SRC))
+	$(CXX) -fPIC --shared -m32 -o $@ $^
 
-$(BUILD_DIR)/libTest-inline.so: $(HEADERS) $(NATIVE)
-	g++ -fPIC --shared -m32 -fkeep-inline-functions -o $@ $(NATIVE)
+$(BUILD_DIR)/libTest-inline.so: $(addsuffix .cpp,$(NATIVE_SRC))
+	$(CXX) -fPIC --shared -m32 -fkeep-inline-functions -o $@ $^
 
-generated: test.xml
+generated: $(addsuffix .xml,$(NATIVE))
 	$(RM) -r generated
-	mono --debug $(BUILD_DIR)/generator.exe -o=$@ -ns=Tests -lib=Test -inline=surrogatelib test.xml
+	$(foreach X,$?, \
+		mono --debug $(BUILD_DIR)/generator.exe -o=$@ -ns=Tests -lib=Test -inline=surrogatelib $(X) && \
+	) \
+	echo Bindings generated successfully.
 
 $(TEST_DLL): generated $(MANAGED) $(BUILD_DIR)/libTest.so $(BUILD_DIR)/libTest-inline.so
 	mcs -debug -out:$@ -target:library -unsafe $(REFERENCES) -r:$(INTEROP_DLL) generated/*.cs $(MANAGED)
 
 clean:
-	$(RM) -rf $(TEST_DLL) generated $(BUILD_DIR)/libTest.so $(BUILD_DIR)/libTest-inline.so test.xml
+	$(RM) -rf $(TEST_DLL) generated $(BUILD_DIR)/libTest.so $(BUILD_DIR)/libTest-inline.so $(addsuffix .xml,$(NATIVE))
 
 run: $(TEST_DLL)
 	nunit-console -nologo $(TEST_DLL)

tests/Native/VirtualTests.cpp

@@ -0,0 +1,63 @@
+
+#include "VirtualTests.h"
+
+NumberClass::NumberClass (int n)
+	: num (n)
+{
+}
+int NumberClass::Number () const
+{
+	return this->num;
+}
+int NumberClass::NegativeNumber () const
+{
+	return -(this->num);
+}
+
+
+AdderClass::AdderClass (int n)
+	: NumberClass (n)
+{
+}
+void AdderClass::Add (int n)
+{
+	this->num += n;
+}
+
+AdderClassWithVirtualBase::AdderClassWithVirtualBase (int n)
+	: NumberClass (n)
+{
+}
+void AdderClassWithVirtualBase::Add (int n)
+{
+	this->num += n;
+}
+
+
+MultiplierClass::MultiplierClass (int n)
+	: NumberClass (n)
+{
+}
+void MultiplierClass::Multiply (int n)
+{
+	this->num *= n;
+}
+
+MultiplierClassWithVirtualBase::MultiplierClassWithVirtualBase (int n)
+	: NumberClass (n)
+{
+}
+void MultiplierClassWithVirtualBase::Multiply (int n)
+{
+	this->num *= n;
+}
+
+
+ClassThatOverridesStuff::ClassThatOverridesStuff (int num, int my)
+	: NumberClass (num), myNum (my)
+{
+}
+int ClassThatOverridesStuff::Number () const
+{
+	return this->myNum;
+}

tests/Native/VirtualTests.h

@@ -0,0 +1,51 @@
+
+class NumberClass {
+protected:
+	int num;
+public:
+	NumberClass (int n);
+	virtual int Number () const;
+	virtual int NegativeNumber () const;
+};
+
+class AdderClass : public NumberClass {
+public:
+	AdderClass (int n);
+	virtual void Add (int n);
+};
+class AdderClassWithVirtualBase : public virtual NumberClass {
+public:
+	AdderClassWithVirtualBase (int n);
+	virtual void Add (int n);
+};
+
+class MultiplierClass : public NumberClass {
+public:
+	MultiplierClass (int n);
+	virtual void Multiply (int n);
+};
+class MultiplierClassWithVirtualBase : public virtual NumberClass {
+public:
+	MultiplierClassWithVirtualBase (int n);
+	virtual void Multiply (int n);
+};
+
+class ClassWithNonVirtualBases : public AdderClass, public MultiplierClass {
+public:
+	// num is not shared between AdderClass and MultiplierClass; Add and Multiply should operate on different numbers
+	ClassWithNonVirtualBases (int addN, int multN) : AdderClass (addN), MultiplierClass (multN) {}
+};
+class ClassWithVirtualBases : public AdderClassWithVirtualBase, public MultiplierClassWithVirtualBase {
+public:
+	// num is shared between AdderClass and MultiplierClass; Add and Multiply should both operate on n
+	ClassWithVirtualBases (int n) : NumberClass (n-2), AdderClassWithVirtualBase (n-1), MultiplierClassWithVirtualBase (n) {}
+};
+
+
+class ClassThatOverridesStuff : public NumberClass {
+protected:
+	int myNum;
+public:
+	ClassThatOverridesStuff (int num, int my);
+	virtual int Number () const;
+};

tests/Tests.csproj

@@ -53,6 +53,7 @@
     <Compile Include="Support\CppMockObject.cs" />
     <Compile Include="Support\CppNUnitAsserts.cs" />
     <Compile Include="ByValTests.cs" />
+    <Compile Include="VirtualTests.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>
@@ -71,6 +72,8 @@
     <None Include="Native\NUnit.h" />
     <None Include="Native\ByValTests.cpp" />
     <None Include="Native\ByValTests.h" />
+    <None Include="Native\VirtualTests.h" />
+    <None Include="Native\VirtualTests.cpp" />
   </ItemGroup>
   <ProjectExtensions>
     <MonoDevelop>

tests/VirtualTests.cs

@@ -0,0 +1,83 @@
+using System;
+using NUnit.Framework;
+
+namespace Tests {
+
+	[TestFixture]
+	public class VirtualTests {
+
+		[Test]
+		public void TestVirtualCall ()
+		{
+			var cls = new NumberClass (5);
+			Assert.AreEqual (5, cls.Number, "#1");
+			Assert.AreEqual (-5, cls.NegativeNumber, "#2");
+		}
+
+		[Test]
+		public void TestVirtualCallOnBaseClass ()
+		{
+			var cls = new AdderClass (8);
+			Assert.AreEqual (8, cls.Number, "#1");
+
+			cls.Add (2);
+			Assert.AreEqual (10, ((NumberClass)cls).Number, "#2");
+		}
+
+		[Test]
+		[Ignore ("virtual inheritance not implemented yet")]
+		public void TestVirtualCallOnVirtualBaseClass ()
+		{
+			var cls = new AdderClassWithVirtualBase (8);
+			Assert.AreEqual (8, cls.Number, "#1");
+
+			cls.Add (2);
+			Assert.AreEqual (10, ((NumberClass)cls).Number, "#2");
+		}
+
+		[Test]
+		public void TestMultipleBases ()
+		{
+			var cls = new ClassWithNonVirtualBases (5, 3);
+			Assert.AreEqual (5, cls.Number, "#1");
+			Assert.AreEqual (3, ((MultiplierClass)cls).Number, "#2");
+
+			cls.Add (4);
+			Assert.AreEqual (9, cls.Number, "#3");
+			Assert.AreEqual (3, ((MultiplierClass)cls).Number, "#4");
+
+			cls.Multiply (10);
+			Assert.AreEqual (9, cls.Number, "#5");
+			Assert.AreEqual (30, ((MultiplierClass)cls).Number, "#6");
+		}
+
+		[Test]
+		[Ignore ("virtual inheritance not implemented yet")]
+		public void TestMultipleVirtualBases ()
+		{
+			var cls = new ClassWithVirtualBases (4);
+			Assert.AreEqual (4, cls.Number, "#1");
+			Assert.AreEqual (4, ((MultiplierClassWithVirtualBase)cls).Number, "#2");
+
+			cls.Add (5);
+			Assert.AreEqual (9, cls.Number, "#3");
+			Assert.AreEqual (9, ((MultiplierClassWithVirtualBase)cls).Number, "#4");
+
+			cls.Multiply (6);
+			Assert.AreEqual (30, cls.Number, "#5");
+			Assert.AreEqual (30, ((MultiplierClassWithVirtualBase)cls).Number, "#6");
+		}
+
+		[Test]
+		public void TestClassThatOverridesStuff ()
+		{
+			var cls = new ClassThatOverridesStuff (5, 3);
+			Assert.AreEqual (3, cls.Number, "#1");
+			Assert.AreEqual (3, ((NumberClass)cls).Number, "#2");
+			Assert.AreEqual (-5, cls.NegativeNumber, "#3");
+		}
+
+
+	}
+}
+