Browse Source

Removed old unused unit tests.

pull/226/merge
triton 11 years ago
parent
commit
f5992a970c
  1. 27
      tests/FieldTests.cs
  2. 166
      tests/InheritanceTests.cs
  3. 31
      tests/ManglingTests.cs
  4. 74
      tests/MarshalingTests.cs
  5. 8
      tests/Native/FieldTests.cpp
  6. 7
      tests/Native/FieldTests.h
  7. 79
      tests/Native/InheritanceTests.cpp
  8. 65
      tests/Native/InheritanceTests.h
  9. 33
      tests/Native/ManglingTests.cpp
  10. 22
      tests/Native/ManglingTests.h
  11. 36
      tests/Native/MarshalingTests.cpp
  12. 77
      tests/Native/MarshalingTests.h
  13. 21
      tests/Native/NUnit.cpp
  14. 114
      tests/Native/NUnit.h

27
tests/FieldTests.cs

@ -1,27 +0,0 @@ @@ -1,27 +0,0 @@
using System;
using NUnit.Framework;
namespace Tests {
[TestFixture]
public class FieldTests {
[Test]
public void TestReadCppObject ()
{
var hf1 = new HasField (1, null);
var hf2 = new HasField (2, hf1);
var hf3 = new HasField (3, hf2);
Assert.IsNull (hf1.other, "#1");
Assert.AreEqual (1, hf1.number);
Assert.AreSame (hf2.other, hf1, "#2");
Assert.AreEqual (1, hf2.other.number);
Assert.AreSame (hf3.other.other, hf1, "#3");
Assert.AreEqual (1, hf3.other.other.number, "#4");
}
}
}

166
tests/InheritanceTests.cs

@ -1,166 +0,0 @@ @@ -1,166 +0,0 @@
using System;
using NUnit.Framework;
namespace Tests {
[TestFixture]
public class InheritanceTests {
[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]
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.MultiplierClass.Multiply (10);
Assert.AreEqual (9, cls.Number, "#5");
Assert.AreEqual (30, ((MultiplierClass)cls).Number, "#6");
}
[Test]
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.MultiplierClassWithVirtualBase.Multiply (6);
Assert.AreEqual (30, cls.Number, "#5");
Assert.AreEqual (30, ((MultiplierClassWithVirtualBase)cls).Number, "#6");
}
[Test]
public void TestNativeOverride1 ()
{
var cls = new ClassThatOverridesStuff (5, 3);
Assert.AreEqual (3, cls.Number, "#1");
Assert.AreEqual (3, ((NumberClass)cls).Number, "#2");
Assert.AreEqual (-3, cls.NegativeNumber, "#3");
Assert.AreEqual (5, cls.BaseNumber, "#4");
}
[Test]
public void TestNativeOverride2 ()
{
var cls = ClassThatOverridesStuff.GetInstance (5, 3);
Assert.AreEqual (3, cls.Number, "#1");
Assert.AreEqual (3, ((NumberClass)cls).Number, "#2");
Assert.AreEqual (-3, cls.NegativeNumber, "#3");
// Assert.AreEqual (5, ((ClassThatOverridesStuff)cls).BaseNumber, "#4");
}
class ManagedOverride1 : NumberClass {
public ManagedOverride1 () : base (3)
{
}
public override int Number {
get {
return 25;
}
}
}
[Test]
public void TestManagedOverride1 ()
{
var cls = new ManagedOverride1 ();
Assert.AreEqual (-25, cls.NegativeNumber, "#1");
}
class ManagedOverride2 : ClassWithNonVirtualBases {
public ManagedOverride2 () : base (5, 3)
{
}
public override int Number {
get {
return 25;
}
}
// override virtual member inherited from non-primary base
protected override void MultiplierClass__Multiply (int n)
{
base.MultiplierClass__Multiply (10);
}
}
[Test]
public void TestManagedOverride2 ()
{
var cls = new ManagedOverride2 ();
Assert.AreEqual (-25, cls.NegativeNumber, "#1");
cls.MultiplierClass.Multiply (7);
Assert.AreEqual (30, ((MultiplierClass)cls).Number, "#3");
cls.CallMultiply (2);
Assert.AreEqual (25, cls.Number, "#2");
Assert.AreEqual (300, ((MultiplierClass)cls).Number, "#5");
}
[Test]
public void TestRoundtripManagedOverride ()
{
var managed = new ManagedOverride2 ();
var roundtripper = new ClassThatRoundtrips (7, managed);
// test primary base ptr from native
var cls = roundtripper.GetThis ();
Assert.AreSame (roundtripper, cls, "#1");
Assert.AreEqual (7, cls.Number, "#2");
// test non-primary base ptr from native
cls = roundtripper.GetThat ();
Assert.AreSame ((MultiplierClass)managed, cls, "#3");
Assert.AreEqual (3, cls.Number, "#4");
Assert.AreEqual (3, cls.Number, "#5");
cls.Multiply (0);
Assert.AreEqual (-30, cls.NegativeNumber, "#6");
// cast to non-primary subclass
Assert.IsNotNull (((ClassWithNonVirtualBases)cls) as ManagedOverride2, "#7");
}
}
}

