From e0c29962e6f334452f0c9db2caaf6ed18065de85 Mon Sep 17 00:00:00 2001 From: Marcelo Lira Date: Mon, 17 Aug 2009 19:31:37 -0300 Subject: The End Is the Beginning Is the End --- tests/CMakeLists.txt | 20 +++ tests/libsample/CMakeLists.txt | 22 +++ tests/libsample/abstract.cpp | 64 +++++++++ tests/libsample/abstract.h | 37 +++++ tests/libsample/complex.cpp | 27 ++++ tests/libsample/complex.h | 25 ++++ tests/libsample/derived.cpp | 80 +++++++++++ tests/libsample/derived.h | 46 +++++++ tests/libsample/functions.cpp | 85 ++++++++++++ tests/libsample/functions.h | 36 +++++ tests/libsample/implicitconv.cpp | 38 ++++++ tests/libsample/implicitconv.h | 44 ++++++ tests/libsample/kindergarten.cpp | 64 +++++++++ tests/libsample/kindergarten.h | 29 ++++ tests/libsample/listuser.cpp | 47 +++++++ tests/libsample/listuser.h | 23 ++++ tests/libsample/main.cpp | 216 ++++++++++++++++++++++++++++++ tests/libsample/modifications.cpp | 68 ++++++++++ tests/libsample/modifications.h | 73 ++++++++++ tests/libsample/pairuser.cpp | 32 +++++ tests/libsample/pairuser.h | 19 +++ tests/libsample/point.cpp | 111 +++++++++++++++ tests/libsample/point.h | 51 +++++++ tests/libsample/reference.cpp | 11 ++ tests/libsample/reference.h | 24 ++++ tests/libsample/samplenamespace.cpp | 48 +++++++ tests/libsample/samplenamespace.h | 36 +++++ tests/libsample/size.cpp | 11 ++ tests/libsample/size.h | 152 +++++++++++++++++++++ tests/run_test.sh | 13 ++ tests/samplebinding/CMakeLists.txt | 44 ++++++ tests/samplebinding/abstract_test.py | 62 +++++++++ tests/samplebinding/complex_conversions.h | 23 ++++ tests/samplebinding/complex_test.py | 42 ++++++ tests/samplebinding/derived_test.py | 113 ++++++++++++++++ tests/samplebinding/enum_test.py | 36 +++++ tests/samplebinding/global.h | 14 ++ tests/samplebinding/implicitconv_test.py | 27 ++++ tests/samplebinding/list_conversions.h | 29 ++++ tests/samplebinding/modifications_test.py | 115 ++++++++++++++++ tests/samplebinding/pair_conversions.h | 25 ++++ tests/samplebinding/point_test.py | 42 ++++++ tests/samplebinding/reference_test.py | 28 ++++ tests/samplebinding/sample_test.py | 37 +++++ tests/samplebinding/size_test.py | 83 ++++++++++++ tests/samplebinding/typesystem_sample.xml | 216 ++++++++++++++++++++++++++++++ 46 files changed, 2488 insertions(+) create mode 100644 tests/CMakeLists.txt create mode 100644 tests/libsample/CMakeLists.txt create mode 100644 tests/libsample/abstract.cpp create mode 100644 tests/libsample/abstract.h create mode 100644 tests/libsample/complex.cpp create mode 100644 tests/libsample/complex.h create mode 100644 tests/libsample/derived.cpp create mode 100644 tests/libsample/derived.h create mode 100644 tests/libsample/functions.cpp create mode 100644 tests/libsample/functions.h create mode 100644 tests/libsample/implicitconv.cpp create mode 100644 tests/libsample/implicitconv.h create mode 100644 tests/libsample/kindergarten.cpp create mode 100644 tests/libsample/kindergarten.h create mode 100644 tests/libsample/listuser.cpp create mode 100644 tests/libsample/listuser.h create mode 100644 tests/libsample/main.cpp create mode 100644 tests/libsample/modifications.cpp create mode 100644 tests/libsample/modifications.h create mode 100644 tests/libsample/pairuser.cpp create mode 100644 tests/libsample/pairuser.h create mode 100644 tests/libsample/point.cpp create mode 100644 tests/libsample/point.h create mode 100644 tests/libsample/reference.cpp create mode 100644 tests/libsample/reference.h create mode 100644 tests/libsample/samplenamespace.cpp create mode 100644 tests/libsample/samplenamespace.h create mode 100644 tests/libsample/size.cpp create mode 100644 tests/libsample/size.h create mode 100755 tests/run_test.sh create mode 100644 tests/samplebinding/CMakeLists.txt create mode 100755 tests/samplebinding/abstract_test.py create mode 100644 tests/samplebinding/complex_conversions.h create mode 100755 tests/samplebinding/complex_test.py create mode 100755 tests/samplebinding/derived_test.py create mode 100755 tests/samplebinding/enum_test.py create mode 100644 tests/samplebinding/global.h create mode 100755 tests/samplebinding/implicitconv_test.py create mode 100644 tests/samplebinding/list_conversions.h create mode 100755 tests/samplebinding/modifications_test.py create mode 100644 tests/samplebinding/pair_conversions.h create mode 100755 tests/samplebinding/point_test.py create mode 100755 tests/samplebinding/reference_test.py create mode 100755 tests/samplebinding/sample_test.py create mode 100755 tests/samplebinding/size_test.py create mode 100644 tests/samplebinding/typesystem_sample.xml (limited to 'tests') diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 000000000..c1569517e --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,20 @@ +add_subdirectory(libsample) +add_subdirectory(samplebinding) + +file(GLOB TEST_FILES samplebinding/*_test.py) + +foreach(test_file ${TEST_FILES}) + string(REGEX MATCH "/([^/]+)_test.py" test_name ${test_file}) + add_test(${CMAKE_MATCH_1} sh + ${CMAKE_CURRENT_SOURCE_DIR}/run_test.sh + "${libsample_BINARY_DIR}:${libshiboken_BINARY_DIR}" + "${sample_BINARY_DIR}" + ${PYTHON_EXECUTABLE} + ${test_file}) + set_tests_properties(${CMAKE_MATCH_1} PROPERTIES TIMEOUT 5) + +# Should set python path here +# Looks like it's fixed in 2.8: +# http://www.vtk.org/Bug/print_bug_page.php?bug_id=7885 +endforeach(test_file ${TEST_FILES}) + diff --git a/tests/libsample/CMakeLists.txt b/tests/libsample/CMakeLists.txt new file mode 100644 index 000000000..a630b3cb4 --- /dev/null +++ b/tests/libsample/CMakeLists.txt @@ -0,0 +1,22 @@ +project(libsample) + +set(libsample_SRC +abstract.cpp +complex.cpp +derived.cpp +functions.cpp +implicitconv.cpp +kindergarten.cpp +listuser.cpp +modifications.cpp +pairuser.cpp +point.cpp +reference.cpp +samplenamespace.cpp +size.cpp +) + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) +add_library(libsample SHARED ${libsample_SRC}) +set_property(TARGET libsample PROPERTY PREFIX "") + diff --git a/tests/libsample/abstract.cpp b/tests/libsample/abstract.cpp new file mode 100644 index 000000000..8b49f37f8 --- /dev/null +++ b/tests/libsample/abstract.cpp @@ -0,0 +1,64 @@ +#include +#include "abstract.h" + +using namespace std; + +Abstract::Abstract(int id) : m_id(id) +{ + cout << __PRETTY_FUNCTION__; + show(); + cout << endl; +} + +Abstract::~Abstract() +{ + cout << __PRETTY_FUNCTION__; + show(); + cout << endl; +} + +void +Abstract::unpureVirtual() +{ + cout << __PRETTY_FUNCTION__ << endl; +} + +void +Abstract::callUnpureVirtual() +{ + cout << __PRETTY_FUNCTION__ << " --- BEGIN" << endl; + this->unpureVirtual(); + cout << __PRETTY_FUNCTION__ << " --- END" << endl; +} + + +void +Abstract::callPureVirtual() +{ + cout << __PRETTY_FUNCTION__ << " --- BEGIN" << endl; + this->pureVirtual(); + cout << __PRETTY_FUNCTION__ << " --- END" << endl; +} + +void +Abstract::show(PrintFormat format) +{ + cout << '<'; + switch(format) { + case Short: + cout << this; + break; + case Verbose: + cout << "class " << className() << " | cptr: " << this; + cout << ", id: " << m_id; + break; + case OnlyId: + cout << "id: " << m_id; + break; + case ClassNameAndId: + cout << className() << " - id: " << m_id; + break; + } + cout << '>'; +} + diff --git a/tests/libsample/abstract.h b/tests/libsample/abstract.h new file mode 100644 index 000000000..19e3a9dbf --- /dev/null +++ b/tests/libsample/abstract.h @@ -0,0 +1,37 @@ +#ifndef ABSTRACT_H +#define ABSTRACT_H + +class Abstract +{ +public: + enum PrintFormat { + Short, + Verbose, + OnlyId, + ClassNameAndId + }; + + Abstract(int id = -1); + virtual ~Abstract(); + + int id() { return m_id; } + + // factory method + static Abstract* createObject() { return 0; } + + virtual void pureVirtual() = 0; + virtual void unpureVirtual(); + + void callPureVirtual(); + void callUnpureVirtual(); + + void show(PrintFormat format = Verbose); + +protected: + virtual const char* className() { return "Abstract"; } + +private: + int m_id; +}; +#endif // ABSTRACT_H + diff --git a/tests/libsample/complex.cpp b/tests/libsample/complex.cpp new file mode 100644 index 000000000..9e93c961c --- /dev/null +++ b/tests/libsample/complex.cpp @@ -0,0 +1,27 @@ +#include +#include "complex.h" + +using namespace std; + +Complex::Complex(double real, double imag) + : m_real(real), m_imag(imag) +{ + // cout << __PRETTY_FUNCTION__ << "[real=0.0, imag=0.0]" << endl; +} + +Complex +Complex::operator+(Complex& other) +{ + Complex result; + result.setReal(m_real + other.real()); + result.setImaginary(m_imag + other.imag()); + return result; +} + +void +Complex::show() +{ + cout << "(real: " << m_real << ", imag: " << m_imag << ")"; +} + + diff --git a/tests/libsample/complex.h b/tests/libsample/complex.h new file mode 100644 index 000000000..f8efb790c --- /dev/null +++ b/tests/libsample/complex.h @@ -0,0 +1,25 @@ +#ifndef COMPLEX_H +#define COMPLEX_H + +class Complex +{ +public: + Complex(double real = 0.0, double imag = 0.0); + ~Complex() {} + + double real() const { return m_real; } + void setReal(double real) { m_real = real; } + double imag() const { return m_imag; } + void setImaginary(double imag) { m_imag = imag; } + + Complex operator+(Complex& other); + + void show(); + +private: + double m_real; + double m_imag; +}; + +#endif // COMPLEX_H + diff --git a/tests/libsample/derived.cpp b/tests/libsample/derived.cpp new file mode 100644 index 000000000..9a86a9c94 --- /dev/null +++ b/tests/libsample/derived.cpp @@ -0,0 +1,80 @@ +#include +#include "derived.h" + +using namespace std; + +Derived::Derived(int id) : Abstract(id) +{ + cout << __PRETTY_FUNCTION__; + show(); + cout << endl; +} + +Derived::~Derived() +{ + cout << __PRETTY_FUNCTION__; + show(); + cout << endl; +} + +Abstract* +Derived::createObject() +{ + static int id = 100; + return new Derived(id++); +} + +void +Derived::pureVirtual() +{ + cout << __PRETTY_FUNCTION__ << endl; +} + +void +Derived::unpureVirtual() +{ + cout << __PRETTY_FUNCTION__ << endl; +} + +bool +Derived::singleArgument(bool b) +{ + cout << __PRETTY_FUNCTION__ << endl; + return !b; +} + +double +Derived::defaultValue(int n) +{ + cout << __PRETTY_FUNCTION__ << "[n = 0]" << endl; + return ((double) n) + 0.1; +} + +PolymorphicFuncEnum +Derived::polymorphic(int i, int d) +{ + cout << __PRETTY_FUNCTION__ << "[i = 0, d = 0]" << endl; + return PolymorphicFunc_ii; +} + +PolymorphicFuncEnum +Derived::polymorphic(double n) +{ + cout << __PRETTY_FUNCTION__ << endl; + return PolymorphicFunc_d; +} + +Derived::OtherPolymorphicFuncEnum +Derived::otherPolymorphic(int a, int b, bool c, double d) +{ + cout << __PRETTY_FUNCTION__ << endl; + return OtherPolymorphicFunc_iibd; +} + +Derived::OtherPolymorphicFuncEnum +Derived::otherPolymorphic(int a, double b) +{ + cout << __PRETTY_FUNCTION__ << endl; + return OtherPolymorphicFunc_id; +} + diff --git a/tests/libsample/derived.h b/tests/libsample/derived.h new file mode 100644 index 000000000..5efc7c4b4 --- /dev/null +++ b/tests/libsample/derived.h @@ -0,0 +1,46 @@ +#ifndef DERIVED_H +#define DERIVED_H + +#include "abstract.h" + +enum PolymorphicFuncEnum { + PolymorphicFunc_ii, + PolymorphicFunc_d +}; + +class Derived : public Abstract +{ +public: + enum OtherPolymorphicFuncEnum { + OtherPolymorphicFunc_iibd, + OtherPolymorphicFunc_id + }; + + Derived(int id = -1); + virtual ~Derived(); + virtual void pureVirtual(); + virtual void unpureVirtual(); + + // factory method + static Abstract* createObject(); + + // single argument + bool singleArgument(bool b); + + // method with default value + double defaultValue(int n = 0); + + // overloads + PolymorphicFuncEnum polymorphic(int i = 0, int d = 0); + PolymorphicFuncEnum polymorphic(double n); + + // more overloads + OtherPolymorphicFuncEnum otherPolymorphic(int a, int b, bool c, double d); + OtherPolymorphicFuncEnum otherPolymorphic(int a, double b); + +protected: + const char* getClassName() { return className(); } + virtual const char* className() { return "Derived"; } +}; +#endif // DERIVED_H + diff --git a/tests/libsample/functions.cpp b/tests/libsample/functions.cpp new file mode 100644 index 000000000..c35bc5be3 --- /dev/null +++ b/tests/libsample/functions.cpp @@ -0,0 +1,85 @@ +#include "functions.h" +#include +#include + +using namespace std; + +void +printSomething() +{ + cout << __PRETTY_FUNCTION__ << endl; +} + +int +gimmeInt() +{ + static int val = 2; + val = val * 1.3; + return val; +} + +double +gimmeDouble() +{ + static double val = 7.77; + val = val * 1.3; + return val; +} + +std::list +gimmeComplexList() +{ + std::list lst; + lst.push_back(Complex()); + lst.push_back(Complex(1.1, 2.2)); + lst.push_back(Complex(1.3, 2.4)); + return lst; +} + +Complex +sumComplexPair(std::pair cpx_pair) +{ + return cpx_pair.first + cpx_pair.second; +} + +double +multiplyPair(std::pair pair) +{ + return pair.first * pair.second; +} + +int +countCharacters(const char* text) +{ + int count; + for(count = 0; text[count] != '\0'; count++) + ; + return count; +} + +char* +makeCString() +{ + char* string = new char[strlen(__FUNCTION__) + 1]; + strcpy(string, __FUNCTION__); + return string; +} + +const char* +returnCString() +{ + return __PRETTY_FUNCTION__; +} + +GlobalPolyFuncEnum +polymorphicFunc(int val) +{ + return GlobalPolyFunc_i; +} + +GlobalPolyFuncEnum +polymorphicFunc(double val) +{ + return GlobalPolyFunc_d; +} + diff --git a/tests/libsample/functions.h b/tests/libsample/functions.h new file mode 100644 index 000000000..77b2cb68f --- /dev/null +++ b/tests/libsample/functions.h @@ -0,0 +1,36 @@ +#ifndef FUNCTIONS_H +#define FUNCTIONS_H + +#include +#include +#include "complex.h" + +enum GlobalEnum { + NoThing, + FirstThing, + SecondThing, + ThirdThing +}; + +enum GlobalPolyFuncEnum { + GlobalPolyFunc_i, + GlobalPolyFunc_d +}; + +void printSomething(); +int gimmeInt(); +double gimmeDouble(); +double multiplyPair(std::pair pair); +std::list gimmeComplexList(); +Complex sumComplexPair(std::pair cpx_pair); + +int countCharacters(const char* text); +char* makeCString(); +const char* returnCString(); + +// Tests polymorphism on functions (!methods) +GlobalPolyFuncEnum polymorphicFunc(int val); +GlobalPolyFuncEnum polymorphicFunc(double val); + +#endif // FUNCTIONS_H + diff --git a/tests/libsample/implicitconv.cpp b/tests/libsample/implicitconv.cpp new file mode 100644 index 000000000..902707e18 --- /dev/null +++ b/tests/libsample/implicitconv.cpp @@ -0,0 +1,38 @@ +#include "implicitconv.h" + +ImplicitConv +ImplicitConv::implicitConvCommon(ImplicitConv implicit) +{ + return implicit; +} + +ImplicitConv +ImplicitConv::implicitConvDefault(ImplicitConv implicit) +{ + return implicit; +} + +ImplicitConv::ICPolymorphicFuncEnum +ImplicitConv::implicitConvPolymorphism(ImplicitConv implicit, int dummyArg) +{ + return ImplicitConv::PolyFunc_Ii; +} + +ImplicitConv::ICPolymorphicFuncEnum +ImplicitConv::implicitConvPolymorphism(ImplicitConv implicit, bool dummyArg) +{ + return ImplicitConv::PolyFunc_Ib; +} + +ImplicitConv::ICPolymorphicFuncEnum +ImplicitConv::implicitConvPolymorphism(int dummyArg) +{ + return ImplicitConv::PolyFunc_i; +} + +ImplicitConv::ICPolymorphicFuncEnum +ImplicitConv::implicitConvPolymorphism(CtorEnum dummyArg) +{ + return ImplicitConv::PolyFunc_C; +} + diff --git a/tests/libsample/implicitconv.h b/tests/libsample/implicitconv.h new file mode 100644 index 000000000..538150870 --- /dev/null +++ b/tests/libsample/implicitconv.h @@ -0,0 +1,44 @@ +#ifndef IMPLICITCONV_H +#define IMPLICITCONV_H + +class ImplicitConv +{ +public: + enum CtorEnum { + CtorNone, + CtorOne, + CtorTwo, + CtorThree + }; + + enum ICPolymorphicFuncEnum { + PolyFunc_Ii, + PolyFunc_Ib, + PolyFunc_i, + PolyFunc_C + }; + + ImplicitConv() : m_ctorEnum(CtorNone), m_objId(-1) {} + ImplicitConv(int objId) : m_ctorEnum(CtorOne), m_objId(objId) {} + ImplicitConv(CtorEnum ctorEnum) : m_ctorEnum(ctorEnum), m_objId(-1) {} + ~ImplicitConv() {} + + CtorEnum ctorEnum() { return m_ctorEnum; } + int objId() { return m_objId; } + + static ImplicitConv implicitConvCommon(ImplicitConv implicit); + + static ImplicitConv implicitConvDefault(ImplicitConv implicit = CtorTwo); + + static ICPolymorphicFuncEnum implicitConvPolymorphism(ImplicitConv implicit, int dummyArg); + static ICPolymorphicFuncEnum implicitConvPolymorphism(ImplicitConv implicit, bool dummyArg); + static ICPolymorphicFuncEnum implicitConvPolymorphism(int dummyArg); + static ICPolymorphicFuncEnum implicitConvPolymorphism(CtorEnum dummyArg); + +private: + CtorEnum m_ctorEnum; + int m_objId; +}; + +#endif // IMPLICITCONV_H + diff --git a/tests/libsample/kindergarten.cpp b/tests/libsample/kindergarten.cpp new file mode 100644 index 000000000..8332e4fe7 --- /dev/null +++ b/tests/libsample/kindergarten.cpp @@ -0,0 +1,64 @@ +#include +#include "kindergarten.h" + +using namespace std; + +KinderGarten::~KinderGarten() +{ + cout << __PRETTY_FUNCTION__ << " ---- BEGIN" << endl; + killChildren(); + cout << __PRETTY_FUNCTION__ << " ---- END" << endl; +} + +void +KinderGarten::addChild(Abstract* child) +{ + m_children.push_back(child); +} + +void +KinderGarten::killChildren() +{ + cout << __PRETTY_FUNCTION__ << endl; + while (!m_children.empty()) { + m_children.back()->show(); + cout << endl; + delete m_children.back(); + m_children.pop_back(); + } +} + +void +KinderGarten::killChild(Abstract* child) +{ + cout << __PRETTY_FUNCTION__ << endl; + if (child) { + m_children.remove(child); +// delete child; + } +} + +Abstract* +KinderGarten::releaseChild(Abstract* child) +{ + for(ChildList::iterator child_iter = m_children.begin(); + child_iter != m_children.end(); child_iter++) { + if (child == *child_iter) { + m_children.erase(child_iter); + return child; + } + } +} + +void +KinderGarten::show() +{ + cout << "["; + for(ChildList::iterator child_iter = m_children.begin(); + child_iter != m_children.end(); child_iter++) { + if (child_iter != m_children.begin()) + cout << ", "; + (*child_iter)->show(); + } + cout << "]"; +} diff --git a/tests/libsample/kindergarten.h b/tests/libsample/kindergarten.h new file mode 100644 index 000000000..b0a083dce --- /dev/null +++ b/tests/libsample/kindergarten.h @@ -0,0 +1,29 @@ +#ifndef KINDERGARTEN_H +#define KINDERGARTEN_H + +#include +#include "abstract.h" + +class KinderGarten +{ +public: + typedef std::list ChildList; + + KinderGarten() {} + ~KinderGarten(); + + void addChild(Abstract* child); + Abstract* releaseChild(Abstract* child); + ChildList children() { return m_children; } + + void killChildren(); + void killChild(Abstract* child); + + void show(); + +private: + ChildList m_children; +}; + +#endif // KINDERGARTEN_H + diff --git a/tests/libsample/listuser.cpp b/tests/libsample/listuser.cpp new file mode 100644 index 000000000..0b9a14ff5 --- /dev/null +++ b/tests/libsample/listuser.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +#include "listuser.h" + +using namespace std; + +std::list +ListUser::callCreateList() +{ + cout << __PRETTY_FUNCTION__ << endl; + return createList(); +} + +std::list +ListUser::createList() +{ + cout << __PRETTY_FUNCTION__ << endl; + std::list retval; + for (int i = 0; i < 4; i++) + retval.push_front(rand()); + return retval; +} + +std::list +ListUser::createComplexList(Complex cpx0, Complex cpx1) +{ + cout << __PRETTY_FUNCTION__ << endl; + std::list retval; + retval.push_back(cpx0); + retval.push_back(cpx1); + return retval; +} + +double +ListUser::sumList(std::list vallist) +{ + return std::accumulate(vallist.begin(), vallist.end(), 0.0); +} + +double +ListUser::sumList(std::list vallist) +{ + return std::accumulate(vallist.begin(), vallist.end(), 0.0); +} + + diff --git a/tests/libsample/listuser.h b/tests/libsample/listuser.h new file mode 100644 index 000000000..c1ea7091e --- /dev/null +++ b/tests/libsample/listuser.h @@ -0,0 +1,23 @@ +#ifndef LISTUSER_H +#define LISTUSER_H + +#include +#include "complex.h" + +class ListUser +{ +public: + ListUser() {} + ~ListUser() {} + + virtual std::list createList(); + std::list callCreateList(); + + static std::list createComplexList(Complex cpx0, Complex cpx1); + + double sumList(std::list vallist); + double sumList(std::list vallist); +}; + +#endif // LISTUSER_H + diff --git a/tests/libsample/main.cpp b/tests/libsample/main.cpp new file mode 100644 index 000000000..7fc563679 --- /dev/null +++ b/tests/libsample/main.cpp @@ -0,0 +1,216 @@ +#include +#include +#include "abstract.h" +#include "derived.h" +#include "kindergarten.h" +#include "complex.h" +#include "point.h" +#include "size.h" +#include "listuser.h" +#include "samplenamespace.h" + +using namespace std; + +int +main(int argv, char **argc) +{ + cout << endl; + + Derived derived; + + cout << endl; + + derived.unpureVirtual(); + derived.pureVirtual(); + derived.callPureVirtual(); + + cout << endl; + Abstract* abs; + abs = Abstract::createObject(); + cout << "Abstract::createObject(): " << abs << endl << endl; + delete abs; + + abs = Derived::createObject(); + cout << "Derived::createObject() : "; + abs->show(); + cout << endl; + delete abs; + cout << endl; + + abs = Derived::createObject(); + cout << "Derived::createObject() : "; + abs->show(); + cout << endl; + delete abs; + cout << endl; + + cout << endl << "-----------------------------------------" << endl; + + KinderGarten kg; + Derived* d[] = { 0, 0, 0 }; + + for (int i = 0; i < 3; i++) { + d[i] = new Derived(i); + d[i]->show(); + cout << endl; + kg.addChild(d[i]); + } + + kg.show(); + cout << endl; + + cout << endl << "* kill child "; + d[2]->show(); + cout << " ----------------" << endl; + kg.killChild(d[2]); + kg.show(); + cout << endl; + + cout << endl << "* release child "; + d[1]->show(); + cout << " -------------" << endl; + Abstract* released = kg.releaseChild(d[1]); + cout << "released: "; + released->show(); + cout << endl; + kg.show(); + cout << endl; + + cout << endl << "* kill children ------------------------------------" << endl; + kg.killChildren(); + kg.show(); + cout << endl << endl; + + cout << "-----------------------------------------" << endl; + ListUser lu; + cout << "ListUser::createList()" << endl; + std::list intlist = lu.createList(); + for (std::list::iterator it = intlist.begin(); it != intlist.end(); it++) { + cout << "* " << *it << endl; + } + + cout << "ListUser::createComplexList" << endl; + std::list cpxlist = ListUser::createComplexList(Complex(1.1, 2.2), Complex(3.3, 4.4)); + for (std::list::iterator it = cpxlist.begin(); it != cpxlist.end(); it++) { + cout << "* "; + (*it).show(); + cout << endl; + } + cout << endl; + + cout << "-----------------------------------------" << endl; + cout << "SampleNamespace" << endl; + + cout << "SampleNamespace::RandomNumber: "; + cout << SampleNamespace::getNumber(SampleNamespace::RandomNumber); + cout << endl; + cout << "SampleNamespace::UnixTime: "; + cout << SampleNamespace::getNumber(SampleNamespace::UnixTime); + cout << endl; + double val_d = 1.3; + cout << "SampleNamespace::powerOfTwo(" << val_d << "): "; + cout << SampleNamespace::powerOfTwo(val_d) << endl; + int val_i = 7; + cout << "SampleNamespace::powerOfTwo(" << val_i << "): "; + cout << SampleNamespace::powerOfTwo(val_i) << endl; + cout << endl; + + cout << "-----------------------------------------" << endl; + cout << "Point" << endl; + + Point p1(1.1, 2.2); + cout << "p1: "; + p1.show(); + cout << endl; + + Point p2(3.4, 5.6); + cout << "p2: "; + p2.show(); + cout << endl; + + cout << "p1 + p2 == "; + (p1 + p2).show(); + cout << endl; + + cout << "p1 * 2.0 == "; + (p1 * 2.0).show(); + cout << endl; + + cout << "1.5 * p2 == "; + (1.5 * p2).show(); + cout << endl; + + cout << "p1: "; + p1.show(); + cout << endl << "p2: "; + p2.show(); + cout << endl << "p1 += p2" << endl; + p1 += p2; + cout << "p1: "; + p1.show(); + cout << endl; + + cout << "p1 == p2 ? " << ((p1 == p2) ? "true" : "false") << endl; + cout << "p1 == p1 ? " << ((p1 == p1) ? "true" : "false") << endl; + cout << "p2 == p2 ? " << ((p2 == p2) ? "true" : "false") << endl; + + cout << "-----------------------------------------" << endl; + cout << "Size" << endl; + + Size s1(2, 2); + cout << "s1: "; + s1.show(); + cout << ", area: " << s1.calculateArea(); + cout << endl; + + Size s2(3, 5); + cout << "s2: "; + s2.show(); + cout << ", area: " << s2.calculateArea(); + cout << endl; + + cout << endl; + + cout << "s1 == s2 ? " << ((s1 == s2) ? "true" : "false") << endl; + cout << "s1 != s2 ? " << ((s1 != s2) ? "true" : "false") << endl; + + cout << "s1 < s2 ? " << ((s1 < s2) ? "true" : "false") << endl; + cout << "s1 <= s2 ? " << ((s1 <= s2) ? "true" : "false") << endl; + cout << "s1 > s2 ? " << ((s1 > s2) ? "true" : "false") << endl; + cout << "s1 >= s2 ? " << ((s1 >= s2) ? "true" : "false") << endl; + + cout << "s1 < 10 ? " << ((s1 < 10) ? "true" : "false") << endl; + cout << "s1 <= 10 ? " << ((s1 <= 10) ? "true" : "false") << endl; + cout << "s1 > 10 ? " << ((s1 > 10) ? "true" : "false") << endl; + cout << "s1 >= 10 ? " << ((s1 >= 10) ? "true" : "false") << endl; + cout << "s2 < 10 ? " << ((s2 < 10) ? "true" : "false") << endl; + cout << "s2 <= 10 ? " << ((s2 <= 10) ? "true" : "false") << endl; + cout << "s2 > 10 ? " << ((s2 > 10) ? "true" : "false") << endl; + cout << "s2 >= 10 ? " << ((s2 >= 10) ? "true" : "false") << endl; + cout << endl; + + cout << "s1: "; + s1.show(); + cout << endl << "s2: "; + s2.show(); + cout << endl << "s1 += s2" << endl; + s1 += s2; + cout << "s1: "; + s1.show(); + cout << endl; + + cout << endl; + + cout << "s1: "; + s1.show(); + cout << endl << "s1 *= 2.0" << endl; + s1 *= 2.0; + cout << "s1: "; + s1.show(); + cout << endl; + + cout << endl; + + return 0; +} + diff --git a/tests/libsample/modifications.cpp b/tests/libsample/modifications.cpp new file mode 100644 index 000000000..68cf6fe6c --- /dev/null +++ b/tests/libsample/modifications.cpp @@ -0,0 +1,68 @@ +#include +#include "modifications.h" + +using namespace std; + +std::pair +Modifications::pointToPair(Point pt, bool* ok) +{ + std::pair retval(pt.x(), pt.y()); + *ok = true; + return retval; +} + +double +Modifications::multiplyPointCoordsPlusValue(bool* ok, Point pt, double value) +{ + double retval = (pt.x() * pt.y()) + value; + *ok = true; + return retval; +} + +int +Modifications::doublePlus(int value, int plus) +{ + return (2 * value) + plus; +} + +int +Modifications::power(int base, int exponent) +{ + if (exponent == 0) + return 1; + int retval = base; + for (int i = 1; i < exponent; i++) + retval = retval * base; + return retval; +} + +int +Modifications::timesTen(int number) +{ + return number * 10; +} + +int +Modifications::increment(int number) +{ + return ++number; +} + +void +Modifications::exclusiveCppStuff() +{ + cout << __PRETTY_FUNCTION__ << endl; +} + +int +Modifications::cppMultiply(int a, int b) +{ + return a * b; +} + +const char* +Modifications::className() +{ + return "Modifications"; +} + diff --git a/tests/libsample/modifications.h b/tests/libsample/modifications.h new file mode 100644 index 000000000..793808161 --- /dev/null +++ b/tests/libsample/modifications.h @@ -0,0 +1,73 @@ +#ifndef MODIFICATIONS_H +#define MODIFICATIONS_H + +#include +#include "point.h" + +class Modifications +{ +public: + Modifications() {} + ~Modifications() {} + + enum PolymorphicModFunc { + PolymorphicNone, + Polymorphic_ibid, + Polymorphic_ibib, + Polymorphic_ibiP, + Polymorphic_ibii, + Polymorphic_ibPP + }; + + // those polymorphic methods should be heavily modified + // to push the overload decisor to its limits + PolymorphicModFunc polymorphic(int a0, bool b0, int c0, double d0) { return Polymorphic_ibid; } + PolymorphicModFunc polymorphic(int a1, bool b1, int c1, bool d1) { return Polymorphic_ibib; } + PolymorphicModFunc polymorphic(int a2, bool b2, int c2, Point d2) { return Polymorphic_ibiP; } + PolymorphicModFunc polymorphic(int a3, bool b3, int c3 = 123, int d3 = 456) { return Polymorphic_ibii; } + PolymorphicModFunc polymorphic(int a4, bool b4, Point c4, Point d4) { return Polymorphic_ibPP; } + + // 'ok' must be removed and the return value will be changed + // to a tuple (PyObject*) containing the expected result plus + // the 'ok' value as a Python boolean + std::pair pointToPair(Point pt, bool* ok); + + // same as 'pointToPair' except that this time 'ok' is the first argument + double multiplyPointCoordsPlusValue(bool* ok, Point pt, double value); + + // completely remove 'plus' from the Python side + int doublePlus(int value, int plus = 0); + + // the default value for both arguments must be changed in Python + int power(int base = 1, int exponent = 0); + + // in Python set argument default value to 10 + int timesTen(int number); + + // in Python remove the argument default value + int increment(int number = 0); + + // don't export this method to Python + void exclusiveCppStuff(); + + // change the name of this regular method + int cppMultiply(int a, int b); + + // change the name of this virtual method + virtual const char* className(); +}; + +class AbstractModifications : public Modifications +{ +public: + AbstractModifications() {} + ~AbstractModifications() {} + + bool invert(bool value) { return !value; } + + // completely remove this method in Python + virtual void pointlessPureVirtualMethod() = 0; +}; + +#endif // MODIFICATIONS_H + diff --git a/tests/libsample/pairuser.cpp b/tests/libsample/pairuser.cpp new file mode 100644 index 000000000..8983630e2 --- /dev/null +++ b/tests/libsample/pairuser.cpp @@ -0,0 +1,32 @@ +#include +#include "pairuser.h" + +using namespace std; + +std::pair +PairUser::callCreatePair() +{ + cout << __PRETTY_FUNCTION__ << endl; + return createPair(); +} + +std::pair +PairUser::createPair() +{ + cout << __PRETTY_FUNCTION__ << endl; + return std::pair(10, 20); +} + +std::pair +PairUser::createComplexPair(Complex cpx0, Complex cpx1) +{ + cout << __PRETTY_FUNCTION__ << endl; + return std::pair(cpx0, cpx1); +} + +double +PairUser::sumPair(std::pair pair) +{ + return ((double) pair.first) + pair.second; +} + diff --git a/tests/libsample/pairuser.h b/tests/libsample/pairuser.h new file mode 100644 index 000000000..27cf76681 --- /dev/null +++ b/tests/libsample/pairuser.h @@ -0,0 +1,19 @@ +#ifndef PAIRUSER_H +#define PAIRUSER_H + +#include +#include "complex.h" + +class PairUser +{ +public: + PairUser() {} + ~PairUser() {} + + virtual std::pair createPair(); + std::pair callCreatePair(); + static std::pair createComplexPair(Complex cpx0, Complex cpx1); + double sumPair(std::pair pair); +}; +#endif // PAIRUSER_H + diff --git a/tests/libsample/point.cpp b/tests/libsample/point.cpp new file mode 100644 index 000000000..ad816025e --- /dev/null +++ b/tests/libsample/point.cpp @@ -0,0 +1,111 @@ +#include +#include "point.h" + +using namespace std; + +Point::Point(int x, int y) : m_x(x), m_y(y) +{ + // cout << __PRETTY_FUNCTION__ << " [x=0, y=0]" << endl; +} + +Point::Point(double x, double y) : m_x(x), m_y(y) +{ + // cout << __PRETTY_FUNCTION__ << endl; +} + +void +Point::show() +{ + cout << "(x: " << m_x << ", y: " << m_y << ")"; +} + +bool +Point::operator==(const Point& other) +{ + return m_x == other.m_x && m_y == other.m_y; +} + +Point +Point::operator+(const Point& other) +{ + return Point(m_x + other.m_x, m_y + other.m_y); +} + +Point +Point::operator-(const Point& other) +{ + return Point(m_x - other.m_x, m_y - other.m_y); +} + +Point& +Point::operator+=(Point &other) +{ + m_x += other.m_x; + m_y += other.m_y; + return *this; +} + +Point& +Point::operator-=(Point &other) +{ + m_x -= other.m_x; + m_y -= other.m_y; + return *this; +} + +Point +operator*(Point& pt, double mult) +{ + return Point(pt.m_x * mult, pt.m_y * mult); +} + +Point +operator*(Point& pt, int mult) +{ + return Point(((int) pt.m_x) * mult, ((int) pt.m_y) * mult); +} + +Point +operator*(double mult, Point& pt) +{ + return Point(pt.m_x * mult, pt.m_y * mult); +} + +Point +operator*(int mult, Point& pt) +{ + return Point(((int) pt.m_x) * mult, ((int) pt.m_y) * mult); +} + +Point +operator-(const Point& pt) +{ + return Point(-pt.m_x, -pt.m_y); +} + +bool +operator!(const Point& pt) +{ + return (pt.m_x == 0.0 && pt.m_y == 0.0); +} + +Complex +transmutePointIntoComplex(Point point) +{ + Complex cpx(point.x(), point.y()); + // cout << __PRETTY_FUNCTION__ << " "; + // point.show(); + // cout << endl; + return cpx; +} + +Point +transmuteComplexIntoPoint(Complex cpx) +{ + Point pt(cpx.real(), cpx.imag()); + // cout << __PRETTY_FUNCTION__ << " "; + // cpx.show(); + // cout << endl; + return pt; +} + diff --git a/tests/libsample/point.h b/tests/libsample/point.h new file mode 100644 index 000000000..e5ec9c1bc --- /dev/null +++ b/tests/libsample/point.h @@ -0,0 +1,51 @@ +#ifndef POINT_H +#define POINT_H + +#include "complex.h" +#include + +class Point +{ +public: + Point(int x = 0, int y = 0); + Point(double x, double y); + ~Point() {} + + double x() const { return m_x; } + double y() const { return m_y; } + + bool operator==(const Point& other); + Point operator+(const Point& other); + Point operator-(const Point& other); + + friend Point operator*(Point& pt, double mult); + friend Point operator*(Point& pt, int mult); + friend Point operator*(double mult, Point& pt); + friend Point operator*(int mult, Point& pt); + friend Point operator-(const Point& pt); + friend bool operator!(const Point& pt); + + Point& operator+=(Point &other); + Point& operator-=(Point &other); + + void show(); + +private: + double m_x; + double m_y; +}; + +Point operator*(Point& pt, double mult); +Point operator*(Point& pt, int mult); +Point operator*(double mult, Point& pt); +Point operator*(int mult, Point& pt); +Point operator-(const Point& pt); +bool operator!(const Point& pt); + +Complex transmutePointIntoComplex(Point point); +Point transmuteComplexIntoPoint(Complex cpx); + +Point operator*(Point& pt, double multiplier); + +#endif // POINT_H + diff --git a/tests/libsample/reference.cpp b/tests/libsample/reference.cpp new file mode 100644 index 000000000..fb3e78e49 --- /dev/null +++ b/tests/libsample/reference.cpp @@ -0,0 +1,11 @@ +#include +#include "reference.h" + +using namespace std; + +void +Reference::show() const +{ + cout << "Reference.objId: " << m_objId; +} + diff --git a/tests/libsample/reference.h b/tests/libsample/reference.h new file mode 100644 index 000000000..bafd2492a --- /dev/null +++ b/tests/libsample/reference.h @@ -0,0 +1,24 @@ +#ifndef REFERENCE_H +#define REFERENCE_H + +class Reference +{ +public: + explicit Reference(int objId = -1) + : m_objId(objId) {} + ~Reference() {} + + double objId() { return m_objId; } + void setObjId(int objId) { m_objId = objId; } + + static int usesReference(Reference& r) { return r.m_objId; } + static int usesConstReference(const Reference& r) { return r.m_objId; } + + void show() const; + +private: + int m_objId; +}; + +#endif // REFERENCE_H + diff --git a/tests/libsample/samplenamespace.cpp b/tests/libsample/samplenamespace.cpp new file mode 100644 index 000000000..ebf2ff74d --- /dev/null +++ b/tests/libsample/samplenamespace.cpp @@ -0,0 +1,48 @@ +#include +#include +#include +#include "samplenamespace.h" + +using namespace std; + +namespace SampleNamespace +{ + +OutValue +enumInEnumOut(InValue in) +{ + OutValue retval; + switch(in) { + case ZeroIn: + retval = ZeroOut; + break; + case OneIn: + retval = OneOut; + break; + case TwoIn: + retval = TwoOut; + break; + default: + retval = (OutValue) -1; + } + return retval; +} + +int +getNumber(Option opt) +{ + int retval; + switch(opt) { + case RandomNumber: + retval = rand() % 100; + break; + case UnixTime: + retval = (int) time(0); + break; + default: + retval = 0; + } + return retval; +} + +} // namespace SampleNamespace diff --git a/tests/libsample/samplenamespace.h b/tests/libsample/samplenamespace.h new file mode 100644 index 000000000..2c65aeab0 --- /dev/null +++ b/tests/libsample/samplenamespace.h @@ -0,0 +1,36 @@ +#ifndef SAMPLENAMESPACE_H +#define SAMPLENAMESPACE_H + +namespace SampleNamespace +{ + +enum Option { + None, + RandomNumber, + UnixTime +}; + +enum InValue { + ZeroIn, + OneIn, + TwoIn +}; + +enum OutValue { + ZeroOut, + OneOut, + TwoOut +}; + +OutValue enumInEnumOut(InValue in); + +int getNumber(Option opt); + +inline double powerOfTwo(double num) { + return num * num; +} + +} // namespace SampleNamespace + +#endif // SAMPLENAMESPACE_H + diff --git a/tests/libsample/size.cpp b/tests/libsample/size.cpp new file mode 100644 index 000000000..63af9c828 --- /dev/null +++ b/tests/libsample/size.cpp @@ -0,0 +1,11 @@ +#include +#include "size.h" + +using namespace std; + +void +Size::show() const +{ + cout << "(width: " << m_width << ", height: " << m_height << ")"; +} + diff --git a/tests/libsample/size.h b/tests/libsample/size.h new file mode 100644 index 000000000..48f0d772a --- /dev/null +++ b/tests/libsample/size.h @@ -0,0 +1,152 @@ +#ifndef SIZE_H +#define SIZE_H + +class Size +{ +public: + Size(double width = 0.0, double height = 0.0) : m_width(width), m_height(height) {} + ~Size() {} + + double width() { return m_width; } + void setWidth(double width) { m_width = width; } + double height() { return m_height; } + void setHeight(double height) { m_height = height; } + + double calculateArea() const { return m_width * m_height; } + + // Comparison Operators + inline bool operator==(const Size& other) + { + return m_width == other.m_width && m_height == other.m_height; + } + + inline bool operator<(const Size& other) + { + return calculateArea() < other.calculateArea(); + } + + inline bool operator>(const Size& other) + { + return calculateArea() > other.calculateArea(); + } + + inline bool operator<=(const Size& other) + { + return calculateArea() <= other.calculateArea(); + } + + inline bool operator>=(const Size& other) + { + return calculateArea() >= other.calculateArea(); + } + + inline bool operator<(double area) { return calculateArea() < area; } + inline bool operator>(double area) { return calculateArea() > area; } + inline bool operator<=(double area) { return calculateArea() <= area; } + inline bool operator>=(double area) { return calculateArea() >= area; } + + // Arithmetic Operators + Size& operator+=(const Size& s) + { + m_width += s.m_width; + m_height += s.m_height; + return *this; + } + + Size& operator-=(const Size& s) + { + m_width -= s.m_width; + m_height -= s.m_height; + return *this; + } + + Size& operator*=(double mult) + { + m_width *= mult; + m_height *= mult; + return *this; + } + + Size& operator/=(double div) + { + m_width /= div; + m_height /= div; + return *this; + } + + // TODO: add ++size, size++, --size, size-- + + // External operators + friend inline bool operator!=(const Size&, const Size&); + friend inline const Size operator+(const Size&, const Size&); + friend inline const Size operator-(const Size&, const Size&); + friend inline const Size operator*(const Size&, double); + friend inline const Size operator*(double, const Size&); + friend inline const Size operator/(const Size&, double); + + friend inline bool operator<(double, const Size&); + friend inline bool operator>(double, const Size&); + friend inline bool operator<=(double, const Size&); + friend inline bool operator>=(double, const Size&); + + void show() const; + +private: + double m_width; + double m_height; +}; + +// Comparison Operators +inline bool operator!=(const Size& s1, const Size& s2) +{ + return s1.m_width != s2.m_width || s1.m_height != s2.m_height; +} + +inline bool operator<(double area, const Size& s) +{ + return area < s.calculateArea(); +} + +inline bool operator>(double area, const Size& s) +{ + return area > s.calculateArea(); +} + +inline bool operator<=(double area, const Size& s) +{ + return area <= s.calculateArea(); +} + +inline bool operator>=(double area, const Size& s) +{ + return area >= s.calculateArea(); +} + +// Arithmetic Operators +inline const Size operator+(const Size& s1, const Size& s2) +{ + return Size(s1.m_width + s2.m_width, s1.m_height + s2.m_height); +} + +inline const Size operator-(const Size& s1, const Size& s2) +{ + return Size(s1.m_width - s2.m_width, s1.m_height - s2.m_height); +} + +inline const Size operator*(const Size& s, double mult) +{ + return Size(s.m_width * mult, s.m_height * mult); +} + +inline const Size operator*(double mult, const Size& s) +{ + return Size(s.m_width * mult, s.m_height * mult); +} + +inline const Size operator/(const Size& s, double div) +{ + return Size(s.m_width / div, s.m_height / div); +} + +#endif // SIZE_H + diff --git a/tests/run_test.sh b/tests/run_test.sh new file mode 100755 index 000000000..ed86ea30c --- /dev/null +++ b/tests/run_test.sh @@ -0,0 +1,13 @@ +#!/usr/bin/python + +# This is a nasty workaround of a CTest limitation +# of setting the environment variables for the test. + + +LIB_PATH=$LD_LIBRARY_PATH:$1 +PYTHON_PATH=$PYTHONPATH:$2 +PYTHON_EXEC=$3 +TEST_FILE=$4 + +LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$LIB_PATH PYTHONPATH=$PYTHON_PATH $PYTHON_EXEC $TEST_FILE + diff --git a/tests/samplebinding/CMakeLists.txt b/tests/samplebinding/CMakeLists.txt new file mode 100644 index 000000000..e89d7d765 --- /dev/null +++ b/tests/samplebinding/CMakeLists.txt @@ -0,0 +1,44 @@ +project(sample) + +set(sample_TYPESYSTEM +${CMAKE_CURRENT_SOURCE_DIR}/typesystem_sample.xml +) + +set(sample_SRC +${CMAKE_CURRENT_BINARY_DIR}/sample/abstractmodifications_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/abstract_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/derived_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/implicitconv_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/listuser_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/modifications_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/pairuser_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/point_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/reference_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/sample_module_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/samplenamespace_wrapper.cpp +${CMAKE_CURRENT_BINARY_DIR}/sample/size_wrapper.cpp +) + +add_custom_command(OUTPUT ${sample_SRC} +COMMAND ${CMAKE_BINARY_DIR}/shiboken + ${CMAKE_CURRENT_SOURCE_DIR}/global.h + --include-paths=${libsample_SOURCE_DIR} + --typesystem-paths=${CMAKE_CURRENT_SOURCE_DIR} + --output-directory=${CMAKE_CURRENT_BINARY_DIR} + ${sample_TYPESYSTEM} +WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} +COMMENT "Running generator for test binding..." +) + +include_directories(${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_SOURCE_DIR} + ${PYTHON_INCLUDE_PATH} + ${libsample_SOURCE_DIR} + ${libshiboken_SOURCE_DIR}) +add_library(sample MODULE ${sample_SRC}) +set_property(TARGET sample PROPERTY PREFIX "") +target_link_libraries(sample + libsample + ${PYTHON_LIBRARIES} + libshiboken) + diff --git a/tests/samplebinding/abstract_test.py b/tests/samplebinding/abstract_test.py new file mode 100755 index 000000000..9d4c51f2c --- /dev/null +++ b/tests/samplebinding/abstract_test.py @@ -0,0 +1,62 @@ +#!/usr/bin/python + +'''Test cases for Abstract class''' + +import sys +import unittest + +from sample import Abstract + +class Incomplete(Abstract): + def __init__(self): + Abstract.__init__(self) + +class Concrete(Abstract): + def __init__(self): + Abstract.__init__(self) + self.pure_virtual_called = False + self.unpure_virtual_called = False + + def pureVirtual(self): + self.pure_virtual_called = True + + def unpureVirtual(self): + self.unpure_virtual_called = True + + +class AbstractTest(unittest.TestCase): + '''Test case for Abstract class''' + + def testAbstractPureVirtualMethodAvailability(self): + '''Test if Abstract class pure virtual method was properly wrapped.''' + self.assert_('pureVirtual' in dir(Abstract)) + + def testAbstractInstanciation(self): + '''Test if instanciation of an abstract class raises the correct exception.''' + self.assertRaises(NotImplementedError, Abstract) + + def testUnimplementedPureVirtualMethodCall(self): + '''Test if calling a pure virtual method raises the correct exception.''' + i = Incomplete() + self.assertRaises(NotImplementedError, i.pureVirtual) + + def testReimplementedVirtualMethodCall(self): + '''Test if instanciation of an abstract class raises the correct exception.''' + i = Concrete() + self.assertRaises(NotImplementedError, i.callPureVirtual) + + def testReimplementedVirtualMethodCall(self): + '''Test if a Python override of a virtual method is correctly called from C++.''' + c = Concrete() + c.callUnpureVirtual() + self.assert_(c.unpure_virtual_called) + + def testImplementedPureVirtualMethodCall(self): + '''Test if a Python override of a pure virtual method is correctly called from C++.''' + c = Concrete() + c.callPureVirtual() + self.assert_(c.pure_virtual_called) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/complex_conversions.h b/tests/samplebinding/complex_conversions.h new file mode 100644 index 000000000..8caaef03b --- /dev/null +++ b/tests/samplebinding/complex_conversions.h @@ -0,0 +1,23 @@ +template<> +struct Converter +{ + static PyObject* toPython(ValueHolder cpx) + { + /* + fprintf(stderr, "[%s:%d] cpx.real: %f, cpx.imag: %f\n", + __PRETTY_FUNCTION__, __LINE__, cpx.value.real(), cpx.value.imag()); + PyObject* result = PyComplex_FromDoubles(cpx.value.real(), cpx.value.imag()); + fprintf(stderr, "[%s:%d]", __PRETTY_FUNCTION__, __LINE__); + PyObject_Print(result, stderr, 0); + fprintf(stderr, "\n"); + return result; + */ + return PyComplex_FromDoubles(cpx.value.real(), cpx.value.imag()); + } + static Complex toCpp(PyObject* pyobj) + { + double real = PyComplex_RealAsDouble(pyobj); + double imag = PyComplex_ImagAsDouble(pyobj); + return Complex(real, imag); + } +}; diff --git a/tests/samplebinding/complex_test.py b/tests/samplebinding/complex_test.py new file mode 100755 index 000000000..92da61090 --- /dev/null +++ b/tests/samplebinding/complex_test.py @@ -0,0 +1,42 @@ +#!/usr/bin/python + +'''Test cases for Complex class''' + +import sys +import unittest + +import sample +from sample import Point + +class ComplexTest(unittest.TestCase): + '''Test case for conversions between C++ Complex class to Python complex class''' + + def testFunctionReturningComplexObject(self): + '''Test function returning a C++ Complex object.''' + cpx = sample.transmutePointIntoComplex(Point(5.0, 2.3)) + self.assertEqual(cpx, complex(5.0, 2.3)) + + def testFunctionReceivingComplexObjectAsArgument(self): + '''Test function returning a C++ Complex object.''' + pt = sample.transmuteComplexIntoPoint(complex(1.2, 3.4)) + # these assertions intentionally avoids to test the == operator, + # it should have its own test cases. + self.assertEqual(pt.x(), 1.2) + self.assertEqual(pt.y(), 3.4) + + def testComplexList(self): + '''Test list of C++ Complex objects conversion to a list of Python complex objects.''' + # the global function gimmeComplexList() is expected to return a list + # containing the following Complex values: [0j, 1.1+2.2j, 1.3+2.4j] + cpxlist = sample.gimmeComplexList() + self.assertEqual(cpxlist, [complex(), complex(1.1, 2.2), complex(1.3, 2.4)]) + + def testSumComplexPair(self): + '''Test sum of a tuple containing two complex objects.''' + cpx1 = complex(1.2, 3.4) + cpx2 = complex(5.6, 7.8) + self.assertEqual(sample.sumComplexPair((cpx1, cpx2)), cpx1 + cpx2) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/derived_test.py b/tests/samplebinding/derived_test.py new file mode 100755 index 000000000..22d49470f --- /dev/null +++ b/tests/samplebinding/derived_test.py @@ -0,0 +1,113 @@ +#!/usr/bin/python + +'''Test cases for Derived class''' + +import sys +import unittest + +import sample +from sample import Abstract, Derived, PolymorphicFuncEnum + +class Deviant(Derived): + def __init__(self): + Derived.__init__(self) + self.pure_virtual_called = False + self.unpure_virtual_called = False + + def pureVirtual(self): + self.pure_virtual_called = True + + def unpureVirtual(self): + self.unpure_virtual_called = True + + def className(self): + return 'Deviant' + +class DerivedTest(unittest.TestCase): + '''Test case for Derived class''' + + def testParentClassMethodsAvailability(self): + '''Test if Derived class really inherits its methods from parent.''' + inherited_methods = set(['callPureVirtual', 'callUnpureVirtual', + 'id_', 'pureVirtual', 'unpureVirtual']) + self.assert_(inherited_methods.issubset(dir(Derived))) + + def testPolymorphicMethodCall(self): + '''Test if the correct polymorphic method is being called.''' + derived = Derived() + + result = derived.polymorphic(1, 2) + self.assertEqual(type(result), PolymorphicFuncEnum) + self.assertEqual(result, sample.PolymorphicFunc_ii) + + result = derived.polymorphic(3) + self.assertEqual(type(result), PolymorphicFuncEnum) + self.assertEqual(result, sample.PolymorphicFunc_ii) + + result = derived.polymorphic(4.4) + self.assertEqual(type(result), PolymorphicFuncEnum) + self.assertEqual(result, sample.PolymorphicFunc_d) + + def testOtherPolymorphicMethodCall(self): + '''Another test to check polymorphic method calling, just to double check.''' + derived = Derived() + + result = derived.otherPolymorphic(1, 2, True, 3.3) + self.assertEqual(type(result), Derived.OtherPolymorphicFuncEnum) + self.assertEqual(result, sample.Derived.OtherPolymorphicFunc_iibd) + + result = derived.otherPolymorphic(1, 2.2) + self.assertEqual(type(result), Derived.OtherPolymorphicFuncEnum) + self.assertEqual(result, Derived.OtherPolymorphicFunc_id) + + def testPolymorphicMethodCallWithDifferentNumericTypes(self): + '''Test if the correct polymorphic method accepts a different numeric type as argument.''' + derived = Derived() + result = derived.polymorphic(1.1, 2.2) + self.assertEqual(type(result), PolymorphicFuncEnum) + self.assertEqual(result, sample.PolymorphicFunc_ii) + + def testPolymorphicMethodCallWithWrongNumberOfArguments(self): + '''Test if a call to a polymorphic method with the wrong number of arguments raises an exception.''' + derived = Derived() + self.assertRaises(TypeError, lambda : derived.otherPolymorphic(1, 2, True)) + + def testReimplementedPureVirtualMethodCall(self): + '''Test if a Python override of a implemented pure virtual method is correctly called from C++.''' + d = Deviant() + d.callPureVirtual() + self.assert_(d.pure_virtual_called) + + def testReimplementedVirtualMethodCall(self): + '''Test if a Python override of a reimplemented virtual method is correctly called from C++.''' + d = Deviant() + d.callUnpureVirtual() + self.assert_(d.unpure_virtual_called) + + def testVirtualMethodCallString(self): + '''Test virtual method call returning string.''' + d = Derived() + self.assertEqual(d.className(), 'Derived') + self.assertEqual(d.getClassName(), 'Derived') + + def testReimplementedVirtualMethodCallReturningString(self): + '''Test if a Python override of a reimplemented virtual method is correctly called from C++.''' + d = Deviant() + self.assertEqual(d.className(), 'Deviant') + self.assertEqual(d.getClassName(), 'Deviant') + + def testSingleArgument(self): + '''Test singleArgument call.''' + d = Derived() + self.assert_(d.singleArgument(False)) + self.assert_(not d.singleArgument(True)) + + def testMethodCallWithDefaultValue(self): + '''Test method call with default value.''' + d = Derived() + self.assertEqual(d.defaultValue(3), 3.1) + self.assertEqual(d.defaultValue(), 0.1) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/enum_test.py b/tests/samplebinding/enum_test.py new file mode 100755 index 000000000..699adceda --- /dev/null +++ b/tests/samplebinding/enum_test.py @@ -0,0 +1,36 @@ +#!/usr/bin/python + +'''Test cases for Python representation of C++ enums''' + +import sys +import unittest + +from sample import SampleNamespace + +class EnumTest(unittest.TestCase): + '''Test case for Abstract class''' + + def testPassingIntegerOnEnumArgument(self): + '''Test if replacing an enum argument with an integer raises an exception.''' + self.assertRaises(TypeError, lambda : SampleNamespace.getNumber(1)) + + def testExtendingEnum(self): + '''Test if can create new items for an enum declared as extensible on the typesystem file.''' + name, value = 'NewItem', 13 + enumitem = SampleNamespace.Option(name, value) + self.assert_(type(enumitem), SampleNamespace.Option) + self.assert_(enumitem.name, name) + self.assert_(int(enumitem), value) + + def testExtendingNonExtensibleEnum(self): + '''Test if trying to create a new enum item for an unextensible enum raises an exception.''' + self.assertRaises(TypeError, lambda : SampleNamespace.InValue(13)) + + def testEnumConversionToAndFromPython(self): + '''Test conversion of enum objects to Python and C++ in both directions.''' + enumout = SampleNamespace.enumInEnumOut(SampleNamespace.TwoIn) + self.assert_(enumout, SampleNamespace.TwoOut) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/global.h b/tests/samplebinding/global.h new file mode 100644 index 000000000..b5ae6a8a0 --- /dev/null +++ b/tests/samplebinding/global.h @@ -0,0 +1,14 @@ +#include "abstract.h" +#include "derived.h" +#include "point.h" +#include "size.h" +#include "complex.h" +#include "functions.h" +#include "kindergarten.h" +#include "pairuser.h" +#include "listuser.h" +#include "samplenamespace.h" +#include "modifications.h" +#include "implicitconv.h" +#include "reference.h" + diff --git a/tests/samplebinding/implicitconv_test.py b/tests/samplebinding/implicitconv_test.py new file mode 100755 index 000000000..30dd870e3 --- /dev/null +++ b/tests/samplebinding/implicitconv_test.py @@ -0,0 +1,27 @@ +#!/usr/bin/python + +'''Test cases for implicit conversions''' + +import sys +import unittest + +from sample import ImplicitConv + +class ImplicitConvTest(unittest.TestCase): + '''Test case for implicit conversions''' + + def testImplicitConversions(self): + '''Test if polymorphic function call decisor takes implicit conversions into account.''' + ic = ImplicitConv.implicitConvCommon(ImplicitConv()) + self.assertEqual(ic.ctorEnum(), ImplicitConv.CtorNone) + + ic = ImplicitConv.implicitConvCommon(3) + self.assertEqual(ic.ctorEnum(), ImplicitConv.CtorOne) + self.assertEqual(ic.objId(), 3) + + ic = ImplicitConv.implicitConvCommon(ImplicitConv.CtorThree) + self.assertEqual(ic.ctorEnum(), ImplicitConv.CtorThree) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/list_conversions.h b/tests/samplebinding/list_conversions.h new file mode 100644 index 000000000..f512f98ad --- /dev/null +++ b/tests/samplebinding/list_conversions.h @@ -0,0 +1,29 @@ +template +struct Converter_std_list +{ + static PyObject* toPython(ValueHolder holder) + { + PyObject* result = PyList_New((int) holder.value.size()); + typedef typename StdList::iterator IT; + IT it; + int idx = 0; + for (it = holder.value.begin(); it != holder.value.end(); it++) { + ValueHolder vh(*it); + PyList_SET_ITEM(result, idx, Converter::toPython(vh)); + idx++; + } + return result; + } + static StdList toCpp(PyObject* pyobj) + { + StdList result; + for (int i = 0; i < PyTuple_GET_SIZE(pyobj); i++) { + PyObject* pyItem = PyTuple_GET_ITEM(pyobj, i); + result.push_back(Converter::toCpp(pyItem)); + } + return result; + } +}; + +template +struct Converter > : Converter_std_list > {}; diff --git a/tests/samplebinding/modifications_test.py b/tests/samplebinding/modifications_test.py new file mode 100755 index 000000000..33d420f37 --- /dev/null +++ b/tests/samplebinding/modifications_test.py @@ -0,0 +1,115 @@ +#!/usr/bin/python + +'''Test cases for method modifications performed as described on typesystem. ''' + +import sys +import unittest + +from sample import Modifications, Point + +class ExtModifications(Modifications): + def __init__(self): + Modifications.__init__(self) + + def name(self): + return 'ExtModifications' + + +class ModificationsTest(unittest.TestCase): + '''Test cases for method modifications performed as described on typesystem. ''' + + def setUp(self): + self.mods = Modifications() + + def tearDown(self): + del self.mods + + def testClassMembersAvailability(self): + '''Test if Modified class really have the expected members.''' + expected_members = set(['PolymorphicModFunc', 'PolymorphicNone', + 'Polymorphic_ibiP', 'Polymorphic_ibib', + 'Polymorphic_ibid', 'Polymorphic_ibii', + 'calculateArea', 'doublePlus', 'increment', + 'multiplyPointCoordsPlusValue', 'name', + 'pointToPair', 'polymorphic', 'power', + 'timesTen']) + self.assert_(expected_members.issubset(dir(Modifications))) + + def testRenamedMethodAvailability(self): + '''Test if Modification class really have renamed the 'className' virtual method to 'name'.''' + self.assert_('className' not in dir(Modifications)) + self.assert_('name' in dir(Modifications)) + + def testReimplementationOfRenamedVirtualMethod(self): + '''Test if class inheriting from Modification class have the reimplementation of renamed virtual method called.''' + em = ExtModifications() + self.assertEqual(self.mods.name(), 'Modifications') + self.assertEqual(em.name(), 'ExtModifications') + + def testRegularMethodRenaming(self): + '''Test if Modifications::cppMultiply was correctly renamed to calculateArea.''' + self.assert_('cppMultiply' not in dir(Modifications)) + self.assert_('calculateArea' in dir(Modifications)) + self.assertEqual(self.mods.calculateArea(3, 6), 3 * 6) + + def testRegularMethodRemoval(self): + '''Test if 'Modifications::exclusiveCppStuff' was removed from Python bindings.''' + self.assert_('exclusiveCppStuff' not in dir(Modifications)) + + def testArgumentRemoval(self): + '''Test if second argument of Modifications::doublePlus(int, int) was removed.''' + self.assertRaises(TypeError, lambda : self.mods.doublePlus(3, 7)) + self.assertEqual(self.mods.doublePlus(7), 14) + + def testDefaultValueRemoval(self): + '''Test if default value was removed from first argument of Modifications::increment(int).''' + self.assertRaises(TypeError, self.mods.increment) + self.assertEqual(self.mods.increment(7), 8) + + def testDefaultValueReplacement(self): + '''Test if default values for both arguments of Modifications::power(int, int) were modified.''' + # original default values: int power(int base = 1, int exponent = 0); + self.assertNotEqual(self.mods.power(4), 1) + # modified default values: int power(int base = 2, int exponent = 1); + self.assertEqual(self.mods.power(), 2) + self.assertEqual(self.mods.power(3), 3) + self.assertEqual(self.mods.power(5, 3), 5**3) + + def testSetNewDefaultValue(self): + '''Test if default value was correctly set to 10 for first argument of Modifications::timesTen(int).''' + self.assertEqual(self.mods.timesTen(7), 70) + self.assertEqual(self.mods.timesTen(), 100) + + def testArgumentRemovalAndReturnTypeModificationWithTypesystemTemplates1(self): + '''Test modifications to method signature and return value using typesystem templates (case 1).''' + result, ok = self.mods.pointToPair(Point(2, 5)) + self.assertEqual(type(ok), bool) + self.assertEqual(type(result), tuple) + self.assertEqual(len(result), 2) + self.assertEqual(type(result[0]), float) + self.assertEqual(type(result[1]), float) + self.assertEqual(result[0], 2.0) + self.assertEqual(result[1], 5.0) + + def testArgumentRemovalAndReturnTypeModificationWithTypesystemTemplates2(self): + '''Test modifications to method signature and return value using typesystem templates (case 2).''' + result, ok = self.mods.multiplyPointCoordsPlusValue(Point(2, 5), 4.1) + self.assertEqual(type(ok), bool) + self.assertEqual(type(result), float) + self.assertEqual(result, 14.1) + + def testPolymorphicMethodModifications(self): + '''Tests modifications to a polymorphic method''' + # polymorphic(int, bool[removed], int, double) + self.assertEqual(self.mods.polymorphic(1, 2, 3.1), Modifications.Polymorphic_ibid) + # polymorphic(int, bool, int[removed,default=321], int) + self.assertEqual(self.mods.polymorphic(1, True, 2), Modifications.Polymorphic_ibii) + # the others weren't modified + self.assertEqual(self.mods.polymorphic(1, True, 2, False), Modifications.Polymorphic_ibib) + self.assertEqual(self.mods.polymorphic(1, False, 2, Point(3, 4)), Modifications.Polymorphic_ibiP) + self.assertRaises(TypeError, lambda : self.mods.polymorphic(1, True, Point(2, 3), Point(4, 5))) + self.assertEqual(self.mods.poly(1, True, Point(2, 3), Point(4, 5)), Modifications.Polymorphic_ibPP) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/pair_conversions.h b/tests/samplebinding/pair_conversions.h new file mode 100644 index 000000000..8adf2f6f3 --- /dev/null +++ b/tests/samplebinding/pair_conversions.h @@ -0,0 +1,25 @@ +template +struct Converter_std_pair +{ + static PyObject* toPython(ValueHolder holder) + { + ValueHolder first(holder.value.first); + ValueHolder second(holder.value.second); + PyObject* tuple = PyTuple_New(2); + PyTuple_SET_ITEM(tuple, 0, Converter::toPython(first)); + PyTuple_SET_ITEM(tuple, 1, Converter::toPython(second)); + return tuple; + } + static StdPair toCpp(PyObject* pyobj) + { + StdPair result; + PyObject* pyFirst = PyTuple_GET_ITEM(pyobj, 0); + PyObject* pySecond = PyTuple_GET_ITEM(pyobj, 1); + result.first = Converter::toCpp(pyFirst); + result.second = Converter::toCpp(pySecond); + return result; + } +}; + +template +struct Converter > : Converter_std_pair > {}; diff --git a/tests/samplebinding/point_test.py b/tests/samplebinding/point_test.py new file mode 100755 index 000000000..69ef1eefb --- /dev/null +++ b/tests/samplebinding/point_test.py @@ -0,0 +1,42 @@ +#!/usr/bin/python + +'''Test cases for Point class''' + +import sys +import unittest + +from sample import Point + +class PointTest(unittest.TestCase): + '''Test case for Point class, including operator overloads.''' + + def testConstructor(self): + '''Test Point class constructor.''' + pt = Point(5.0, 2.3) + self.assertEqual(pt.x(), 5.0) + self.assertEqual(pt.y(), 2.3) + + def testPlusOperator(self): + '''Test Point class + operator.''' + pt1 = Point(5.0, 2.3) + pt2 = Point(0.5, 3.2) + self.assertEqual(pt1 + pt2, Point(5.0 + 0.5, 2.3 + 3.2)) + + def testEqualOperator(self): + '''Test Point class == operator.''' + pt1 = Point(5.0, 2.3) + pt2 = Point(5.0, 2.3) + pt3 = Point(0.5, 3.2) + self.assertTrue(pt1 == pt1) + self.assertTrue(pt1 == pt2) + self.assertFalse(pt1 == pt3) + + def testNotEqualOperator(self): + '''Test Point class != operator.''' + pt1 = Point(5.0, 2.3) + pt2 = Point(5.0, 2.3) + self.assertRaises(NotImplementedError, lambda : pt1.__ne__(pt2)) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/reference_test.py b/tests/samplebinding/reference_test.py new file mode 100755 index 000000000..ed4c5cbc8 --- /dev/null +++ b/tests/samplebinding/reference_test.py @@ -0,0 +1,28 @@ +#!/usr/bin/python + +'''Test cases for methods that receive references to objects.''' + +import sys +import unittest + +from sample import Reference + +class ReferenceTest(unittest.TestCase): + '''Test case for methods that receive references to objects.''' + + def testMethodThatReceivesReference(self): + '''Test a method that receives a reference to an object as argument.''' + objId = 123 + r = Reference(objId) + self.assertEqual(Reference.usesReference(r), objId) + + def testMethodThatReceivesConstReference(self): + '''Test a method that receives a const reference to an object as argument.''' + objId = 123 + r = Reference(objId) + self.assertEqual(Reference.usesConstReference(r), objId) + + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/sample_test.py b/tests/samplebinding/sample_test.py new file mode 100755 index 000000000..9de201a24 --- /dev/null +++ b/tests/samplebinding/sample_test.py @@ -0,0 +1,37 @@ +#!/usr/bin/python + +'''Test cases for libsample bindings module''' + +import sys +import unittest + +import sample + +class ModuleTest(unittest.TestCase): + '''Test case for module and global functions''' + + def testModuleMembers(self): + '''Test availability of classes, global functions and other members on binding''' + expected_members = set(['Abstract', 'Derived', 'ListUser', 'PairUser', + 'Point', 'gimmeComplexList', 'gimmeDouble', + 'gimmeInt', 'makeCString', 'multiplyPair', + 'returnCString', 'transmuteComplexIntoPoint', + 'transmutePointIntoComplex', 'sumComplexPair', + 'SampleNamespace', 'GlobalEnum', 'NoThing', + 'FirstThing', 'SecondThing', 'ThirdThing']) + self.assert_(expected_members.issubset(dir(sample))) + + def testAbstractPrintFormatEnum(self): + '''Test availability of PrintFormat enum from Abstract class''' + enum_members = set(['PrintFormat', 'Short', 'Verbose', + 'OnlyId', 'ClassNameAndId']) + self.assert_(enum_members.issubset(dir(sample.Abstract))) + + def testSampleNamespaceOptionEnum(self): + '''Test availability of Option enum from SampleNamespace namespace''' + enum_members = set(['Option', 'None', 'RandomNumber', 'UnixTime']) + self.assert_(enum_members.issubset(dir(sample.SampleNamespace))) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/size_test.py b/tests/samplebinding/size_test.py new file mode 100755 index 000000000..dcfc9d9d3 --- /dev/null +++ b/tests/samplebinding/size_test.py @@ -0,0 +1,83 @@ +#!/usr/bin/python + +'''Test cases for operator overloads on Size class''' + +import sys +import unittest + +from sample import Size + +class PointTest(unittest.TestCase): + '''Test case for Size class, including operator overloads.''' + + def testConstructor(self): + '''Test Size class constructor.''' + width, height = (5.0, 2.3) + size = Size(width, height) + self.assertEqual(size.width(), width) + self.assertEqual(size.height(), height) + self.assertEqual(size.calculateArea(), width * height) + + def testPlusOperator(self): + '''Test Size class + operator.''' + s1 = Size(5.0, 2.3) + s2 = Size(0.5, 3.2) + self.assertEqual(s1 + s2, Size(5.0 + 0.5, 2.3 + 3.2)) + + def testEqualOperator(self): + '''Test Size class == operator.''' + s1 = Size(5.0, 2.3) + s2 = Size(5.0, 2.3) + s3 = Size(0.5, 3.2) + self.assertTrue(s1 == s1) + self.assertTrue(s1 == s2) + self.assertFalse(s1 == s3) + + def testNotEqualOperator(self): + '''Test Size class != operator.''' + s1 = Size(5.0, 2.3) + s2 = Size(5.0, 2.3) + s3 = Size(0.5, 3.2) + self.assertFalse(s1 != s1) + self.assertFalse(s1 != s2) + self.assertTrue(s1 != s3) + + def testMinorEqualOperator(self): + '''Test Size class <= operator.''' + s1 = Size(5.0, 2.3) + s2 = Size(5.0, 2.3) + s3 = Size(0.5, 3.2) + self.assertTrue(s1 <= s1) + self.assertTrue(s1 <= s2) + self.assertTrue(s3 <= s1) + self.assertFalse(s1 <= s3) + + def testMinorOperator(self): + '''Test Size class < operator.''' + s1 = Size(5.0, 2.3) + s2 = Size(0.5, 3.2) + self.assertFalse(s1 < s1) + self.assertFalse(s1 < s2) + self.assertTrue(s2 < s1) + + def testMajorEqualOperator(self): + '''Test Size class >= operator.''' + s1 = Size(5.0, 2.3) + s2 = Size(5.0, 2.3) + s3 = Size(0.5, 3.2) + self.assertTrue(s1 >= s1) + self.assertTrue(s1 >= s2) + self.assertTrue(s1 >= s3) + self.assertFalse(s3 >= s1) + + def testMajorOperator(self): + '''Test Size class > operator.''' + s1 = Size(5.0, 2.3) + s2 = Size(0.5, 3.2) + self.assertFalse(s1 > s1) + self.assertTrue(s1 > s2) + self.assertFalse(s2 > s1) + +if __name__ == '__main__': + unittest.main() + diff --git a/tests/samplebinding/typesystem_sample.xml b/tests/samplebinding/typesystem_sample.xml new file mode 100644 index 000000000..c049ea9eb --- /dev/null +++ b/tests/samplebinding/typesystem_sample.xml @@ -0,0 +1,216 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + %0 = ((%TYPE*) ((Shiboken::PyBaseWrapper*) self)->cptr)-> + %TYPE::%FUNCTION_NAME(%1, true, %3, %4); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- cgit v1.2.3