pimhwang
/
CppSharp
mirror of https://github.com/mono/CppSharp.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Removed old unused unit tests.

pull/226/merge
triton 11 years ago
parent
a070912c1a
commit
f5992a970c
14 changed files with 0 additions and 760 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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_ */
Write Preview
Loading…
Cancel
Save