31
tests/ManglingTests.cs

@ -1,31 +0,0 @@ @@ -1,31 +0,0 @@
using System;
using NUnit.Framework;
namespace Tests {
[TestFixture]
public class ManglingTests {
[Test]
public void TestCompression ()
{
Compression.Test1 (null, "foo", null, "bar");
}
[Test]
public void TestNamespaced ()
{
Ns1.Namespaced.Test1 ();
Ns1.Namespaced.Test2 (null);
}
[Test]
public void TestNamespaced2 ()
{
var cls = new Ns1.Ns2.Namespaced2 ();
cls.Test1 ();
cls.Test2 (null);
}
}
}

74
tests/MarshalingTests.cs

@ -1,74 +0,0 @@ @@ -1,74 +0,0 @@
using System;
using NUnit.Framework;
namespace Tests {
[TestFixture]
public class MarshalingTests {
[Test]
public void TestClassReturn ()
{
// Section 3.1.4:
// Classes with non-default copy ctors/destructors are returned using a hidden
// argument
var c = ClassWithCopyCtor.Return (42);
Assert.AreEqual (42, c.GetX (), "#1");
var c2 = ClassWithDtor.Return (43);
Assert.AreEqual (43, c2.GetX (), "#2");
// This class is returned normally
var c3 = ClassWithoutCopyCtor.Return (44);
Assert.AreEqual (44, c3.GetX (), "#3");
}
// An object as ref argument
[Test]
public void TestClassArg ()
{
var c1 = new Class (4);
var c2 = new Class (5);
c1.CopyTo (c2);
Assert.AreEqual (4, c2.GetX (), "#1");
}
// A null object as ref argument
[Test]
public void TestClassArgNull ()
{
var c1 = new Class (4);
Assert.That (c1.IsNull (null), "#1");
}
// An object as byval argument
[Test]
public void TestClassArgByval ()
{
var c1 = new Class (4);
var c2 = new Class (5);
c1.CopyFromValue (c2);
Assert.AreEqual (5, c1.GetX (), "#1");
}
// A null object as byval argument
[Test]
[ExpectedException (typeof (ArgumentException))]
public void TestClassArgByvalNull ()
{
var c1 = new Class (4);
c1.CopyFromValue (null);
}
[Test]
public void TestByRefReturn ()
{
var c1 = new Class (7);
Assert.AreEqual (7, c1.GetXRef ());
}
}
}

8
tests/Native/FieldTests.cpp

@ -1,8 +0,0 @@ @@ -1,8 +0,0 @@
#include "FieldTests.h"
HasField::HasField (int number, HasField* other)
{
this->number = number;
this->other = other;
}

7
tests/Native/FieldTests.h

@ -1,7 +0,0 @@ @@ -1,7 +0,0 @@
class HasField {
public:
int number;
HasField* other;
HasField (int number, HasField* other);
};

79
tests/Native/InheritanceTests.cpp

@ -1,79 +0,0 @@ @@ -1,79 +0,0 @@
#include "InheritanceTests.h"
NumberClass::NumberClass (int n)
: num (n)
{
}
int NumberClass::Number () const
{
return this->num;
}
int NumberClass::NegativeNumber () const
{
return -(this->Number ());
}
NumberClass::~NumberClass ()
{
this->num = 0;
}
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;
}
int ClassThatOverridesStuff::BaseNumber () const
{
return this->NumberClass::Number ();
}
ClassThatOverridesStuff::~ClassThatOverridesStuff ()
{
this->myNum = 0;
}
NumberClass* ClassThatOverridesStuff::GetInstance (int num, int my)
{
return new ClassThatOverridesStuff (num, my);
}

65
tests/Native/InheritanceTests.h

@ -1,65 +0,0 @@ @@ -1,65 +0,0 @@
class NumberClass {
protected:
int num;
public:
NumberClass (int n);
virtual int NegativeNumber () const;
virtual int Number () const;
virtual ~NumberClass ();
};
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) {}
virtual void CallMultiply (int n) { this->Multiply (n); }
};
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;
virtual ~ClassThatOverridesStuff ();
virtual int BaseNumber () const;
static NumberClass* GetInstance (int num, int my);
};
class ClassThatRoundtrips : public MultiplierClass {
protected:
MultiplierClass* that;
public:
ClassThatRoundtrips (int n, MultiplierClass* managed) : MultiplierClass (n) { this->that = managed; }
virtual MultiplierClass* GetThat () { return this->that; }
virtual MultiplierClass* GetThis () { return this; }
};

33
tests/Native/ManglingTests.cpp

@ -1,33 +0,0 @@ @@ -1,33 +0,0 @@
#include "ManglingTests.h"
#include <stdio.h>
void Compression::Test1 (const Compression* a1, const char* a2, const Compression* a3, const char* a4)
{
printf ("Compression::Test1");
}
void Ns1::Namespaced::Test1 ()
{
printf ("Ns1::Namespaced::Test1");
}
void Ns1::Namespaced::Test2 (const Compression* a1)
{
printf ("Ns1::Namespaced::Test2");
}
Ns1::Ns2::Namespaced2::Namespaced2 ()
{
printf ("Ns1::Ns2::Namespaced2::Namespaced2");
}
void Ns1::Ns2::Namespaced2::Test1 ()
{
printf ("Ns1::Ns2::Namespaced2::Test1");
}
Ns1::Ns2::Namespaced2* Ns1::Ns2::Namespaced2::Test2 (Compression* a1)
{
printf ("Ns1::Ns2::Namespaced2::Test2");
}

22
tests/Native/ManglingTests.h

@ -1,22 +0,0 @@ @@ -1,22 +0,0 @@
class Compression {
public:
static void Test1 (const Compression* a1, const char* a2, const Compression* a3, const char* a4);
};
namespace Ns1 {
class Namespaced {
public:
static void Test1 ();
static void Test2 (const Compression* a1);
};
}
namespace Ns1 { namespace Ns2 {
class Namespaced2 {
public:
Namespaced2 ();
void Test1 ();
Namespaced2* Test2 (Compression* a1);
};
}}

36
tests/Native/MarshalingTests.cpp

@ -1,36 +0,0 @@ @@ -1,36 +0,0 @@
#include "MarshalingTests.h"
ClassWithCopyCtor::ClassWithCopyCtor(const ClassWithCopyCtor& f) {
x = f.x;
}
ClassWithCopyCtor
ClassWithCopyCtor::Return (int x) {
return ClassWithCopyCtor (x);
}
int
ClassWithCopyCtor::GetX () {
return x;
}
ClassWithDtor
ClassWithDtor::Return (int x) {
return ClassWithDtor (x);
}
int
ClassWithDtor::GetX () {
return x;
}
ClassWithoutCopyCtor
ClassWithoutCopyCtor::Return (int x) {
return ClassWithoutCopyCtor (x);
}
int
ClassWithoutCopyCtor::GetX () {
return x;
}

77
tests/Native/MarshalingTests.h

@ -1,77 +0,0 @@ @@ -1,77 +0,0 @@
class ClassWithCopyCtor {
int x;
public:
ClassWithCopyCtor(int xarg) {
x = xarg;
}
ClassWithCopyCtor(const ClassWithCopyCtor& f);
static ClassWithCopyCtor Return (int x);
int GetX ();
};
class ClassWithDtor {
int x;
public:
ClassWithDtor(int xarg) {
x = xarg;
}
~ClassWithDtor () {
}
static ClassWithDtor Return (int x);
int GetX ();
};
class ClassWithoutCopyCtor {
int x;
public:
ClassWithoutCopyCtor(int xarg) {
x = xarg;
}
static ClassWithoutCopyCtor Return (int x);
int GetX ();
};
class Class {
int x;
public:
Class (int xarg) {
x = xarg;
}
void CopyFromValue (Class c) {
x = c.x;
}
void CopyTo (Class *c) {
c->x = x;
}
bool IsNull (Class *c) {
return !c ? true : false;
}
int GetX () {
return x;
}
int& GetXRef () {
return x;
}
};

21
tests/Native/NUnit.cpp

@ -1,21 +0,0 @@ @@ -1,21 +0,0 @@
//
// NUnit.cpp: Bridges the NUnit Assert methods to C++
//
// Author:
// Alexander Corrado (alexander.corrado@gmail.com)
//
// Copyright (C) 2010 Alexander Corrado
//
#include "NUnit.h"
NUnit* NUnit::Assert;
extern "C" {
void SetNUnitInterface (NUnit* nunit)
{
NUnit::Assert = nunit;
}
}

114
tests/Native/NUnit.h

@ -1,114 +0,0 @@ @@ -1,114 +0,0 @@
//
// NUnit.h: The NUnit C++ interface
//
// Author:
// Alexander Corrado (alexander.corrado@gmail.com)
//
// Copyright (C) 2010 Alexander Corrado
//
#ifndef _CPPINTEROP_NUNIT_H_
#define _CPPINTEROP_NUNIT_H_
#ifdef __GNUC__
#define EXPORT
#elif defined(_MSC_VER)
#define EXPORT __declspec(dllexport)
#else
#error Unknown compiler!
#endif
typedef const char* string;
typedef unsigned int uint;
typedef unsigned long ulong;
class NUnit {
public:
static NUnit* Assert;
virtual void Fail (string message);
virtual void Fail ();
virtual void IsTrue (bool condition, string message);
virtual void IsTrue (bool condition);
virtual void IsFalse (bool condition, string message);
virtual void IsFalse (bool condition);
virtual void IsEmpty (string aString, string message);
virtual void IsEmpty (string aString);
virtual void IsNotEmpty (string aString, string message);
virtual void IsNotEmpty (string aString);
virtual void AreEqual (int expected, int actual, string message);
virtual void AreEqual (int expected, int actual);
virtual void AreEqual (long expected, long actual, string message);
virtual void AreEqual (long expected, long actual);
virtual void AreEqual (uint expected, uint actual, string message);
virtual void AreEqual (uint expected, uint actual);
virtual void AreEqual (ulong expected, ulong actual, string message);
virtual void AreEqual (ulong expected, ulong actual);
virtual void AreEqual (double expected, double actual, double delta, string message);
virtual void AreEqual (double expected, double actual, double delta);
virtual void AreEqual (float expected, float actual, float delta, string message);
virtual void AreEqual (float expected, float actual, float delta);
virtual void AreNotEqual (int expected, int actual, string message);
virtual void AreNotEqual (int expected, int actual);
virtual void AreNotEqual (long expected, long actual, string message);
virtual void AreNotEqual (long expected, long actual);
virtual void AreNotEqual (uint expected, uint actual, string message);
virtual void AreNotEqual (uint expected, uint actual);
virtual void AreNotEqual (ulong expected, ulong actual, string message);
virtual void AreNotEqual (ulong expected, ulong actual);
virtual void AreNotEqual (double expected, double actual, string message);
virtual void AreNotEqual (double expected, double actual);
virtual void AreNotEqual (float expected, float actual, string message);
virtual void AreNotEqual (float expected, float actual);
virtual void Greater (int expected, int actual, string message);
virtual void Greater (int expected, int actual);
virtual void Greater (long expected, long actual, string message);
virtual void Greater (long expected, long actual);
virtual void Greater (uint expected, uint actual, string message);
virtual void Greater (uint expected, uint actual);
virtual void Greater (ulong expected, ulong actual, string message);
virtual void Greater (ulong expected, ulong actual);
virtual void Greater (double expected, double actual, string message);
virtual void Greater (double expected, double actual);
virtual void Greater (float expected, float actual, string message);
virtual void Greater (float expected, float actual);
virtual void Less (int expected, int actual, string message);
virtual void Less (int expected, int actual);
virtual void Less (long expected, long actual, string message);
virtual void Less (long expected, long actual);
virtual void Less (uint expected, uint actual, string message);
virtual void Less (uint expected, uint actual);
virtual void Less (ulong expected, ulong actual, string message);
virtual void Less (ulong expected, ulong actual);
virtual void Less (double expected, double actual, string message);
virtual void Less (double expected, double actual);
virtual void Less (float expected, float actual, string message);
virtual void Less (float expected, float actual);
virtual void GreaterOrEqual (int expected, int actual, string message);
virtual void GreaterOrEqual (int expected, int actual);
virtual void GreaterOrEqual (long expected, long actual, string message);
virtual void GreaterOrEqual (long expected, long actual);
virtual void GreaterOrEqual (uint expected, uint actual, string message);
virtual void GreaterOrEqual (uint expected, uint actual);
virtual void GreaterOrEqual (ulong expected, ulong actual, string message);
virtual void GreaterOrEqual (ulong expected, ulong actual);
virtual void GreaterOrEqual (double expected, double actual, string message);
virtual void GreaterOrEqual (double expected, double actual);
virtual void GreaterOrEqual (float expected, float actual, string message);
virtual void GreaterOrEqual (float expected, float actual);
virtual void LessOrEqual (int expected, int actual, string message);
virtual void LessOrEqual (int expected, int actual);
virtual void LessOrEqual (long expected, long actual, string message);
virtual void LessOrEqual (long expected, long actual);
virtual void LessOrEqual (uint expected, uint actual, string message);
virtual void LessOrEqual (uint expected, uint actual);
virtual void LessOrEqual (ulong expected, ulong actual, string message);
virtual void LessOrEqual (ulong expected, ulong actual);
virtual void LessOrEqual (double expected, double actual, string message);
virtual void LessOrEqual (double expected, double actual);
virtual void LessOrEqual (float expected, float actual, string message);
virtual void LessOrEqual (float expected, float actual);
};
#endif /* _CPPINTEROP_NUNIT_H_ */
Loading…
Cancel
Save