diff options
Diffstat (limited to 'sources/shiboken6/tests/libsample')
131 files changed, 7839 insertions, 0 deletions
diff --git a/sources/shiboken6/tests/libsample/CMakeLists.txt b/sources/shiboken6/tests/libsample/CMakeLists.txt new file mode 100644 index 000000000..926972340 --- /dev/null +++ b/sources/shiboken6/tests/libsample/CMakeLists.txt @@ -0,0 +1,95 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +project(libsample) + +set(libsample_SRC +abstract.cpp abstract.h +blackbox.cpp blackbox.h +bucket.cpp bucket.h +bytearray.cpp bytearray.h +collector.cpp collector.h +complex.cpp complex.h +ctorconvrule.h +ctparam.cpp ctparam.h +cvlist.h +derived.cpp derived.h +derivedusingct.cpp derivedusingct.h +echo.cpp echo.h +exceptiontest.cpp exceptiontest.h +expression.cpp expression.h +filter.cpp filter.h +functions.cpp functions.h +handle.cpp handle.h +implicitconv.cpp implicitconv.h +injectcode.cpp injectcode.h +intwrapper.cpp intwrapper.h +libsamplemacros.h +list.h +listuser.cpp listuser.h +mapuser.cpp mapuser.h +modelindex.h +modifications.cpp modifications.h +modified_constructor.cpp modified_constructor.h +multiple_derived.cpp multiple_derived.h +noimplicitconversion.h +nondefaultctor.h +nontypetemplate.h +null.h +objectmodel.cpp objectmodel.h +objecttype.cpp objecttype.h +objecttypebyvalue.h +objecttypeholder.cpp objecttypeholder.h +objecttypelayout.cpp objecttypelayout.h +objecttypeoperators.cpp objecttypeoperators.h +objectview.cpp objectview.h +oddbool.cpp oddbool.h +onlycopy.cpp onlycopy.h +overload.cpp overload.h +overloadsort.cpp overloadsort.h +pairuser.cpp pairuser.h +pen.cpp pen.h +photon.cpp photon.h +point.cpp point.h +pointerholder.h +pointf.cpp pointf.h +polygon.cpp polygon.h +privatector.h +privatedtor.h +protected.cpp protected.h +rect.h +reference.cpp reference.h +removednamespaces.h +renaming.cpp renaming.h +sample.cpp sample.h +samplenamespace.cpp samplenamespace.h +sbkdate.cpp sbkdate.h +stdcomplex.cpp stdcomplex.h +simplefile.cpp simplefile.h +size.cpp size.h +snakecasetest.cpp snakecasetest.h +sometime.cpp sometime.h +str.cpp str.h +strlist.cpp strlist.h +templateptr.cpp templateptr.h +transform.cpp transform.h +typesystypedef.cpp typesystypedef.h +valueandvirtual.h +virtualmethods.cpp virtualmethods.h +voidholder.h +) + +# Includes windows.h which is causing clashes between class Polygon and +# wingdi.h's Polygon() function. + +if(WIN32) + set_source_files_properties( + bucket.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON + ) +endif() + +add_library(libsample SHARED ${libsample_SRC}) +target_include_directories(libsample PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) +target_compile_definitions(libsample PRIVATE LIBSAMPLE_BUILD) +set_property(TARGET libsample PROPERTY PREFIX "") + diff --git a/sources/shiboken6/tests/libsample/abstract.cpp b/sources/shiboken6/tests/libsample/abstract.cpp new file mode 100644 index 000000000..0d67d8630 --- /dev/null +++ b/sources/shiboken6/tests/libsample/abstract.cpp @@ -0,0 +1,71 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "abstract.h" + +#include <iostream> + +const int Abstract::staticPrimitiveField = 0; + +Abstract::Abstract(int id) noexcept : m_id(id) +{ + bitField = 0; +} + +Abstract::~Abstract() = default; + +void Abstract::unpureVirtual() +{ +} + +void Abstract::callUnpureVirtual() +{ + this->unpureVirtual(); +} + +void Abstract::callPureVirtual() +{ + this->pureVirtual(); +} + +void Abstract::show(PrintFormat format) const +{ + std::cout << '<'; + switch(format) { + case Short: + std::cout << this; + break; + case Verbose: + std::cout << "class " << className() << " | cptr: " << this + << ", id: " << m_id; + break; + case OnlyId: + std::cout << "id: " << m_id; + break; + case ClassNameAndId: + std::cout << className() << " - id: " << m_id; + break; + } + std::cout << '>'; +} + +void Abstract::virtualWithOutParameter(int &x) const +{ + x = 42; +} + +int Abstract::callVirtualWithOutParameter() const +{ + int x; + virtualWithOutParameter(x); + return x; +} + +void Abstract::callVirtualGettingEnum(PrintFormat p) +{ + virtualGettingAEnum(p); +} + +void Abstract::virtualGettingAEnum(Abstract::PrintFormat) +{ +} diff --git a/sources/shiboken6/tests/libsample/abstract.h b/sources/shiboken6/tests/libsample/abstract.h new file mode 100644 index 000000000..4c1b98d90 --- /dev/null +++ b/sources/shiboken6/tests/libsample/abstract.h @@ -0,0 +1,91 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef ABSTRACT_H +#define ABSTRACT_H + +#include "libsamplemacros.h" +#include "point.h" +#include "complex.h" + +class ObjectType; + +// this class is not exported to python +class HideType +{ +}; + +class LIBSAMPLE_API Abstract +{ +private: + enum PrivateEnum { + PrivValue0, + PrivValue1, + PrivValue2 = PrivValue1 + 2 + }; +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Abstract) + + enum PrintFormat { + Short, + Verbose, + OnlyId, + ClassNameAndId, + DummyItemToTestPrivateEnum1 = Abstract::PrivValue1, + DummyItemToTestPrivateEnum2 = PrivValue2, + }; + + enum Type { + TpAbstract, TpDerived + }; + + static const int staticPrimitiveField; + int primitiveField = 123; + Complex userPrimitiveField; + Point valueTypeField{12, 34}; + ObjectType *objectTypeField = nullptr; + int toBeRenamedField = 123; + int readOnlyField = 123; + + explicit Abstract(int id = -1) noexcept; + virtual ~Abstract(); + + inline int id() const { return m_id; } + + // factory method + inline static Abstract *createObject() { return nullptr; } + + // method that receives an Object Type + inline static int getObjectId(Abstract *obj) { return obj->id(); } + + virtual void pureVirtual() = 0; + virtual void *pureVirtualReturningVoidPtr() = 0; + virtual void unpureVirtual(); + + virtual PrintFormat returnAnEnum() = 0; + void callVirtualGettingEnum(PrintFormat p); + virtual void virtualGettingAEnum(PrintFormat p); + + void callPureVirtual(); + void callUnpureVirtual(); + + void show(PrintFormat format = Verbose) const; + virtual Type type() const { return TpAbstract; } + + virtual void hideFunction(HideType *arg) = 0; + + virtual void virtualWithOutParameter(int &x) const; + int callVirtualWithOutParameter() const; + +protected: + virtual const char *className() const { return "Abstract"; } + + // Protected bit-field structure member. + unsigned int bitField: 1; + +private: + virtual void pureVirtualPrivate() = 0; + int m_id; +}; + +#endif // ABSTRACT_H diff --git a/sources/shiboken6/tests/libsample/blackbox.cpp b/sources/shiboken6/tests/libsample/blackbox.cpp new file mode 100644 index 000000000..2ac435d3d --- /dev/null +++ b/sources/shiboken6/tests/libsample/blackbox.cpp @@ -0,0 +1,81 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "blackbox.h" + +BlackBox::~BlackBox() +{ + // Free all maps. + for (const auto &p :m_objects) + delete p.second; + for (const auto &p : m_points) + delete p.second; +} + +int BlackBox::keepObjectType(ObjectType *object) +{ + ++m_ticket; + m_objects.insert({m_ticket, object}); + object->setParent(nullptr); + + return m_ticket; +} + +ObjectType *BlackBox::retrieveObjectType(int ticket) +{ + const auto it = m_objects.find(ticket); + if (it != m_objects.end()) { + ObjectType *second = it->second; + m_objects.erase(it); + return second; + } + return nullptr; +} + +void BlackBox::disposeObjectType(int ticket) +{ + delete retrieveObjectType(ticket); +} + +int BlackBox::keepPoint(Point *point) +{ + ++m_ticket; + m_points.insert({m_ticket, point}); + return m_ticket; +} + +Point *BlackBox::retrievePoint(int ticket) +{ + const auto it = m_points.find(ticket); + if (it != m_points.end()) { + Point *second = it->second; + m_points.erase(it); + return second; + } + return nullptr; +} + +void BlackBox::disposePoint(int ticket) +{ + delete retrievePoint(ticket); +} + +std::list<ObjectType*> BlackBox::objects() +{ + std::list<ObjectType*> l; + + for (const auto &p : m_objects) + l.push_back(p.second); + + return l; +} + +std::list<Point*> BlackBox::points() +{ + std::list<Point*> l; + + for (const auto &p : m_points) + l.push_back(p.second); + + return l; +} diff --git a/sources/shiboken6/tests/libsample/blackbox.h b/sources/shiboken6/tests/libsample/blackbox.h new file mode 100644 index 000000000..9d32670dd --- /dev/null +++ b/sources/shiboken6/tests/libsample/blackbox.h @@ -0,0 +1,44 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef BLACKBOX_H +#define BLACKBOX_H + +#include "libsamplemacros.h" +#include "objecttype.h" +#include "point.h" + +#include <list> +#include <map> + +class LIBSAMPLE_API BlackBox +{ +public: + using ObjectTypeMap = std::map<int, ObjectType*>; + using PointMap = std::map<int, Point*>; + + LIBMINIMAL_DEFAULT_COPY_MOVE(BlackBox) + BlackBox() noexcept = default; + ~BlackBox(); + + int keepObjectType(ObjectType *object); + ObjectType *retrieveObjectType(int ticket); + void disposeObjectType(int ticket); + + int keepPoint(Point *point); + Point *retrievePoint(int ticket); + void disposePoint(int ticket); + + std::list<ObjectType*> objects(); + std::list<Point*> points(); + + inline void referenceToValuePointer(Point*&) {} + inline void referenceToObjectPointer(ObjectType*&) {} + +private: + ObjectTypeMap m_objects; + PointMap m_points; + int m_ticket = -1; +}; + +#endif // BLACKBOX_H diff --git a/sources/shiboken6/tests/libsample/bucket.cpp b/sources/shiboken6/tests/libsample/bucket.cpp new file mode 100644 index 000000000..cafd382a9 --- /dev/null +++ b/sources/shiboken6/tests/libsample/bucket.cpp @@ -0,0 +1,59 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "bucket.h" + +#include <iostream> + +#ifdef _WIN32 // _WIN32 is defined by all Windows 32 and 64 bit compilers, but not by others. +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include <windows.h> +# define SLEEP(x) Sleep(x) +#else +# include <unistd.h> +# define SLEEP(x) usleep(x) +#endif + +void Bucket::push(int x) +{ + m_data.push_back(x); +} + +int Bucket::pop(void) +{ + int x = 0; + + if (!m_data.empty()) { + x = m_data.front(); + m_data.pop_front(); + } + + return x; +} + +bool Bucket::empty() +{ + return m_data.empty(); +} + +void Bucket::lock() +{ + m_locked = true; + while (m_locked) { + SLEEP(300); + } +} + +void Bucket::unlock() +{ + m_locked = false; +} + +bool Bucket::virtualBlockerMethod() +{ + lock(); + // The return value was added just for diversity sake. + return true; +} diff --git a/sources/shiboken6/tests/libsample/bucket.h b/sources/shiboken6/tests/libsample/bucket.h new file mode 100644 index 000000000..73e8edd78 --- /dev/null +++ b/sources/shiboken6/tests/libsample/bucket.h @@ -0,0 +1,34 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef BUCKET_H +#define BUCKET_H + +#include "libsamplemacros.h" +#include "objecttype.h" + +#include <list> + +class ObjectType; + +class LIBSAMPLE_API Bucket : public ObjectType +{ +public: + Bucket() = default; + void push(int); + int pop(); + bool empty(); + void lock(); + inline bool locked() { return m_locked; } + void unlock(); + + virtual bool virtualBlockerMethod(); + inline bool callVirtualBlockerMethodButYouDontKnowThis() { return virtualBlockerMethod(); } + +private: + std::list<int> m_data; + + volatile bool m_locked = false; +}; + +#endif // BUCKET_H diff --git a/sources/shiboken6/tests/libsample/bytearray.cpp b/sources/shiboken6/tests/libsample/bytearray.cpp new file mode 100644 index 000000000..78d5162b0 --- /dev/null +++ b/sources/shiboken6/tests/libsample/bytearray.cpp @@ -0,0 +1,166 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "bytearray.h" + +#include <algorithm> +#include <iterator> +#include <cstring> + +ByteArray::ByteArray() : m_data(1, '\0') +{ +} + +ByteArray::ByteArray(char c) +{ + m_data = std::vector<char>(2); + m_data[0] = c; + m_data[1] = '\0'; +} + +ByteArray::ByteArray(const char *data) +{ + size_t len = std::strlen(data); + m_data = std::vector<char>(len + 1); + memcpy(&m_data[0], data, len); + m_data[len] = '\0'; +} + +ByteArray::ByteArray(const char *data, int len) +{ + m_data = std::vector<char>(len + 1); + memcpy(&m_data[0], data, len); + m_data[len] = '\0'; +} + +int ByteArray::size() const +{ + return m_data.size() - 1; +} + +char ByteArray::at(int pos) const +{ + return m_data[pos]; +} + +const char *ByteArray::data() const +{ + return &(m_data[0]); +} + +ByteArray &ByteArray::append(char c) +{ + m_data.pop_back(); + m_data.push_back(c); + m_data.push_back('\0'); + return *this; +} + +ByteArray &ByteArray::append(const char *data) +{ + m_data.pop_back(); + std::copy(data, data + strlen(data), std::back_inserter(m_data)); + m_data.push_back('\0'); + return *this; +} + +ByteArray &ByteArray::append(const char *data, int len) +{ + m_data.pop_back(); + std::copy(data, data + len, std::back_inserter(m_data)); + m_data.push_back('\0'); + return *this; +} + +ByteArray &ByteArray::append(const ByteArray &other) +{ + m_data.pop_back(); + std::copy(other.m_data.begin(), other.m_data.end(), std::back_inserter(m_data)); + return *this; +} + +static bool compare(const std::vector<char> &mine, const char *other) +{ + for (int i = 0; i < (int)mine.size() - 1; ++i) { + if (mine[i] != other[i]) + return false; + } + return true; +} + +bool ByteArray::operator==(const ByteArray &other) const +{ + return m_data == other.m_data; +} +bool operator==(const ByteArray &ba1, const char *ba2) +{ + return compare(ba1.m_data, ba2); +} + +bool operator==(const char *ba1, const ByteArray &ba2) +{ + return compare(ba2.m_data, ba1); +} + +bool ByteArray::operator!=(const ByteArray &other) const +{ + return m_data != other.m_data; +} + +bool operator!=(const ByteArray &ba1, const char *ba2) +{ + return !(ba1 == ba2); +} + +bool operator!=(const char *ba1, const ByteArray &ba2) +{ + return !(ba1 == ba2); +} + +ByteArray &ByteArray::operator+=(char c) +{ + return append(c); +} + +ByteArray &ByteArray::operator+=(const char *data) +{ + return append(data); +} + +ByteArray &ByteArray::operator+=(const ByteArray &other) +{ + return append(other); +} + +ByteArray operator+(const ByteArray &ba1, const ByteArray &ba2) +{ + return ByteArray(ba1) += ba2; +} + +ByteArray operator+(const ByteArray &ba1, const char *ba2) +{ + return ByteArray(ba1) += ByteArray(ba2); +} + +ByteArray operator+(const char *ba1, const ByteArray &ba2) +{ + return ByteArray(ba1) += ba2; +} + +ByteArray operator+(const ByteArray &ba1, char ba2) +{ + return ByteArray(ba1) += ByteArray(ba2); +} + +ByteArray operator+(char ba1, const ByteArray &ba2) +{ + return ByteArray(ba1) += ba2; +} + +unsigned int ByteArray::hash(const ByteArray &byteArray) +{ + unsigned int result = 0; + for (char c : byteArray.m_data) + result = 5U * result + unsigned(c); + return result; +} diff --git a/sources/shiboken6/tests/libsample/bytearray.h b/sources/shiboken6/tests/libsample/bytearray.h new file mode 100644 index 000000000..35ff22367 --- /dev/null +++ b/sources/shiboken6/tests/libsample/bytearray.h @@ -0,0 +1,64 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef BYTEARRAY_H +#define BYTEARRAY_H + +#include "str.h" +#include "libsamplemacros.h" + +#include <vector> + +class LIBSAMPLE_API ByteArray +{ +public: + ByteArray(); + explicit ByteArray(char data); + explicit ByteArray(const char *data); + explicit ByteArray(const char *data, int len); + + int size() const; + char at(int i) const; + char operator[](int i) const; + + const char *data() const; + + ByteArray &append(char c); + ByteArray &append(const char *data); + ByteArray &append(const char *data, int len); + ByteArray &append(const ByteArray &other); + + bool operator==(const ByteArray &other) const; + bool operator!=(const ByteArray &other) const; + + ByteArray &operator+=(char c); + ByteArray &operator+=(const char *data); + ByteArray &operator+=(const ByteArray &other); + + static unsigned int hash(const ByteArray &byteArray); +private: + std::vector<char> m_data; + friend LIBSAMPLE_API bool operator==(const ByteArray &ba1, const char *ba2); + friend LIBSAMPLE_API bool operator==(const char *ba1, const ByteArray &ba2); + friend LIBSAMPLE_API bool operator!=(const ByteArray &ba1, const char *ba2); + friend LIBSAMPLE_API bool operator!=(const char *ba1, const ByteArray &ba2); + + friend LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const ByteArray &ba2); + friend LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const char *ba2); + friend LIBSAMPLE_API ByteArray operator+(const char *ba1, const ByteArray &ba2); + friend LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, char ba2); + friend LIBSAMPLE_API ByteArray operator+(char ba1, const ByteArray &ba2); +}; + +LIBSAMPLE_API bool operator==(const ByteArray &ba1, const char *ba2); +LIBSAMPLE_API bool operator==(const char *ba1, const ByteArray &ba2); +LIBSAMPLE_API bool operator!=(const ByteArray &ba1, const char *ba2); +LIBSAMPLE_API bool operator!=(const char *ba1, const ByteArray &ba2); + +LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const ByteArray &ba2); +LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, const char *ba2); +LIBSAMPLE_API ByteArray operator+(const char *ba1, const ByteArray &ba2); +LIBSAMPLE_API ByteArray operator+(const ByteArray &ba1, char ba2); +LIBSAMPLE_API ByteArray operator+(char ba1, const ByteArray &ba2); + +#endif // BYTEARRAY_H diff --git a/sources/shiboken6/tests/libsample/collector.cpp b/sources/shiboken6/tests/libsample/collector.cpp new file mode 100644 index 000000000..579239bcb --- /dev/null +++ b/sources/shiboken6/tests/libsample/collector.cpp @@ -0,0 +1,37 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "collector.h" + +void Collector::clear() +{ + m_items.clear(); +} + +Collector &Collector::operator<<(ObjectType::Identifier item) +{ + m_items.push_back(item); + return *this; +} + +Collector &Collector::operator<<(const ObjectType *obj) +{ + m_items.push_back(obj->identifier()); + return *this; +} + +std::list<ObjectType::Identifier> Collector::items() +{ + return m_items; +} + +int Collector::size() const +{ + return int(m_items.size()); +} + +Collector &operator<<(Collector &s, const IntWrapper &w) +{ + s << w.toInt(); + return s; +} diff --git a/sources/shiboken6/tests/libsample/collector.h b/sources/shiboken6/tests/libsample/collector.h new file mode 100644 index 000000000..26766847a --- /dev/null +++ b/sources/shiboken6/tests/libsample/collector.h @@ -0,0 +1,37 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef COLLECTOR_H +#define COLLECTOR_H + +#include "libsamplemacros.h" +#include "intwrapper.h" +#include "objecttype.h" + +#include <list> + +class LIBSAMPLE_API Collector +{ +public: + Collector() noexcept = default; + virtual ~Collector() = default; + LIBMINIMAL_DISABLE_COPY_MOVE(Collector) + + void clear(); + + Collector &operator<<(ObjectType::Identifier item); + + Collector &operator<<(const ObjectType *); + + std::list<ObjectType::Identifier> items(); + int size() const; + +private: + std::list<ObjectType::Identifier> m_items; +}; + +/* Helper for testing external operators */ +LIBSAMPLE_API Collector &operator<<(Collector &, const IntWrapper &); + +#endif // COLLECTOR_H + diff --git a/sources/shiboken6/tests/libsample/complex.cpp b/sources/shiboken6/tests/libsample/complex.cpp new file mode 100644 index 000000000..e3bec9aae --- /dev/null +++ b/sources/shiboken6/tests/libsample/complex.cpp @@ -0,0 +1,24 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "complex.h" + +#include <iostream> + +Complex::Complex(double real, double imag) noexcept + : m_real(real), m_imag(imag) +{ +} + +Complex Complex::operator+(const Complex &other) +{ + Complex result; + result.setReal(m_real + other.real()); + result.setImaginary(m_imag + other.imag()); + return result; +} + +void Complex::show() const +{ + std::cout << "(real: " << m_real << ", imag: " << m_imag << ")"; +} diff --git a/sources/shiboken6/tests/libsample/complex.h b/sources/shiboken6/tests/libsample/complex.h new file mode 100644 index 000000000..168fe5c44 --- /dev/null +++ b/sources/shiboken6/tests/libsample/complex.h @@ -0,0 +1,32 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef COMPLEX_H +#define COMPLEX_H + +#include "libsamplemacros.h" + +class LIBSAMPLE_API Complex +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Complex) + + explicit Complex(double real = 0.0, double imag = 0.0) noexcept; + ~Complex() = default; + + inline double real() const { return m_real; } + inline void setReal(double real) { m_real = real; } + inline double imag() const { return m_imag; } + inline void setImaginary(double imag) { m_imag = imag; } + + Complex operator+(const Complex &other); + + void show() const; + +private: + double m_real; + double m_imag; +}; + +#endif // COMPLEX_H + diff --git a/sources/shiboken6/tests/libsample/ctorconvrule.h b/sources/shiboken6/tests/libsample/ctorconvrule.h new file mode 100644 index 000000000..a5411b749 --- /dev/null +++ b/sources/shiboken6/tests/libsample/ctorconvrule.h @@ -0,0 +1,22 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef CTORCONVRULE_H +#define CTORCONVRULE_H + +#include "libsamplemacros.h" + +class CtorConvRule +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(CtorConvRule) + + explicit CtorConvRule(long value) noexcept : m_value(value) {} + virtual ~CtorConvRule() = default; + virtual void dummyVirtualMethod() {} + long value() { return m_value; } +private: + long m_value; +}; + +#endif diff --git a/sources/shiboken6/tests/libsample/ctparam.cpp b/sources/shiboken6/tests/libsample/ctparam.cpp new file mode 100644 index 000000000..9bbbcfc3f --- /dev/null +++ b/sources/shiboken6/tests/libsample/ctparam.cpp @@ -0,0 +1,20 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "ctparam.h" + +namespace SampleNamespace +{ + +CtParam::CtParam(int value) : m_value(value) +{ +} + +CtParam::~CtParam() = default; + +int CtParam::value() const +{ + return m_value; +} + +} // namespace SampleNamespace diff --git a/sources/shiboken6/tests/libsample/ctparam.h b/sources/shiboken6/tests/libsample/ctparam.h new file mode 100644 index 000000000..fa241b587 --- /dev/null +++ b/sources/shiboken6/tests/libsample/ctparam.h @@ -0,0 +1,26 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef CTPARAM_H +#define CTPARAM_H + +#include "libsamplemacros.h" + +namespace SampleNamespace +{ + +class LIBSAMPLE_API CtParam +{ +public: + explicit CtParam(int value); + virtual ~CtParam(); + + int value() const; + +private: + int m_value; +}; + +} // namespace SampleNamespace + +#endif // CTPARAM_H diff --git a/sources/shiboken6/tests/libsample/cvlist.h b/sources/shiboken6/tests/libsample/cvlist.h new file mode 100644 index 000000000..e09c7d943 --- /dev/null +++ b/sources/shiboken6/tests/libsample/cvlist.h @@ -0,0 +1,28 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef CONSTVALUELIST_H +#define CONSTVALUELIST_H + +#include <list> +#include "libsamplemacros.h" + +class CVValueType +{ + CVValueType(); +}; + +using const_ptr_value_list = std::list<const CVValueType*>; + +// This tests binding generation for a container of a const value type. The +// class doesn't need to do anything; this is just to verify that the generated +// binding code (the container conversion in particular) is const-valid. + +class CVListUser +{ +public: + static const_ptr_value_list produce() { return {}; } + static void consume(const const_ptr_value_list &l) { (void)l; } +}; + +#endif // LIST_H diff --git a/sources/shiboken6/tests/libsample/derived.cpp b/sources/shiboken6/tests/libsample/derived.cpp new file mode 100644 index 000000000..d20880431 --- /dev/null +++ b/sources/shiboken6/tests/libsample/derived.cpp @@ -0,0 +1,88 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "derived.h" + +#include <iostream> + +Derived::Derived(int id) noexcept : Abstract(id) +{ +} + +Derived::~Derived() = default; + +Abstract *Derived::createObject() +{ + static int id = 100; + return new Derived(id++); +} + +void Derived::pureVirtual() +{ +} + +void *Derived::pureVirtualReturningVoidPtr() +{ + return nullptr; +} + +void Derived::unpureVirtual() +{ +} + +bool Derived::singleArgument(bool b) +{ + return !b; +} + +double +Derived::defaultValue(int n) +{ + return ((double) n) + 0.1; +} + +OverloadedFuncEnum Derived::overloaded(int, int) +{ + return OverloadedFunc_ii; +} + +OverloadedFuncEnum Derived::overloaded(double) +{ + return OverloadedFunc_d; +} + +Derived::OtherOverloadedFuncEnum Derived::otherOverloaded(int, int, bool, double) +{ + return OtherOverloadedFunc_iibd; +} + +Derived::OtherOverloadedFuncEnum Derived::otherOverloaded(int, double) +{ + return OtherOverloadedFunc_id; +} + +struct SecretClass : public Abstract { + void pureVirtual() override {} + void *pureVirtualReturningVoidPtr() override { return nullptr; } + PrintFormat returnAnEnum() override { return Short; } + void hideFunction(HideType*) override {}; +private: + void pureVirtualPrivate() override {} +}; + +Abstract *Derived::triggerImpossibleTypeDiscovery() +{ + return new SecretClass; +} + +struct AnotherSecretClass : public Derived { +}; + +Abstract *Derived::triggerAnotherImpossibleTypeDiscovery() +{ + return new AnotherSecretClass; +} + +void Derived::pureVirtualPrivate() +{ +} diff --git a/sources/shiboken6/tests/libsample/derived.h b/sources/shiboken6/tests/libsample/derived.h new file mode 100644 index 000000000..cf95cb601 --- /dev/null +++ b/sources/shiboken6/tests/libsample/derived.h @@ -0,0 +1,72 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef DERIVED_H +#define DERIVED_H + +#include "libsamplemacros.h" +#include "abstract.h" + +enum OverloadedFuncEnum { + OverloadedFunc_ii, + OverloadedFunc_d +}; + +class LIBSAMPLE_API Derived : public Abstract +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Derived) + + enum OtherOverloadedFuncEnum { + OtherOverloadedFunc_iibd, + OtherOverloadedFunc_id + }; + + class SomeInnerClass { + public: + void uselessMethod() {} + SomeInnerClass operator+(const SomeInnerClass &other) { return other; } + bool operator==(const SomeInnerClass &) const { return true; } + }; + + explicit Derived(int id = -1) noexcept; + ~Derived() override; + void pureVirtual() override; + void *pureVirtualReturningVoidPtr() override; + void unpureVirtual() override; + + PrintFormat returnAnEnum() override { return Short; } + Type type() const override { return TpDerived; } + + // factory method + static Abstract *createObject(); + + // single argument + bool singleArgument(bool b); + + // method with default value + double defaultValue(int n = 0); + + // overloads + OverloadedFuncEnum overloaded(int i = 0, int d = 0); + OverloadedFuncEnum overloaded(double n); + + // more overloads + OtherOverloadedFuncEnum otherOverloaded(int a, int b, bool c, double d); + OtherOverloadedFuncEnum otherOverloaded(int a, double b); + + inline SomeInnerClass returnMyParameter(const SomeInnerClass &s) { return s; } + + static Abstract *triggerImpossibleTypeDiscovery(); + static Abstract *triggerAnotherImpossibleTypeDiscovery(); + + void hideFunction(HideType*) override {} +protected: + const char *getClassName() { return className(); } + virtual const char *className() const override { return "Derived"; } + +private: + void pureVirtualPrivate() override; +}; +#endif // DERIVED_H + diff --git a/sources/shiboken6/tests/libsample/derivedusingct.cpp b/sources/shiboken6/tests/libsample/derivedusingct.cpp new file mode 100644 index 000000000..720d0ed96 --- /dev/null +++ b/sources/shiboken6/tests/libsample/derivedusingct.cpp @@ -0,0 +1,9 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "derivedusingct.h" + +void DerivedUsingCt::foo() +{ + delete new DerivedUsingCt(42); +} diff --git a/sources/shiboken6/tests/libsample/derivedusingct.h b/sources/shiboken6/tests/libsample/derivedusingct.h new file mode 100644 index 000000000..6bc026d08 --- /dev/null +++ b/sources/shiboken6/tests/libsample/derivedusingct.h @@ -0,0 +1,17 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef DERIVEDUSINGCT_H +#define DERIVEDUSINGCT_H + +#include "libsamplemacros.h" +#include "ctparam.h" + +class LIBSAMPLE_API DerivedUsingCt : public SampleNamespace::CtParam +{ +public: + using CtParam::CtParam; + + void foo(); +}; +#endif // DERIVEDUSINGCT_H diff --git a/sources/shiboken6/tests/libsample/echo.cpp b/sources/shiboken6/tests/libsample/echo.cpp new file mode 100644 index 000000000..7fa8433d3 --- /dev/null +++ b/sources/shiboken6/tests/libsample/echo.cpp @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "echo.h" diff --git a/sources/shiboken6/tests/libsample/echo.h b/sources/shiboken6/tests/libsample/echo.h new file mode 100644 index 000000000..01b11a4a6 --- /dev/null +++ b/sources/shiboken6/tests/libsample/echo.h @@ -0,0 +1,60 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef ECHO_H +#define ECHO_H + +#include "libsamplemacros.h" +#include "str.h" + +class ObjectType; + +class Echo +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Echo) + + Echo() noexcept = default; + ~Echo() = default; + + void doNothingWithConstBool(const bool hi); + void methodWithNamedArg(const Str &string = Str{}); + + Str operator()(const Str &s, const int i) { return s + i; } + + // These method are here just for compilation test purposes + Echo &operator<<(unsigned int item); + Echo &operator<<(signed int item); + Echo &operator<<(const ObjectType *item); + Echo &operator<<(Str str); +}; + +inline void Echo::doNothingWithConstBool(const bool) +{ +} + +inline void Echo::methodWithNamedArg(const Str &) +{ +} + +inline Echo &Echo::operator<<(unsigned int) +{ + return *this; +} + +inline Echo &Echo::operator<<(signed int) +{ + return *this; +} + +inline Echo &Echo::operator<<(const ObjectType *) +{ + return *this; +} + +inline Echo &Echo::operator<<(Str) +{ + return *this; +} + +#endif // ECHO_H diff --git a/sources/shiboken6/tests/libsample/exceptiontest.cpp b/sources/shiboken6/tests/libsample/exceptiontest.cpp new file mode 100644 index 000000000..56144e086 --- /dev/null +++ b/sources/shiboken6/tests/libsample/exceptiontest.cpp @@ -0,0 +1,46 @@ +// Copyright (C) 2018 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "exceptiontest.h" + +class TestException : public std::exception +{ +public: + const char *what() const noexcept override + { return "TestException"; } +}; + +ExceptionTest::ExceptionTest() = default; + +int ExceptionTest::intThrowStdException(bool doThrow) +{ + if (doThrow) + throw TestException(); + return 1; +} + +void ExceptionTest::voidThrowStdException(bool doThrow) +{ + if (doThrow) + throw TestException(); +} + +int ExceptionTest::intThrowInt(bool doThrow) +{ + if (doThrow) + throw 42; + return 1; +} + +void ExceptionTest::voidThrowInt(bool doThrow) +{ + if (doThrow) + throw 42; +} + +ExceptionTest *ExceptionTest::create(bool doThrow) +{ + if (doThrow) + throw TestException(); + return new ExceptionTest; +} diff --git a/sources/shiboken6/tests/libsample/exceptiontest.h b/sources/shiboken6/tests/libsample/exceptiontest.h new file mode 100644 index 000000000..b5812a090 --- /dev/null +++ b/sources/shiboken6/tests/libsample/exceptiontest.h @@ -0,0 +1,25 @@ +// Copyright (C) 2018 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef EXCEPTIONTEST_H +#define EXCEPTIONTEST_H + +#include "libsamplemacros.h" + +#include <exception> + +class LIBSAMPLE_API ExceptionTest +{ + public: + ExceptionTest(); + + int intThrowStdException(bool doThrow); + void voidThrowStdException(bool doThrow); + + int intThrowInt(bool doThrow); + void voidThrowInt(bool doThrow); + + static ExceptionTest *create(bool doThrow); +}; + +#endif // EXCEPTIONTEST_H diff --git a/sources/shiboken6/tests/libsample/expression.cpp b/sources/shiboken6/tests/libsample/expression.cpp new file mode 100644 index 000000000..6f3c5fdc5 --- /dev/null +++ b/sources/shiboken6/tests/libsample/expression.cpp @@ -0,0 +1,79 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + + +#include "expression.h" + +#include <sstream> + +Expression::Expression() noexcept = default; + +Expression::Expression(int number) noexcept : m_value(number) +{ +} + +Expression Expression::operator+(const Expression &other) +{ + Expression expr; + expr.m_operation = Add; + expr.m_operand1 = std::make_shared<Expression>(*this); + expr.m_operand2 = std::make_shared<Expression>(other); + return expr; +} + +Expression Expression::operator-(const Expression &other) +{ + Expression expr; + expr.m_operation = Add; + expr.m_operand1 = std::make_shared<Expression>(*this); + expr.m_operand2 = std::make_shared<Expression>(other); + return expr; +} + +Expression Expression::operator<(const Expression &other) +{ + Expression expr; + expr.m_operation = LessThan; + expr.m_operand1 = std::make_shared<Expression>(*this); + expr.m_operand2 = std::make_shared<Expression>(other); + return expr; +} + +Expression Expression::operator>(const Expression &other) +{ + Expression expr; + expr.m_operation = GreaterThan; + expr.m_operand1 = std::make_shared<Expression>(*this); + expr.m_operand2 = std::make_shared<Expression>(other); + return expr; +} + +std::string Expression::toString() const +{ + std::ostringstream s; + if (m_operation == None) { + s << m_value; + return s.str(); + } + + s << '(' << m_operand1->toString(); + switch (m_operation) { + case Add: + s << '+'; + break; + case Sub: + s << '-'; + break; + case LessThan: + s << '<'; + break; + case GreaterThan: + s << '<'; + break; + default: + s << '?'; + break; + } + s << m_operand2->toString() << ')'; + return s.str(); +} diff --git a/sources/shiboken6/tests/libsample/expression.h b/sources/shiboken6/tests/libsample/expression.h new file mode 100644 index 000000000..e7c5b7306 --- /dev/null +++ b/sources/shiboken6/tests/libsample/expression.h @@ -0,0 +1,40 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + + +#ifndef EXPRESSION_H +#define EXPRESSION_H + +#include "libsamplemacros.h" + +#include <memory> +#include <string> + +class LIBSAMPLE_API Expression +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Expression) + + enum Operation { + None, Add, Sub, LessThan, GreaterThan + }; + + explicit Expression(int number) noexcept; + ~Expression() = default; + + Expression operator>(const Expression &other); + Expression operator<(const Expression &other); + Expression operator+(const Expression &other); + Expression operator-(const Expression &other); + + std::string toString() const; +private: + int m_value = 0; + Operation m_operation = None; + std::shared_ptr<Expression> m_operand1; + std::shared_ptr<Expression> m_operand2; + + Expression() noexcept; +}; + +#endif // EXPRESSION_H diff --git a/sources/shiboken6/tests/libsample/filter.cpp b/sources/shiboken6/tests/libsample/filter.cpp new file mode 100644 index 000000000..950847985 --- /dev/null +++ b/sources/shiboken6/tests/libsample/filter.cpp @@ -0,0 +1,38 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "filter.h" + +Data::Data(Field field, std::string value) + : m_field(field), m_value(value) +{ +} + +Union::Union(const Data &filter) +{ + m_filters.push_back(filter); +} + +Union::Union(const Intersection &filter) +{ + m_filters.push_back(filter); +} + +Intersection::Intersection(const Data &filter) +{ + m_filters.push_back(filter); +} + +Intersection::Intersection(const Union &filter) +{ + m_filters.push_back(filter); +} + +Intersection operator&(const Intersection &a, const Intersection &b) +{ + Intersection filter; + filter.addFilter(a); + filter.addFilter(b); + + return filter; +} diff --git a/sources/shiboken6/tests/libsample/filter.h b/sources/shiboken6/tests/libsample/filter.h new file mode 100644 index 000000000..d82d38eb8 --- /dev/null +++ b/sources/shiboken6/tests/libsample/filter.h @@ -0,0 +1,70 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef FILTER_H +#define FILTER_H + +#include "libsamplemacros.h" + +#include <string> +#include <list> + +class Intersection; + +class LIBSAMPLE_API Filter +{ +}; + +class LIBSAMPLE_API Data : public Filter +{ +public: + enum Field { + Name, + Album, + Year + }; + + explicit Data(Field field, std::string value); + + Field field() const { return m_field; } + std::string value() const { return m_value; } + +private: + Field m_field; + std::string m_value; +}; + +class LIBSAMPLE_API Union : public Filter +{ +public: + + Union(const Data &); + Union(const Intersection &); + Union() = default; + + std::list<Filter> filters() const { return m_filters; } + void addFilter(const Filter &data) { m_filters.push_back(data); } + +private: + std::list<Filter> m_filters; +}; + +class LIBSAMPLE_API Intersection : public Filter +{ +public: + Intersection(const Data &); + Intersection(const Union &); + Intersection() = default; + + std::list<Filter> filters() const { return m_filters; } + void addFilter(const Filter &data) { m_filters.push_back(data); } + +private: + std::list<Filter> m_filters; +}; + +LIBSAMPLE_API Intersection operator&(const Intersection &a, const Intersection &b); + +#endif // FILTER_H + + diff --git a/sources/shiboken6/tests/libsample/functions.cpp b/sources/shiboken6/tests/libsample/functions.cpp new file mode 100644 index 000000000..ad2f4dd5a --- /dev/null +++ b/sources/shiboken6/tests/libsample/functions.cpp @@ -0,0 +1,232 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "functions.h" +#include "polygon.h" + +#include <cstring> +#include <algorithm> +#include <iostream> +#include <numeric> + +void printSomething() +{ + std::cout << __FUNCTION__ << std::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<Complex> gimmeComplexList() +{ + std::list<Complex> 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<Complex, Complex> cpx_pair) +{ + return cpx_pair.first + cpx_pair.second; +} + +double multiplyPair(std::pair<double, double> pair) +{ + return pair.first * pair.second; +} + +int countCharacters(const char *text) +{ + return text != nullptr ? int(std::strlen(text)) : -1; +} + +char *makeCString() +{ + char *string = new char[std::strlen(__FUNCTION__) + 1]; + std::strcpy(string, __FUNCTION__); + return string; +} + +const char *returnCString() +{ + return __FUNCTION__; +} + +GlobalOverloadFuncEnum overloadedFunc(int) +{ + return GlobalOverloadFunc_i; +} + +GlobalOverloadFuncEnum overloadedFunc(double) +{ + return GlobalOverloadFunc_d; +} + +char *returnNullPrimitivePointer() +{ + return nullptr; +} + +ObjectType *returnNullObjectTypePointer() +{ + return nullptr; +} + +Event *returnNullValueTypePointer() +{ + return nullptr; +} + +unsigned int doubleUnsignedInt(unsigned int value) +{ + return value * 2; +} + +long long doubleLongLong(long long value) +{ + return value * 2; +} + +unsigned long long doubleUnsignedLongLong(unsigned long long value) +{ + return value * 2; +} + +short doubleShort(short value) +{ + return value * 2; +} + +int acceptInt(int x) +{ + return x; +} + +const int *acceptIntReturnPtr(int x) +{ + return new int(x); +} + +unsigned int acceptUInt(unsigned int x) +{ + return x; +} + +long acceptLong(long x) +{ + return x; +} + +unsigned long acceptULong(unsigned long x) +{ + return x; +} + +double acceptDouble(double x) +{ + return x; +} + +int acceptIntReference(int &x) +{ + return x; +} + +OddBool acceptOddBoolReference(OddBool &x) +{ + return x; +} + +int sumIntArray(int array[4]) +{ + return std::accumulate(array, array + 4, 0); +} + +double sumDoubleArray(double array[4]) +{ + return std::accumulate(array, array + 4, double(0)); +} + +int sumIntMatrix(int m[2][3]) +{ + int result = 0; + for (int r = 0; r < 2; ++r) { + for (int c = 0; c < 3; ++c) + result += m[r][c]; + } + return result; +} + +double sumDoubleMatrix(double m[2][3]) +{ + double result = 0; + for (int r = 0; r < 2; ++r) { + for (int c = 0; c < 3; ++c) + result += m[r][c]; + } + return result; +} + +ArrayModifyTest::ArrayModifyTest() = default; + +int ArrayModifyTest::sumIntArray(int n, int *array) +{ + return std::accumulate(array, array + n, 0); +} + +ClassWithFunctionPointer::ClassWithFunctionPointer() +{ + callFunctionPointer(0, &ClassWithFunctionPointer::doNothing); +} + +void ClassWithFunctionPointer::callFunctionPointer(int dummy, void (*fp)(void *)) +{ + size_t a = dummy; + fp(reinterpret_cast<void *>(a)); +} + +void ClassWithFunctionPointer::doNothing(void *operand) +{ + (void) operand; +} + +std::string addStdStrings(const std::string &s1, const std::string &s2) +{ + return s1 + s2; +} + +std::wstring addStdWStrings(const std::wstring &s1, const std::wstring &s2) +{ + return s1 + s2; +} + +void testNullPtrT(std::nullptr_t) +{ + std::cout << __FUNCTION__ << '\n'; +} + +int takePolygon(Polygon &&p) +{ + auto p2 = std::move(p); + std::cout << __FUNCTION__ << ' ' << p2.points().size() << " points\n"; + return int(p2.points().size()); +} + +int takeObjectType(ObjectType &&o) +{ + auto o2 = std::move(o); + std::cout << __FUNCTION__ << ' ' << o2.objectName().cstring() << '\n'; + return o2.objectName().size(); +} diff --git a/sources/shiboken6/tests/libsample/functions.h b/sources/shiboken6/tests/libsample/functions.h new file mode 100644 index 000000000..b745aed6b --- /dev/null +++ b/sources/shiboken6/tests/libsample/functions.h @@ -0,0 +1,91 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef FUNCTIONS_H +#define FUNCTIONS_H + +#include "libsamplemacros.h" +#include "oddbool.h" +#include "complex.h" +#include "objecttype.h" + +#include <list> +#include <utility> + +class Polygon; + +enum GlobalEnum { + NoThing, + FirstThing, + SecondThing, + ThirdThing +}; + +enum GlobalOverloadFuncEnum { + GlobalOverloadFunc_i, + GlobalOverloadFunc_d +}; + +LIBSAMPLE_API void printSomething(); +LIBSAMPLE_API int gimmeInt(); +LIBSAMPLE_API double gimmeDouble(); +LIBSAMPLE_API double multiplyPair(std::pair<double, double> pair); +LIBSAMPLE_API std::list<Complex> gimmeComplexList(); +LIBSAMPLE_API Complex sumComplexPair(std::pair<Complex, Complex> cpx_pair); + +LIBSAMPLE_API int countCharacters(const char *text); +LIBSAMPLE_API char *makeCString(); +LIBSAMPLE_API const char *returnCString(); + +LIBSAMPLE_API char *returnNullPrimitivePointer(); +LIBSAMPLE_API ObjectType *returnNullObjectTypePointer(); +LIBSAMPLE_API Event *returnNullValueTypePointer(); + +// Tests overloading on functions (!methods) +LIBSAMPLE_API GlobalOverloadFuncEnum overloadedFunc(int val); +LIBSAMPLE_API GlobalOverloadFuncEnum overloadedFunc(double val); + +LIBSAMPLE_API unsigned int doubleUnsignedInt(unsigned int value); +LIBSAMPLE_API long long doubleLongLong(long long value); +LIBSAMPLE_API unsigned long long doubleUnsignedLongLong(unsigned long long value); +LIBSAMPLE_API short doubleShort(short value); + +LIBSAMPLE_API int acceptInt(int x); +LIBSAMPLE_API const int *acceptIntReturnPtr(int x); +LIBSAMPLE_API unsigned int acceptUInt(unsigned int x); +LIBSAMPLE_API long acceptLong(long x); +LIBSAMPLE_API unsigned long acceptULong(unsigned long x); +LIBSAMPLE_API double acceptDouble(double x); + +LIBSAMPLE_API int acceptIntReference(int &x); +LIBSAMPLE_API OddBool acceptOddBoolReference(OddBool &x); + +LIBSAMPLE_API int sumIntArray(int array[4]); +LIBSAMPLE_API double sumDoubleArray(double array[4]); +LIBSAMPLE_API int sumIntMatrix(int m[2][3]); +LIBSAMPLE_API double sumDoubleMatrix(double m[2][3]); + +LIBSAMPLE_API std::string addStdStrings(const std::string &s1, const std::string &s2); +LIBSAMPLE_API std::wstring addStdWStrings(const std::wstring &s1, const std::wstring &s2); + +LIBSAMPLE_API void testNullPtrT(std::nullptr_t); + +LIBSAMPLE_API int takePolygon(Polygon &&p); +LIBSAMPLE_API int takeObjectType(ObjectType &&o); + +class LIBSAMPLE_API ArrayModifyTest +{ +public: + ArrayModifyTest(); + int sumIntArray(int n, int *array); +}; + +class LIBSAMPLE_API ClassWithFunctionPointer +{ +public: + explicit ClassWithFunctionPointer(); + void callFunctionPointer(int dummy, void (*fp)(void *)); + static void doNothing(void *operand); +}; + +#endif // FUNCTIONS_H diff --git a/sources/shiboken6/tests/libsample/handle.cpp b/sources/shiboken6/tests/libsample/handle.cpp new file mode 100644 index 000000000..93c2abe47 --- /dev/null +++ b/sources/shiboken6/tests/libsample/handle.cpp @@ -0,0 +1,19 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "handle.h" + +SAMPLE_HANDLE HandleHolder::createHandle() +{ + return (SAMPLE_HANDLE) new OBJ; +} + +bool HandleHolder::compare(HandleHolder *other) +{ + return other->m_handle == m_handle; +} + +bool HandleHolder::compare2(HandleHolder *other) +{ + return other->m_handle2 == m_handle2; +} diff --git a/sources/shiboken6/tests/libsample/handle.h b/sources/shiboken6/tests/libsample/handle.h new file mode 100644 index 000000000..07fc89d15 --- /dev/null +++ b/sources/shiboken6/tests/libsample/handle.h @@ -0,0 +1,53 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef HANDLE_H +#define HANDLE_H + +#include "libsamplemacros.h" + +/* See http://bugs.pyside.org/show_bug.cgi?id=1105. */ +namespace Foo { + using SAMPLE_HANDLE = unsigned long; +} + +class LIBSAMPLE_API OBJ +{ +}; + +using SAMPLE_HANDLE = OBJ *; + +class LIBSAMPLE_API HandleHolder +{ +public: + explicit HandleHolder(SAMPLE_HANDLE ptr = nullptr) : m_handle(ptr) {} + explicit HandleHolder(Foo::SAMPLE_HANDLE val): m_handle2(val) {} + + void set(SAMPLE_HANDLE ptr); + inline void set(const Foo::SAMPLE_HANDLE &val) { m_handle2 = val; } + inline SAMPLE_HANDLE handle() const { return m_handle; } + inline Foo::SAMPLE_HANDLE handle2() const { return m_handle2; } + + static SAMPLE_HANDLE createHandle(); + bool compare(HandleHolder *other); + bool compare2(HandleHolder *other); + +private: + SAMPLE_HANDLE m_handle = nullptr; + Foo::SAMPLE_HANDLE m_handle2 = 0; +}; + +inline void HandleHolder::set(SAMPLE_HANDLE) +{ + SAMPLE_HANDLE tmp = m_handle; + m_handle = tmp; +} + +struct LIBSAMPLE_API PrimitiveStruct {}; +using PrimitiveStructPtr = struct PrimitiveStruct *; +struct LIBSAMPLE_API PrimitiveStructPointerHolder +{ + PrimitiveStructPtr primitiveStructPtr; +}; + +#endif // HANDLE_H diff --git a/sources/shiboken6/tests/libsample/implicitconv.cpp b/sources/shiboken6/tests/libsample/implicitconv.cpp new file mode 100644 index 000000000..887fa6b1c --- /dev/null +++ b/sources/shiboken6/tests/libsample/implicitconv.cpp @@ -0,0 +1,39 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "implicitconv.h" + +ImplicitConv::ImplicitConv(const Null &) : + m_ctorEnum(CtorPrimitiveType) +{ +} + +ImplicitConv ImplicitConv::implicitConvCommon(ImplicitConv implicit) +{ + return implicit; +} + +ImplicitConv ImplicitConv::implicitConvDefault(ImplicitConv implicit) +{ + return implicit; +} + +ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(ImplicitConv, int) +{ + return ImplicitConv::OverFunc_Ii; +} + +ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(ImplicitConv, bool) +{ + return ImplicitConv::OverFunc_Ib; +} + +ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(int) +{ + return ImplicitConv::OverFunc_i; +} + +ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(CtorEnum) +{ + return ImplicitConv::OverFunc_C; +} diff --git a/sources/shiboken6/tests/libsample/implicitconv.h b/sources/shiboken6/tests/libsample/implicitconv.h new file mode 100644 index 000000000..5d69eb487 --- /dev/null +++ b/sources/shiboken6/tests/libsample/implicitconv.h @@ -0,0 +1,60 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef IMPLICITCONV_H +#define IMPLICITCONV_H + +#include "libsamplemacros.h" +#include "null.h" + +class ObjectType; + +class LIBSAMPLE_API ImplicitConv +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(ImplicitConv) + + enum CtorEnum { + CtorNone, + CtorOne, + CtorTwo, + CtorThree, + CtorObjectTypeReference, + CtorPrimitiveType + }; + + enum ICOverloadedFuncEnum { + OverFunc_Ii, + OverFunc_Ib, + OverFunc_i, + OverFunc_C + }; + + ImplicitConv() noexcept = default; + ImplicitConv(int objId) noexcept : m_ctorEnum(CtorOne), m_objId(objId) {} + ImplicitConv(CtorEnum ctorEnum) : m_ctorEnum(ctorEnum) {} + ImplicitConv(ObjectType&) : m_ctorEnum(CtorObjectTypeReference) {} + ImplicitConv(double value, bool=true) : m_ctorEnum(CtorNone), m_value(value) {} + ImplicitConv(const Null &null); + ~ImplicitConv() = default; + + inline CtorEnum ctorEnum() const { return m_ctorEnum; } + inline int objId() const { return m_objId; } + inline double value() const { return m_value; } + + static ImplicitConv implicitConvCommon(ImplicitConv implicit); + + static ImplicitConv implicitConvDefault(ImplicitConv implicit = CtorTwo); + + static ICOverloadedFuncEnum implicitConvOverloading(ImplicitConv implicit, int dummyArg); + static ICOverloadedFuncEnum implicitConvOverloading(ImplicitConv implicit, bool dummyArg); + static ICOverloadedFuncEnum implicitConvOverloading(int dummyArg); + static ICOverloadedFuncEnum implicitConvOverloading(CtorEnum dummyArg); + +private: + CtorEnum m_ctorEnum = CtorNone; + int m_objId = -1; + double m_value = -1.0; +}; + +#endif // IMPLICITCONV_H diff --git a/sources/shiboken6/tests/libsample/injectcode.cpp b/sources/shiboken6/tests/libsample/injectcode.cpp new file mode 100644 index 000000000..707d14ed8 --- /dev/null +++ b/sources/shiboken6/tests/libsample/injectcode.cpp @@ -0,0 +1,78 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "injectcode.h" + +#include <sstream> + +InjectCode::InjectCode() noexcept = default; + +InjectCode::~InjectCode() = default; + +template<typename T> +const char *InjectCode::toStr(const T &value) +{ + std::ostringstream s; + s << value; + m_valueHolder = s.str(); + return m_valueHolder.c_str(); +} + +const char *InjectCode::simpleMethod1(int arg0, int arg1) +{ + return toStr(arg0 + arg1); +} + +const char *InjectCode::simpleMethod2() +{ + return "_"; +} + +const char *InjectCode::simpleMethod3(int argc, char **argv) +{ + for (int i = 0; i < argc; ++i) + m_valueHolder += argv[i]; + return m_valueHolder.c_str(); +} + +const char *InjectCode::overloadedMethod(int arg0, bool arg1) +{ + toStr(arg0); + m_valueHolder += arg1 ? "true" : "false"; + return m_valueHolder.c_str(); +} + +const char *InjectCode::overloadedMethod(int arg0, double arg1) +{ + return toStr(arg0 + arg1); +} + +const char *InjectCode::overloadedMethod(int argc, char **argv) +{ + return simpleMethod3(argc, argv); +} + +const char *InjectCode::virtualMethod(int arg) +{ + return toStr(arg); +} + +int InjectCode::arrayMethod(int count, int *values) const +{ + int ret = 0; + for (int i=0; i < count; i++) + ret += values[i]; + return ret; +} + +int InjectCode::sumArrayAndLength(int *values) const +{ + int sum = 0; + + while (*values) { + sum = sum + *values + 1; + ++values; + } + + return sum; +} diff --git a/sources/shiboken6/tests/libsample/injectcode.h b/sources/shiboken6/tests/libsample/injectcode.h new file mode 100644 index 000000000..74046dad5 --- /dev/null +++ b/sources/shiboken6/tests/libsample/injectcode.h @@ -0,0 +1,44 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef INJECTCODE_H +#define INJECTCODE_H + +#include "libsamplemacros.h" + +#include <utility> +#include <string> + +class LIBSAMPLE_API InjectCode +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(InjectCode) + + InjectCode() noexcept; + virtual ~InjectCode(); + + const char *simpleMethod1(int arg0, int arg1); + const char *simpleMethod2(); + const char *simpleMethod3(int argc, char **argv); + + const char *overloadedMethod(int argc, char **argv); + const char *overloadedMethod(int arg0, double arg1); + const char *overloadedMethod(int arg0, bool arg1); + + virtual int arrayMethod(int count, int *values) const; + inline int callArrayMethod(int count, int *values) const { return arrayMethod(count, values); } + virtual const char *virtualMethod(int arg); + int sumArrayAndLength(int *values) const; + +private: + // This attr is just to retain the memory pointed by all return values, + // So, the memory returned by all methods will be valid until someone call + // another method of this class. + std::string m_valueHolder; + + template<typename T> + const char *toStr(const T &value); +}; + +#endif // INJECTCODE_H + diff --git a/sources/shiboken6/tests/libsample/intwrapper.cpp b/sources/shiboken6/tests/libsample/intwrapper.cpp new file mode 100644 index 000000000..0eaf30465 --- /dev/null +++ b/sources/shiboken6/tests/libsample/intwrapper.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + + +#include "intwrapper.h" + +int IntWrapper::toInt() const +{ + return m_number; +} + +IntWrapper &IntWrapper::operator ++() +{ + ++m_number; + return *this; +} + +IntWrapper IntWrapper::operator++(int) +{ + IntWrapper result(*this); + ++m_number; + return result; +} + +IntWrapper &IntWrapper::operator--() +{ + --m_number; + return *this; +} + +IntWrapper IntWrapper::operator--(int) +{ + IntWrapper result(*this); + --m_number; + return result; +} diff --git a/sources/shiboken6/tests/libsample/intwrapper.h b/sources/shiboken6/tests/libsample/intwrapper.h new file mode 100644 index 000000000..cfda5adc7 --- /dev/null +++ b/sources/shiboken6/tests/libsample/intwrapper.h @@ -0,0 +1,62 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef INTWRAPPER_H +#define INTWRAPPER_H + +#include "libsamplemacros.h" + +// Wrapper around int for testing operators +class LIBSAMPLE_API IntWrapper +{ +public: + constexpr explicit IntWrapper(int i) noexcept : m_number(i) {} + int toInt() const; + + IntWrapper &operator++(); + IntWrapper operator++(int); // Postfix + + IntWrapper &operator--(); + IntWrapper operator--(int); // Postfix + + friend constexpr inline bool operator==(IntWrapper lhs, IntWrapper rhs) noexcept + { return lhs.m_number == rhs.m_number; } + friend constexpr inline bool operator!=(IntWrapper lhs, IntWrapper rhs) noexcept + { return lhs.m_number != rhs.m_number; } + friend constexpr inline bool operator<(IntWrapper lhs, IntWrapper rhs) noexcept + { return lhs.m_number < rhs.m_number; } + friend constexpr inline bool operator>(IntWrapper lhs, IntWrapper rhs) noexcept + { return lhs.m_number > rhs.m_number; } + friend constexpr inline bool operator<=(IntWrapper lhs, IntWrapper rhs) noexcept + { return lhs.m_number <= rhs.m_number; } + friend constexpr inline bool operator>=(IntWrapper lhs, IntWrapper rhs) noexcept + { return lhs.m_number >= rhs.m_number; } + + constexpr inline IntWrapper &operator+=(IntWrapper i); + constexpr inline IntWrapper &operator-=(const IntWrapper i); + + friend constexpr inline IntWrapper operator+(IntWrapper lhs, IntWrapper rhs) noexcept + { return IntWrapper(lhs.m_number + rhs.m_number); } + friend constexpr inline IntWrapper operator-(IntWrapper lhs, IntWrapper rhs) noexcept + { return IntWrapper(lhs.m_number - rhs.m_number); } + + // FIXME: Test spaceship operator with C++ 20: + // auto operator<=>(IntWrapper) const = default; + +private: + int m_number; +}; + +constexpr inline IntWrapper &IntWrapper::operator+=(IntWrapper i) +{ + m_number += i.m_number; + return *this; +} + +constexpr inline IntWrapper &IntWrapper::operator-=(const IntWrapper i) +{ + m_number -= i.m_number; + return *this; +} + +#endif // INTWRAPPER_H diff --git a/sources/shiboken6/tests/libsample/libsamplemacros.h b/sources/shiboken6/tests/libsample/libsamplemacros.h new file mode 100644 index 000000000..93e549bfb --- /dev/null +++ b/sources/shiboken6/tests/libsample/libsamplemacros.h @@ -0,0 +1,18 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef LIBSAMPLEMACROS_H +#define LIBSAMPLEMACROS_H + +#include "../libminimal/libminimalmacros.h" + +#define LIBSAMPLE_EXPORT LIBMINIMAL_EXPORT +#define LIBSAMPLE_IMPORT LIBMINIMAL_IMPORT + +#ifdef LIBSAMPLE_BUILD +# define LIBSAMPLE_API LIBSAMPLE_EXPORT +#else +# define LIBSAMPLE_API LIBSAMPLE_IMPORT +#endif + +#endif // LIBSAMPLEMACROS_H diff --git a/sources/shiboken6/tests/libsample/list.h b/sources/shiboken6/tests/libsample/list.h new file mode 100644 index 000000000..5e06d2a66 --- /dev/null +++ b/sources/shiboken6/tests/libsample/list.h @@ -0,0 +1,99 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef LIST_H +#define LIST_H + +#include <list> +#include "libsamplemacros.h" +#include "point.h" + +class ObjectType; + +template<class T> +class List : public std::list<T> +{ +}; + +class IntList : public List<int> +{ +public: + LIBMINIMAL_DEFAULT_MOVE(IntList) + + enum CtorEnum { + NoParamsCtor, + IntCtor, + CopyCtor, + ListOfIntCtor + }; + + inline IntList() noexcept : m_ctorUsed(NoParamsCtor) {} + inline explicit IntList(int val) : m_ctorUsed(IntCtor) { push_back(val); } + inline IntList(const List<int> &lst) : List<int>(lst), m_ctorUsed(ListOfIntCtor) {} + ~IntList() = default; + + inline IntList(const IntList &lst) : List<int>(lst), m_ctorUsed(CopyCtor) {} + IntList &operator=(const IntList &) = default; + + inline void append(int v) { insert(end(), v); } + CtorEnum constructorUsed() { return m_ctorUsed; } +private: + CtorEnum m_ctorUsed; +}; + +class PointValueList : public List<Point> +{ +public: + LIBMINIMAL_DEFAULT_MOVE(PointValueList) + + enum CtorEnum { + NoParamsCtor, + PointCtor, + CopyCtor, + ListOfPointValuesCtor + }; + + inline PointValueList() noexcept : m_ctorUsed(NoParamsCtor) {} + inline explicit PointValueList(Point val) : m_ctorUsed(PointCtor) { push_back(val); } + inline PointValueList(const List<Point> &lst) : List<Point>(lst), m_ctorUsed(ListOfPointValuesCtor) {} + + inline PointValueList(const PointValueList &lst) : List<Point>(lst), m_ctorUsed(CopyCtor) {} + PointValueList &operator=(const PointValueList &) = default; + ~PointValueList() = default; + + inline void append(Point v) { insert(end(), v); } + CtorEnum constructorUsed() { return m_ctorUsed; } +private: + CtorEnum m_ctorUsed; +}; + +class ObjectTypePtrList : public List<ObjectType*> +{ +public: + LIBMINIMAL_DEFAULT_MOVE(ObjectTypePtrList) + + enum CtorEnum { + NoParamsCtor, + ObjectTypeCtor, + CopyCtor, + ListOfObjectTypePtrCtor + }; + + inline ObjectTypePtrList() = default; + inline ObjectTypePtrList(const ObjectTypePtrList &lst) : + List<ObjectType*>(lst), m_ctorUsed(CopyCtor) {} + inline explicit ObjectTypePtrList(ObjectType *val) : + m_ctorUsed(ObjectTypeCtor) { push_back(val); } + inline ObjectTypePtrList(const List<ObjectType*> &lst) : + List<ObjectType*>(lst), m_ctorUsed(ListOfObjectTypePtrCtor) {} + ~ObjectTypePtrList() = default; + + ObjectTypePtrList &operator=(const ObjectTypePtrList &) = default; + + inline void append(ObjectType *v) { insert(end(), v); } + CtorEnum constructorUsed() { return m_ctorUsed; } +private: + CtorEnum m_ctorUsed = NoParamsCtor; +}; + +#endif // LIST_H diff --git a/sources/shiboken6/tests/libsample/listuser.cpp b/sources/shiboken6/tests/libsample/listuser.cpp new file mode 100644 index 000000000..9bb7f7798 --- /dev/null +++ b/sources/shiboken6/tests/libsample/listuser.cpp @@ -0,0 +1,63 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "listuser.h" + +#include <numeric> +#include <cstdlib> + +std::list<int> ListUser::callCreateList() +{ + return createList(); +} + +ListUser::ListUser() = default; +ListUser::ListUser(const ListUser &other) = default; +ListUser::ListUser(ListUser &&other) noexcept = default; +ListUser &ListUser::operator=(const ListUser &other) = default; +ListUser &ListUser::operator=(ListUser &&other) noexcept = default; +ListUser::~ListUser() = default; + +std::list<int> ListUser::createList() +{ + std::list<int> retval; + for (int i = 0; i < 4; i++) + retval.push_front(rand()); + return retval; +} + +std::list<Complex> ListUser::createComplexList(Complex cpx0, Complex cpx1) +{ + std::list<Complex> retval; + retval.push_back(cpx0); + retval.push_back(cpx1); + return retval; +} + +double ListUser::sumList(std::list<int> vallist) +{ + return std::accumulate(vallist.begin(), vallist.end(), 0.0); +} + +double ListUser::sumList(std::list<double> vallist) +{ + return std::accumulate(vallist.begin(), vallist.end(), 0.0); +} + +ListUser::ListOfSomething ListUser::listOfPoints(const std::list<Point> &) +{ + return ListOfPoint; +} + +ListUser::ListOfSomething ListUser::listOfPoints(const std::list<PointF> &) +{ + return ListOfPointF; +} + +void ListUser::multiplyPointList(PointList &points, double multiplier) +{ + for (auto *point : points) { + point->setX(point->x() * multiplier); + point->setY(point->y() * multiplier); + } +} diff --git a/sources/shiboken6/tests/libsample/listuser.h b/sources/shiboken6/tests/libsample/listuser.h new file mode 100644 index 000000000..96781ed16 --- /dev/null +++ b/sources/shiboken6/tests/libsample/listuser.h @@ -0,0 +1,53 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef LISTUSER_H +#define LISTUSER_H + +#include "complex.h" +#include "point.h" +#include "pointf.h" + +#include "libsamplemacros.h" + +#include <list> + +class LIBSAMPLE_API ListUser +{ +public: + using PointList = std::list<Point *>; + + enum ListOfSomething { + ListOfPoint, + ListOfPointF + }; + + ListUser(); + ListUser(const ListUser &other); + ListUser(ListUser &&other) noexcept; + ListUser &operator=(const ListUser &other); + ListUser &operator=(ListUser &&other) noexcept; + virtual ~ListUser(); + + virtual std::list<int> createList(); + std::list<int> callCreateList(); + + static std::list<Complex> createComplexList(Complex cpx0, Complex cpx1); + + double sumList(std::list<int> vallist); + double sumList(std::list<double> vallist); + + static ListOfSomething listOfPoints(const std::list<Point> &pointlist); + static ListOfSomething listOfPoints(const std::list<PointF> &pointlist); + + static void multiplyPointList(PointList &points, double multiplier); + + inline void setList(std::list<int> lst) { m_lst = lst; } + inline std::list<int> getList() const { return m_lst; } + +private: + std::list<int> m_lst; +}; + +#endif // LISTUSER_H + diff --git a/sources/shiboken6/tests/libsample/main.cpp b/sources/shiboken6/tests/libsample/main.cpp new file mode 100644 index 000000000..1b44642ae --- /dev/null +++ b/sources/shiboken6/tests/libsample/main.cpp @@ -0,0 +1,209 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include <iostream> +#include <list> +#include "abstract.h" +#include "derived.h" +#include "kindergarten.h" +#include "complex.h" +#include "point.h" +#include "size.h" +#include "listuser.h" +#include "samplenamespace.h" + +int +main(int argv, char **argc) +{ + std::cout << std::endl; + + Derived derived; + + std::cout << std::endl; + + derived.unpureVirtual(); + derived.pureVirtual(); + derived.callPureVirtual(); + + std::cout << std::endl; + auto *abs = Abstract::createObject(); + std::cout << "Abstract::createObject(): " << abs << std::endl << std::endl; + delete abs; + + abs = Derived::createObject(); + std::cout << "Derived::createObject() : "; + abs->show(); + std::cout << std::endl; + delete abs; + std::cout << std::endl; + + abs = Derived::createObject(); + std::cout << "Derived::createObject() : "; + abs->show(); + std::cout << std::endl; + delete abs; + std::cout << std::endl; + + std::cout << "\n-----------------------------------------\n"; + + KinderGarten kg; + Derived *d[] = { 0, 0, 0 }; + + for (int i = 0; i < 3; i++) { + d[i] = new Derived(i); + d[i]->show(); + std::cout << std::endl; + kg.addChild(d[i]); + } + + kg.show(); + std::cout << std::endl; + + std::cout << "\n* kill child "; + d[2]->show(); + std::cout << " ----------------\n"; + kg.killChild(d[2]); + kg.show(); + std::cout << std::endl; + + std::cout << "\n* release child "; + d[1]->show(); + std::cout << " -------------\n"; + Abstract *released = kg.releaseChild(d[1]); + std::cout << "released: "; + released->show(); + std::cout << std::endl; + kg.show(); + std::cout << "\n\n* kill children ------------------------------------\n"; + kg.killChildren(); + kg.show(); + std::cout << "\n\n-----------------------------------------\n"; + ListUser lu; + std::cout << "ListUser::createList()\n"; + std::list<int> intlist = lu.createList(); + for (std::list<int>::iterator it = intlist.begin(); it != intlist.end(); it++) + std::cout << "* " << *it << std::endl; + + std::cout << "ListUser::createComplexList\n"; + std::list<Complex> cpxlist = ListUser::createComplexList(Complex(1.1, 2.2), Complex(3.3, 4.4)); + for (std::list<Complex>::iterator it = cpxlist.begin(); it != cpxlist.end(); it++) { + std::cout << "* "; + (*it).show(); + std::cout << std::endl; + } + std::cout << "\n-----------------------------------------\n" + << "SampleNamespace\n"; + + std::cout << "SampleNamespace::RandomNumber: "; + std::cout << SampleNamespace::getNumber(SampleNamespace::RandomNumber); + std::cout << std::endl; + std::cout << "SampleNamespace::UnixTime: "; + std::cout << SampleNamespace::getNumber(SampleNamespace::UnixTime); + std::cout << std::endl; + double val_d = 1.3; + std::cout << "SampleNamespace::powerOfTwo(" << val_d << "): "; + std::cout << SampleNamespace::powerOfTwo(val_d) << std::endl; + int val_i = 7; + std::cout << "SampleNamespace::powerOfTwo(" << val_i << "): "; + std::cout << SampleNamespace::powerOfTwo(val_i) << std::endl; + std::cout << std::endl; + + std::cout << "-----------------------------------------" << std::endl; + std::cout << "Point" << std::endl; + + Point p1(1.1, 2.2); + std::cout << "p1: "; + p1.show(); + std::cout << std::endl; + + Point p2(3.4, 5.6); + std::cout << "p2: "; + p2.show(); + std::cout << std::endl; + + std::cout << "p1 + p2 == "; + (p1 + p2).show(); + std::cout << std::endl; + + std::cout << "p1 * 2.0 == "; + (p1 * 2.0).show(); + std::cout << std::endl; + + std::cout << "1.5 * p2 == "; + (1.5 * p2).show(); + std::cout << std::endl; + + std::cout << "p1: "; + p1.show(); + std::cout << std::endl << "p2: "; + p2.show(); + std::cout << std::endl << "p1 += p2" << std::endl; + p1 += p2; + std::cout << "p1: "; + p1.show(); + std::cout << std::endl; + + std::cout << "p1 == p2 ? " << ((p1 == p2) ? "true" : "false") << std::endl; + std::cout << "p1 == p1 ? " << ((p1 == p1) ? "true" : "false") << std::endl; + std::cout << "p2 == p2 ? " << ((p2 == p2) ? "true" : "false") << std::endl; + + std::cout << "-----------------------------------------" << std::endl; + std::cout << "Size" << std::endl; + + Size s1(2, 2); + std::cout << "s1: "; + s1.show(); + std::cout << ", area: " << s1.calculateArea(); + std::cout << std::endl; + + Size s2(3, 5); + std::cout << "s2: "; + s2.show(); + std::cout << ", area: " << s2.calculateArea(); + std::cout << std::endl; + + std::cout << std::endl; + + std::cout << "s1 == s2 ? " << ((s1 == s2) ? "true" : "false") << std::endl; + std::cout << "s1 != s2 ? " << ((s1 != s2) ? "true" : "false") << std::endl; + + std::cout << "s1 < s2 ? " << ((s1 < s2) ? "true" : "false") << std::endl; + std::cout << "s1 <= s2 ? " << ((s1 <= s2) ? "true" : "false") << std::endl; + std::cout << "s1 > s2 ? " << ((s1 > s2) ? "true" : "false") << std::endl; + std::cout << "s1 >= s2 ? " << ((s1 >= s2) ? "true" : "false") << std::endl; + + std::cout << "s1 < 10 ? " << ((s1 < 10) ? "true" : "false") << std::endl; + std::cout << "s1 <= 10 ? " << ((s1 <= 10) ? "true" : "false") << std::endl; + std::cout << "s1 > 10 ? " << ((s1 > 10) ? "true" : "false") << std::endl; + std::cout << "s1 >= 10 ? " << ((s1 >= 10) ? "true" : "false") << std::endl; + std::cout << "s2 < 10 ? " << ((s2 < 10) ? "true" : "false") << std::endl; + std::cout << "s2 <= 10 ? " << ((s2 <= 10) ? "true" : "false") << std::endl; + std::cout << "s2 > 10 ? " << ((s2 > 10) ? "true" : "false") << std::endl; + std::cout << "s2 >= 10 ? " << ((s2 >= 10) ? "true" : "false") << std::endl; + std::cout << std::endl; + + std::cout << "s1: "; + s1.show(); + std::cout << std::endl << "s2: "; + s2.show(); + std::cout << std::endl << "s1 += s2" << std::endl; + s1 += s2; + std::cout << "s1: "; + s1.show(); + std::cout << std::endl; + + std::cout << std::endl; + + std::cout << "s1: "; + s1.show(); + std::cout << std::endl << "s1 *= 2.0" << std::endl; + s1 *= 2.0; + std::cout << "s1: "; + s1.show(); + std::cout << std::endl; + + std::cout << std::endl; + + return 0; +} + diff --git a/sources/shiboken6/tests/libsample/mapuser.cpp b/sources/shiboken6/tests/libsample/mapuser.cpp new file mode 100644 index 000000000..40059bbcd --- /dev/null +++ b/sources/shiboken6/tests/libsample/mapuser.cpp @@ -0,0 +1,48 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "mapuser.h" + +#include <iostream> + +std::map<std::string, std::pair<Complex, int> > MapUser::callCreateMap() +{ + return createMap(); +} + +std::map<std::string, std::pair<Complex, int> > MapUser::createMap() +{ + std::map<std::string, std::pair<Complex, int> > retval; + + std::pair<Complex, int> value{Complex(1.2, 3.4), 2}; + retval.insert({"zero", value}); + + value = {Complex(5.6, 7.8), 3}; + retval.insert({"one", value}); + + value = {Complex(9.1, 2.3), 5}; + retval.insert({"two", value}); + + return retval; +} + +void MapUser::showMap(std::map<std::string, int> mapping) +{ + std::cout << __FUNCTION__ << std::endl; + for (const auto &p : mapping) + std::cout << p.first << " => " << p.second << std::endl; +} + +void MapUser::pointerToMap(std::map<std::string, std::string> *) +{ +} + +void MapUser::referenceToMap(std::map<std::string, std::string> &) +{ +} + +std::map<int, std::list<std::list<double> > > MapUser::foo() const +{ + std::map<int, std::list<std::list<double> > > result; + return result; +} diff --git a/sources/shiboken6/tests/libsample/mapuser.h b/sources/shiboken6/tests/libsample/mapuser.h new file mode 100644 index 000000000..1677a4bfb --- /dev/null +++ b/sources/shiboken6/tests/libsample/mapuser.h @@ -0,0 +1,45 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef MAPUSER_H +#define MAPUSER_H + +#include "libsamplemacros.h" + +#include "complex.h" +#include "bytearray.h" + +#include <map> +#include <list> +#include <utility> +#include <string> + +class LIBSAMPLE_API MapUser +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(MapUser) + + MapUser() noexcept = default; + virtual ~MapUser() = default; + + virtual std::map<std::string, std::pair<Complex, int> > createMap(); + std::map<std::string, std::pair<Complex, int> > callCreateMap(); + + void showMap(std::map<std::string, int> mapping); + + inline void setMap(std::map<std::string, std::list<int> > map) { m_map = map; } + inline std::map<std::string, std::list<int> > getMap() { return m_map; } + + // Compile test + static void pointerToMap(std::map<std::string, std::string> *arg); + static void referenceToMap(std::map<std::string, std::string> &arg); + + inline const std::map<int, ByteArray> &passMapIntValueType(const std::map<int, ByteArray>& arg) { return arg; } + + std::map<int, std::list<std::list<double> > > foo() const; + +private: + std::map<std::string, std::list<int> > m_map; +}; + +#endif // MAPUSER_H diff --git a/sources/shiboken6/tests/libsample/modelindex.h b/sources/shiboken6/tests/libsample/modelindex.h new file mode 100644 index 000000000..48e1b7de3 --- /dev/null +++ b/sources/shiboken6/tests/libsample/modelindex.h @@ -0,0 +1,50 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef MODELINDEX_H +#define MODELINDEX_H + +class ModelIndex +{ +public: + ModelIndex() = default; + + inline void setValue(int value) { m_value = value; } + inline int value() const { return m_value; } + static int getValue(const ModelIndex &index) { return index.value(); } + +private: + int m_value = 0; +}; + +class ReferentModelIndex +{ +public: + ReferentModelIndex() = default; + + explicit ReferentModelIndex(const ModelIndex &index) : m_index(index) {} + + inline void setValue(int value) { m_index.setValue(value); } + inline int value() const { return m_index.value(); } + operator const ModelIndex&() const { return m_index; } + +private: + ModelIndex m_index; +}; + +class PersistentModelIndex +{ +public: + PersistentModelIndex() = default; + + explicit PersistentModelIndex(const ModelIndex &index) : m_index(index) {} + + inline void setValue(int value) { m_index.setValue(value); } + inline int value() const { return m_index.value(); } + operator ModelIndex() const { return m_index; } + +private: + ModelIndex m_index; +}; + +#endif // MODELINDEX_H diff --git a/sources/shiboken6/tests/libsample/modifications.cpp b/sources/shiboken6/tests/libsample/modifications.cpp new file mode 100644 index 000000000..6d627c4c1 --- /dev/null +++ b/sources/shiboken6/tests/libsample/modifications.cpp @@ -0,0 +1,207 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "modifications.h" +#include "objecttype.h" + +#include <iostream> + +Modifications::Modifications() + : m_object(new ObjectType()) +{ + m_object->setObjectName("MyObject"); +} + +Modifications::~Modifications() +{ + delete m_object; +} + +Modifications::OverloadedModFunc Modifications::overloaded(int, bool, Point, Point) +{ + return Overloaded_ibPP; +} + +Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, int) +{ + return Overloaded_ibii; +} + +Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, Point) +{ + return Overloaded_ibiP; +} + +Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, bool) +{ + return Overloaded_ibib; +} + +Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, double) +{ + return Overloaded_ibid; +} + +void Modifications::argRemoval0(int, bool, int, int) +{ +} + +void Modifications::argRemoval0(int, bool, int, bool) +{ +} + +void Modifications::argRemoval1(int, bool, Point, Point, int) +{ +} + +void Modifications::argRemoval1(int, bool, int, bool) +{ +} + +void Modifications::argRemoval2(int, bool, Point, Point, int) +{ +} + +void Modifications::argRemoval3(int, Point, bool, Point, int) +{ +} + +void Modifications::argRemoval4(int, Point, bool, Point, int) +{ +} + +void Modifications::argRemoval5(int, bool, Point, Point, int) +{ +} + +void Modifications::argRemoval5(int, bool, int, bool) +{ +} + +std::pair<double, double> Modifications::pointToPair(Point pt, bool *ok) +{ + std::pair<double, double> 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() +{ + std::cout << __FUNCTION__ << std::endl; +} + +int Modifications::cppMultiply(int a, int b) +{ + return a * b; +} + +const char *Modifications::className() +{ + return "Modifications"; +} + +Point Modifications::sumPointArray(int arraySize, const Point pointArray[]) +{ + Point point; + for (int i = 0; i < arraySize; ++i) + point = point + pointArray[i]; + return point; +} + +int Modifications::getSize(const void *data, int size) +{ + (void)data; + return size; +} + +int Modifications::sumPointCoordinates(const Point *point) +{ + return point->x() + point->y(); +} + +double Modifications::differenceOfPointCoordinates(const Point *pt, bool *ok) +{ + if (!pt) { + *ok = false; + return 0.0; + } + *ok = true; + double result = pt->x() - pt->y(); + if (result < 0) + result = result * -1.0; + return result; +} + +bool Modifications::nonConversionRuleForArgumentWithDefaultValue(ObjectType **object) +{ + if (object) + *object = m_object; + return true; +} + +void Modifications::setEnumValue(TestEnum e) +{ + m_enumValue = e; +} + +Modifications::TestEnum Modifications::enumValue() const +{ + return m_enumValue; +} + +Modifications::TestEnum Modifications::defaultEnumValue() const +{ + return TestEnumValue2; +} + +bool Modifications::wasGetAttroCalled() const +{ + return m_getAttroCalled; +} + +void Modifications::notifyGetAttroCalled() +{ + m_getAttroCalled = true; +} + +bool Modifications::wasSetAttroCalled() const +{ + return m_setAttroCalled; +} + +void Modifications::notifySetAttroCalled() +{ + m_setAttroCalled = true; +} diff --git a/sources/shiboken6/tests/libsample/modifications.h b/sources/shiboken6/tests/libsample/modifications.h new file mode 100644 index 000000000..5bd1bac47 --- /dev/null +++ b/sources/shiboken6/tests/libsample/modifications.h @@ -0,0 +1,145 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef MODIFICATIONS_H +#define MODIFICATIONS_H + +#include "libsamplemacros.h" +#include "point.h" +#include "oddbool.h" + +#include <utility> + +class ObjectType; + +class LIBSAMPLE_API Modifications +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Modifications) + + Modifications(); + virtual ~Modifications(); + + enum OverloadedModFunc { + OverloadedNone, + Overloaded_ibid, + Overloaded_ibib, + Overloaded_ibiP, + Overloaded_ibii, + Overloaded_ibPP + }; + + enum TestEnum { + TestEnumValue1, + TestEnumValue2 + }; + + // those overloaded methods should be heavily modified + // to push the overload decisor to its limits + OverloadedModFunc overloaded(int a0, bool b0, int c0, double d0); + OverloadedModFunc overloaded(int a1, bool b1, int c1, bool d1); + OverloadedModFunc overloaded(int a2, bool b2, int c2, Point d2); + OverloadedModFunc overloaded(int a3, bool b3, int c3 = 123, int d3 = 456); + OverloadedModFunc overloaded(int a4, bool b4, Point c4, Point d4); + + void argRemoval0(int a0, bool a1, int a2 = 123, int a3 = 456); + void argRemoval0(int a0, bool a1, int a2, bool a3); + + void argRemoval1(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), + int a4 = 333); + void argRemoval1(int a0, bool a1, int a2, bool a3); + + void argRemoval2(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), + int a4 = 333); + + void argRemoval3(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4), + int a4 = 333); + + void argRemoval4(int a0, Point a1, bool a2, Point a3 = Point(3, 4), int a4 = 333); + + void argRemoval5(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), + int a4 = 333); + void argRemoval5(int a0, bool a1, int a2, bool a3); + + // '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<double, double> 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(); + + Point sumPointArray(int arraySize, const Point pointArray[]); + + // Replace 'const void*' by 'ByteArray&'. + int getSize(const void *data, int size); + + // Mark the argument with a <no-null-pointer/> tag; + // the test implementation must expect point never to be null. + int sumPointCoordinates(const Point *point); + + // Modify the return value of a virtual method. + virtual double differenceOfPointCoordinates(const Point *pt, bool *ok); + double callDifferenceOfPointCoordinates(const Point *pt, bool *ok) + { return differenceOfPointCoordinates(pt, ok); } + + // Sets an ObjectType in the argument and returns true. + bool nonConversionRuleForArgumentWithDefaultValue(ObjectType **object = nullptr); + ObjectType *getObject() const { return m_object; } + + // Inject code with a %CONVERTTOPYTHON that receives an user's primitive type. + static inline OddBool passOddBool(OddBool ob) { return ob; } + + void setEnumValue(TestEnum e = TestEnumValue1); + TestEnum enumValue() const; + TestEnum defaultEnumValue() const; + + bool wasGetAttroCalled() const; + void notifyGetAttroCalled(); + + bool wasSetAttroCalled() const; + void notifySetAttroCalled(); + +private: + ObjectType *m_object; + TestEnum m_enumValue = TestEnumValue1; + bool m_getAttroCalled = false; + bool m_setAttroCalled = false; +}; + +class LIBSAMPLE_API AbstractModifications : public Modifications +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(AbstractModifications) + + AbstractModifications() noexcept = default; + ~AbstractModifications() override = default; + + inline bool invert(bool value) { return !value; } + + // completely remove this method in Python + virtual void pointlessPureVirtualMethod() = 0; +}; + +#endif // MODIFICATIONS_H diff --git a/sources/shiboken6/tests/libsample/modified_constructor.cpp b/sources/shiboken6/tests/libsample/modified_constructor.cpp new file mode 100644 index 000000000..c39c97738 --- /dev/null +++ b/sources/shiboken6/tests/libsample/modified_constructor.cpp @@ -0,0 +1,16 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "modified_constructor.h" + +ModifiedConstructor::ModifiedConstructor(int first_arg) +{ + m_stored_value = first_arg; +} + +int ModifiedConstructor::retrieveValue() const +{ + return m_stored_value; +} + + diff --git a/sources/shiboken6/tests/libsample/modified_constructor.h b/sources/shiboken6/tests/libsample/modified_constructor.h new file mode 100644 index 000000000..a27899f3f --- /dev/null +++ b/sources/shiboken6/tests/libsample/modified_constructor.h @@ -0,0 +1,21 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef MODIFIEDCONSTRUCTOR_H +#define MODIFIEDCONSTRUCTOR_H + +#include "libsamplemacros.h" + +class LIBSAMPLE_API ModifiedConstructor +{ +public: + + explicit ModifiedConstructor(int first_arg); + int retrieveValue() const; + +private: + int m_stored_value; +}; + +#endif // MODIFIEDCONSTRUCTOR_H + diff --git a/sources/shiboken6/tests/libsample/multiple_derived.cpp b/sources/shiboken6/tests/libsample/multiple_derived.cpp new file mode 100644 index 000000000..be535c62f --- /dev/null +++ b/sources/shiboken6/tests/libsample/multiple_derived.cpp @@ -0,0 +1,24 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "multiple_derived.h" + +MDerived1::MDerived1() noexcept = default; + +MDerived2::MDerived2() noexcept = default; + +MDerived3::MDerived3() noexcept = default; + +MDerived4::MDerived4() noexcept = default; + +MDerived5::MDerived5() noexcept = default; + +MDerived1 *MDerived1::transformFromBase1(Base1 *self) +{ + return dynamic_cast<MDerived1*>(self); +} + +MDerived1 *MDerived1::transformFromBase2(Base2 *self) +{ + return dynamic_cast<MDerived1*>(self); +} diff --git a/sources/shiboken6/tests/libsample/multiple_derived.h b/sources/shiboken6/tests/libsample/multiple_derived.h new file mode 100644 index 000000000..8c2143ed6 --- /dev/null +++ b/sources/shiboken6/tests/libsample/multiple_derived.h @@ -0,0 +1,202 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef MDERIVED_H +#define MDERIVED_H + +#include "libsamplemacros.h" + +#include <string> + +class Base1 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Base1) + + Base1() noexcept = default; + virtual ~Base1() = default; + + virtual int base1Method() { return m_value; } + + virtual void publicMethod() {}; + +private: + int m_value = 1; +}; + +class Base2 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Base2) + + Base2() noexcept = default; + virtual ~Base2() = default; + virtual int base2Method() { return m_value; } + +private: + int m_value = 2; +}; + +class LIBSAMPLE_API MDerived1 : public Base1, public Base2 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived1) + + MDerived1() noexcept; + ~MDerived1() override = default; + + int mderived1Method() { return m_value; } + int base1Method () override { return Base1::base1Method() * 10; } + int base2Method() override { return Base2::base2Method() * 10; } + + inline Base1 *castToBase1() { return (Base1*) this; } + inline Base2 *castToBase2() { return (Base2*) this; } + + static MDerived1 *transformFromBase1(Base1 *self); + static MDerived1 *transformFromBase2(Base2 *self); + +private: + void publicMethod() override {} + int m_value = 100; +}; + +class SonOfMDerived1 : public MDerived1 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(SonOfMDerived1) + + SonOfMDerived1() noexcept = default; + ~SonOfMDerived1() = default; + + inline MDerived1 *castToMDerived1() { return this; } + + int sonOfMDerived1Method() { return m_value; } + +private: + int m_value = 0; +}; + +class Base3 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Base3) + + explicit Base3(int val = 3) noexcept : m_value(val) {} + virtual ~Base3() = default; + int base3Method() { return m_value; } + +private: + int m_value; +}; + +class Base4 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Base4) + + Base4() noexcept = default; + virtual ~Base4() = default; + int base4Method() { return m_value; } + +private: + int m_value = 4; +}; + +class Base5 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Base5) + + Base5() noexcept = default; + virtual ~Base5() = default; + virtual int base5Method() { return m_value; } + +private: + int m_value = 5; +}; + +class Base6 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Base6) + + Base6() noexcept = default; + virtual ~Base6() = default; + virtual int base6Method() { return m_value; } + +private: + int m_value = 6; +}; + +class LIBSAMPLE_API MDerived2 : public Base3, public Base4, public Base5, public Base6 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived2) + + MDerived2() noexcept; + virtual ~MDerived2() = default; + + inline int base4Method() { return Base3::base3Method() * 10; } + inline int mderived2Method() { return m_value; } + + inline Base3 *castToBase3() { return this; } + inline Base4 *castToBase4() { return this; } + inline Base5 *castToBase5() { return this; } + inline Base6 *castToBase6() { return this; } + +private: + int m_value = 200; +}; + +class LIBSAMPLE_API MDerived3 : public MDerived1, public MDerived2 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived3) + + MDerived3() noexcept; + virtual ~MDerived3() = default; + + inline virtual int mderived3Method() { return m_value; } + + inline MDerived1 *castToMDerived1() { return this; } + inline MDerived2 *castToMDerived2() { return this; } + + inline Base3 *castToBase3() { return (Base3*) this; } + +private: + int m_value = 3000; +}; + +class LIBSAMPLE_API MDerived4 : public Base3, public Base4 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived4) + + MDerived4() noexcept; + ~MDerived4() = default; + + inline int mderived4Method() { return 0; } + inline int justDummyMethod() { return m_value; } + + inline Base3 *castToBase3() { return this; } + inline Base4 *castToBase4() { return this; } + +private: + int m_value; +}; + +class LIBSAMPLE_API MDerived5 : public Base3, public Base4 +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived5) + + MDerived5() noexcept; + virtual ~MDerived5() = default; + + virtual int mderived5Method() { return 0; } + + inline Base3 *castToBase3() { return this; } + inline Base4 *castToBase4() { return this; } +}; + +#endif // MDERIVED_H diff --git a/sources/shiboken6/tests/libsample/noimplicitconversion.h b/sources/shiboken6/tests/libsample/noimplicitconversion.h new file mode 100644 index 000000000..a0b91380b --- /dev/null +++ b/sources/shiboken6/tests/libsample/noimplicitconversion.h @@ -0,0 +1,27 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef NOIMPLICITCONVERSION_H +#define NOIMPLICITCONVERSION_H + +#include "libsamplemacros.h" + +// This class must not have implicit conversions AND +// no conversion operators should be defined in its own module. +class NoImplicitConversion +{ +public: + explicit NoImplicitConversion(int objId) : m_objId(objId) {} + inline int objId() const { return m_objId; } + inline static int receivesNoImplicitConversionByValue(NoImplicitConversion arg) + { return arg.m_objId; } + inline static int receivesNoImplicitConversionByPointer(NoImplicitConversion *arg) + { return arg->m_objId; } + inline static int receivesNoImplicitConversionByReference(NoImplicitConversion &arg) + { return arg.m_objId; } +private: + int m_objId; +}; + +#endif // NOIMPLICITCONVERSION_H + diff --git a/sources/shiboken6/tests/libsample/nondefaultctor.h b/sources/shiboken6/tests/libsample/nondefaultctor.h new file mode 100644 index 000000000..fa97b8859 --- /dev/null +++ b/sources/shiboken6/tests/libsample/nondefaultctor.h @@ -0,0 +1,54 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef NONDEFAULTCTOR_H +#define NONDEFAULTCTOR_H + +#include "libsamplemacros.h" + +class NonDefaultCtor +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(NonDefaultCtor) + + explicit NonDefaultCtor(int value) noexcept : m_value(value) + { + } + + virtual ~NonDefaultCtor() = default; + + inline int value() const + { + return m_value; + } + + inline NonDefaultCtor returnMyself() + { + return *this; + } + + inline NonDefaultCtor returnMyself(int) + { + return *this; + } + + inline NonDefaultCtor returnMyself(int, NonDefaultCtor) + { + return *this; + } + + virtual NonDefaultCtor returnMyselfVirtual() + { + return *this; + } + + inline NonDefaultCtor callReturnMyselfVirtual() + { + return returnMyselfVirtual(); + } + +private: + int m_value; +}; + +#endif // NONDEFAULTCTOR_H diff --git a/sources/shiboken6/tests/libsample/nontypetemplate.h b/sources/shiboken6/tests/libsample/nontypetemplate.h new file mode 100644 index 000000000..e41c21604 --- /dev/null +++ b/sources/shiboken6/tests/libsample/nontypetemplate.h @@ -0,0 +1,27 @@ +// Copyright (C) 2018 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef NONTYPETEMPLATE_H +#define NONTYPETEMPLATE_H + +#include "libsamplemacros.h" + +#include <algorithm> +#include <numeric> + +template <int Size> class IntArray +{ +public: + explicit IntArray(const int *data) { std::copy(data, data + Size, m_array); } + explicit IntArray(int v) { std::fill(m_array, m_array + Size, v); } + + int sum() const { return std::accumulate(m_array, m_array + Size, int(0)); } + +private: + int m_array[Size]; +}; + +using IntArray2 = IntArray<2>; +using IntArray3 = IntArray<3>; + +#endif // NONTYPETEMPLATE_H diff --git a/sources/shiboken6/tests/libsample/null.h b/sources/shiboken6/tests/libsample/null.h new file mode 100644 index 000000000..945a89fa2 --- /dev/null +++ b/sources/shiboken6/tests/libsample/null.h @@ -0,0 +1,19 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef NULL_H +#define NULL_H + +class Null +{ +public: + Null(bool value) : m_isNull(value) {} + Null() = default; + + void setIsNull(bool flag) { m_isNull = flag; } + +private: + bool m_isNull = false; +}; + +#endif // NULL_H diff --git a/sources/shiboken6/tests/libsample/objectmodel.cpp b/sources/shiboken6/tests/libsample/objectmodel.cpp new file mode 100644 index 000000000..56ed86577 --- /dev/null +++ b/sources/shiboken6/tests/libsample/objectmodel.cpp @@ -0,0 +1,24 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "objectmodel.h" + +void ObjectModel::setData(ObjectType *data) +{ + m_data = data; +} + +ObjectType *ObjectModel::data() const +{ + return m_data; +} + +ObjectModel::MethodCalled ObjectModel::receivesObjectTypeFamily(const ObjectModel &) +{ + return ObjectModel::ObjectModelCalled; +} + +ObjectModel::MethodCalled ObjectModel::receivesObjectTypeFamily(const ObjectType &) +{ + return ObjectModel::ObjectTypeCalled; +} diff --git a/sources/shiboken6/tests/libsample/objectmodel.h b/sources/shiboken6/tests/libsample/objectmodel.h new file mode 100644 index 000000000..6d2f97aee --- /dev/null +++ b/sources/shiboken6/tests/libsample/objectmodel.h @@ -0,0 +1,31 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OBJECTMODEL_H +#define OBJECTMODEL_H + +#include "objecttype.h" +#include "libsamplemacros.h" + +class LIBSAMPLE_API ObjectModel : public ObjectType +{ +public: + explicit ObjectModel(ObjectType *parent = nullptr) + : ObjectType(parent) {} + + void setData(ObjectType *data); + virtual ObjectType *data() const; + + // The MethodCalled enum and related static methods were created to + // test bug #630 [http://bugs.openbossa.org/show_bug.cgi?id=630] + enum MethodCalled { ObjectTypeCalled, ObjectModelCalled }; + static MethodCalled receivesObjectTypeFamily(const ObjectType &object); + static MethodCalled receivesObjectTypeFamily(const ObjectModel &object); + +private: + // The model holds only one piece of data. + // (This is just a test after all.) + ObjectType *m_data = nullptr; +}; + +#endif // OBJECTMODEL_H diff --git a/sources/shiboken6/tests/libsample/objecttype.cpp b/sources/shiboken6/tests/libsample/objecttype.cpp new file mode 100644 index 000000000..fa3e7357c --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttype.cpp @@ -0,0 +1,264 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "objecttype.h" +#include "objecttypelayout.h" + +#include <algorithm> +#include <iostream> +#include <string> +#include <assert.h> + +ObjectType::ObjectType(ObjectType *parent) +{ + setParent(parent); +} + +ObjectType::ObjectType(ObjectType &&) noexcept = default; +ObjectType &ObjectType::operator=(ObjectType &&) noexcept = default; + +ObjectType::~ObjectType() +{ + for (auto *o : m_children) + delete o; +} + +ObjectType *ObjectType::createWithChild() +{ + ObjectType *parent = create(); + ObjectType *child = create(); + child->setObjectName("child"); + child->setParent(parent); + return parent; +} + +void ObjectType::removeChild(ObjectType *child) +{ + if (!child) + return; + + auto child_iter = std::find(m_children.begin(), m_children.end(), child); + if (child_iter != m_children.end()) { + m_children.erase(child_iter); + child->m_parent = nullptr; + } +} + +ObjectType *ObjectType::takeChild(ObjectType *child) +{ + if (!child) + return nullptr; + + auto child_iter = std::find(m_children.begin(), m_children.end(), child); + if (child_iter != m_children.end()) { + m_children.erase(child_iter); + child->m_parent = nullptr; + return child; + } + return nullptr; +} + +ObjectType *ObjectType::takeChild(const Str &name) +{ + return takeChild(findChild(name)); + +} + +ObjectTypeList::iterator ObjectType::findChildByName(const Str &name) +{ + return std::find_if(m_children.begin(), m_children.end(), + [&name](const ObjectType *o) { + return o->objectName() == name; + }); +} + +ObjectType *ObjectType::findChild(const Str &name) +{ + auto it = findChildByName(name); + return it != m_children.end() ? *it : nullptr; +} + +void ObjectType::killChild(const Str &name) +{ + auto it = findChildByName(name); + if (it != m_children.end()) { + ObjectType *child = *it; + removeChild(child); + delete child; + } +} + +void ObjectType::setParent(ObjectType *parent) +{ + if (m_parent == parent) + return; + + if (m_parent) + m_parent->removeChild(this); + + m_parent = parent; + if (m_parent) + m_parent->m_children.push_back(this); +} + +void ObjectType::setObjectName(const Str &name) +{ + m_objectName = name; +} + +Str ObjectType::objectName() const +{ + return m_objectName; +} + +bool ObjectType::causeEvent(Event::EventType eventType) +{ + Event e(eventType); + return event(&e); +} + +bool ObjectType::event(Event *) +{ + return true; +} + +int ObjectType::processEvent(ObjectTypeList objects, Event *event) +{ + return std::count_if(objects.begin(), objects.end(), + [event] (ObjectType *o) { + return o->event(event); + }); +} + +void ObjectType::callInvalidateEvent(Event *event) +{ + invalidateEvent(event); +} + +void ObjectType::invalidateEvent(Event *) +{ +} + +void ObjectType::setLayout(ObjectTypeLayout *l) +{ + if (!l) { + std::cerr << "[WARNING] ObjectType::setLayout: Cannot set layout to 0.\n"; + return; + } + + if (layout()) { + if (layout() != l) { + std::cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" + << l->objectName().cstring() + << "' on ObjectType '" << objectName().cstring() + << "', which already has a layout.\n"; + } + return; + } + + ObjectType *oldParent = l->parent(); + if (oldParent && oldParent != this) { + if (oldParent->isLayoutType()) { + std::cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" + << l->objectName().cstring() + << "' on ObjectType '" << objectName().cstring() + << "', when the ObjectTypeLayout already has a parent layout.\n"; + return; + } + // Steal the layout from an ObjectType parent. + oldParent->takeLayout(); + } + + m_layout = l; + if (oldParent != this) { + l->setParent(this); + l->reparentChildren(this); + } +} + +ObjectTypeLayout *ObjectType::takeLayout() +{ + ObjectTypeLayout *l = layout(); + if (!l) + return nullptr; + m_layout = nullptr; + l->setParent(nullptr); + return l; +} + +unsigned int objectTypeHash(const ObjectType *objectType) +{ + return reinterpret_cast<std::size_t>(objectType); +} + +unsigned char ObjectType::callWithEnum(const Str &, Event::EventType, unsigned char value) +{ + return value * value; +} + +unsigned char ObjectType::callWithEnum(const Str &, unsigned char value) +{ + return value; +} + +void ObjectType::setObjectSplittedName(const char *, const Str &prefix, const Str &suffix) +{ + std::string result(prefix.cstring()); + result += suffix.cstring(); + m_objectName = result.c_str(); +} + +void ObjectType::setObjectNameWithSize(const char *, int size, const Str &name) +{ + std::string result(name.cstring(), size); + m_objectName = result.c_str(); +} + +void ObjectType::setObjectNameWithSize(const Str &name, int size) +{ + setObjectNameWithSize("", size, name); +} + +void ObjectType::setObject(ObjectType *) +{ + m_call_id = 0; +} + +void ObjectType::setObject(const Null&) +{ + m_call_id = 1; +} + +int ObjectType::callId() const +{ + return m_call_id; +} + +void ObjectType::callVirtualCreateChild() +{ + auto *fake_parent = new ObjectType(); + ObjectType *fake_child = createChild(fake_parent); + assert(fake_child->isPython()); + (void)fake_child; + delete fake_parent; +} + +ObjectType *ObjectType::createChild(ObjectType *parent) +{ + return new ObjectType(parent); +} + +std::size_t ObjectType::createObjectType() +{ + void *addr = new ObjectType(); + return (std::size_t) addr; +} + +OtherBase::~OtherBase() = default; + +ObjectTypeDerived::~ObjectTypeDerived() = default; + +bool ObjectTypeDerived::event(Event *) +{ + return true; +} diff --git a/sources/shiboken6/tests/libsample/objecttype.h b/sources/shiboken6/tests/libsample/objecttype.h new file mode 100644 index 000000000..498556459 --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttype.h @@ -0,0 +1,166 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OBJECTTYPE_H +#define OBJECTTYPE_H + +#include "str.h" +#include "null.h" + +#include "libsamplemacros.h" + +#include <list> + +struct Event +{ + enum EventType { + NO_EVENT, + BASIC_EVENT, + SOME_EVENT, + ANY_EVENT + }; + + enum class EventTypeClass { + Value1, + Value2 + }; + + explicit Event(EventType eventType) : m_eventType(eventType) {} + EventType eventType() const { return m_eventType; } + + void setEventType(EventType et) { m_eventType = et; } + void setEventTypeByConstRef(const EventType &et) { m_eventType = et; } + void setEventTypeByConstPtr(const EventType *etPtr) { m_eventType = *etPtr; } + +private: + EventType m_eventType; +}; + +class ObjectTypeLayout; +class ObjectType; +using ObjectTypeList = std::list<ObjectType*>; + +class LIBSAMPLE_API ObjectType +{ +public: + // ### Fixme: Use uintptr_t in C++ 11 + using Identifier = size_t; + + explicit ObjectType(ObjectType *parent = nullptr); + virtual ~ObjectType(); + ObjectType(const ObjectType &) = delete; + ObjectType &operator=(const ObjectType &) = delete; + ObjectType(ObjectType &&) noexcept; + ObjectType &operator=(ObjectType &&) noexcept; + + // factory method + inline static ObjectType *create() { return new ObjectType(); } + static ObjectType *createWithChild(); + + void setParent(ObjectType *parent); + inline ObjectType *parent() const { return m_parent; } + inline const ObjectTypeList &children() const { return m_children; } + void killChild(const Str &name); + void removeChild(ObjectType *child); + ObjectType *takeChild(ObjectType *child); + virtual ObjectType *takeChild(const Str &name); + ObjectType *findChild(const Str &name); + + Str objectName() const; + void setObjectName(const Str &name); + + inline Identifier identifier() const { return reinterpret_cast<Identifier>(this); } + + bool causeEvent(Event::EventType eventType); + + // Returns true if the event is processed. + virtual bool event(Event *event); + static int processEvent(ObjectTypeList objects, Event *event); + + void callInvalidateEvent(Event *event); + virtual void invalidateEvent(Event *event); + + // This nonsense method emulate QWidget.setLayout method + // All layout objects will became children of this object. + void setLayout(ObjectTypeLayout *layout); + inline ObjectTypeLayout *layout() const { return m_layout; } + + // This method should be reimplemented by ObjectTypeLayout. + virtual bool isLayoutType() { return false; } + + unsigned char callWithEnum(const Str &prefix, Event::EventType type, + unsigned char value=80); + unsigned char callWithEnum(const Str &prefix, unsigned char value=0); + + //Functions used in test with named arguments + void setObjectSplittedName(const char *, const Str &prefix = Str("<unk"), + const Str &suffix = Str("nown>")); + void setObjectNameWithSize(const char *, int size=9, + const Str &name = Str("<unknown>")); + void setObjectNameWithSize(const Str &name = Str("<unknown>"), int size = 9); + + //Function used to confuse the generator when two values accept Null as arg + void setObject(ObjectType *); + void setObject(const Null &); + int callId() const; + + //Function used to create a parent from C++ + virtual bool isPython() { return false; } + void callVirtualCreateChild(); + virtual ObjectType *createChild(ObjectType *parent); + static std::size_t createObjectType(); + + //return a parent from C++ + ObjectType *getCppParent() { + if (!m_parent) { + ObjectType *parent = new ObjectType(); + setParent(parent); + } + return m_parent; + } + + void destroyCppParent() { + delete m_parent; + } + + //Deprecated test + bool deprecatedFunction() { return true; } + + // nextInFocusChain simply returns the parent to test object cycles; the parent + // may be returned by the QWidget's implementation but isn't always returned + ObjectType *nextInFocusChain() { return m_parent; } + +private: + ObjectTypeLayout *takeLayout(); + ObjectTypeList::iterator findChildByName(const Str &name); + + Str m_objectName; + ObjectType *m_parent = nullptr; + ObjectTypeList m_children; + + ObjectTypeLayout *m_layout = nullptr; + //used on overload null test + int m_call_id = -1; +}; + +LIBSAMPLE_API unsigned int objectTypeHash(const ObjectType *objectType); + +class LIBSAMPLE_API OtherBase { +public: + LIBMINIMAL_DISABLE_COPY_MOVE(OtherBase) + + OtherBase() noexcept = default; + virtual ~OtherBase(); +}; + +class LIBSAMPLE_API ObjectTypeDerived: public ObjectType, public OtherBase { +public: + LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeDerived) + + ObjectTypeDerived() noexcept = default; + + bool event(Event *event) override; + ~ObjectTypeDerived() override; +}; + +#endif // OBJECTTYPE_H diff --git a/sources/shiboken6/tests/libsample/objecttypebyvalue.h b/sources/shiboken6/tests/libsample/objecttypebyvalue.h new file mode 100644 index 000000000..7b12ff945 --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttypebyvalue.h @@ -0,0 +1,31 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OBJECTTYPEBYVALUE_H +#define OBJECTTYPEBYVALUE_H + +#include "protected.h" + +#include <list> + +class ObjectTypeByValue +{ +public: + ObjectTypeByValue returnSomeKindOfMe() { return {}; } + void acceptKindOfMeAsValue(ObjectTypeByValue kindOfMe); + + void acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue> listOfMe); + + // prop used to check for segfaults + ProtectedProperty prop; +}; + +inline void ObjectTypeByValue::acceptKindOfMeAsValue(ObjectTypeByValue) +{ +} + +inline void ObjectTypeByValue::acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue>) +{ +} + +#endif // OBJECTTYPEBYVALUE_H diff --git a/sources/shiboken6/tests/libsample/objecttypeholder.cpp b/sources/shiboken6/tests/libsample/objecttypeholder.cpp new file mode 100644 index 000000000..c0950d09c --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttypeholder.cpp @@ -0,0 +1,31 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "objecttypeholder.h" + +ObjectTypeHolder::ObjectTypeHolder(const char *objectName) +{ + auto *object = new ObjectType(); + object->setObjectName(objectName); + m_objectType = object; +} + +ObjectTypeHolder::ObjectTypeHolder(const ObjectType *object) noexcept : + m_objectType(object) +{ +} + +ObjectTypeHolder::~ObjectTypeHolder() +{ + delete m_objectType; +} + +Str ObjectTypeHolder::passObjectTypeAsReference(const ObjectType &objectType) +{ + return objectType.objectName(); +} + +Str ObjectTypeHolder::callPassObjectTypeAsReference() +{ + return passObjectTypeAsReference(*m_objectType); +} diff --git a/sources/shiboken6/tests/libsample/objecttypeholder.h b/sources/shiboken6/tests/libsample/objecttypeholder.h new file mode 100644 index 000000000..190664608 --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttypeholder.h @@ -0,0 +1,29 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OBJECTTYPEHOLDER_H +#define OBJECTTYPEHOLDER_H + +#include "libsamplemacros.h" +#include "objecttype.h" +#include "str.h" + +class LIBSAMPLE_API ObjectTypeHolder +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeHolder) + + explicit ObjectTypeHolder(const char *objectName); + explicit ObjectTypeHolder(const ObjectType *object) noexcept; + virtual ~ObjectTypeHolder(); + + const ObjectType *getObjectType() const { return m_objectType; } + + virtual Str passObjectTypeAsReference(const ObjectType &objectType); + Str callPassObjectTypeAsReference(); + +private: + const ObjectType *m_objectType; +}; + +#endif // OBJECTTYPEHOLDER_H diff --git a/sources/shiboken6/tests/libsample/objecttypelayout.cpp b/sources/shiboken6/tests/libsample/objecttypelayout.cpp new file mode 100644 index 000000000..3fa02917c --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttypelayout.cpp @@ -0,0 +1,40 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "objecttypelayout.h" + +#include <iostream> + +void ObjectTypeLayout::addObject(ObjectType *obj) +{ + if (obj->isLayoutType()) { + auto *l = reinterpret_cast<ObjectTypeLayout*>(obj); + if (l->parent()) { + std::cerr << "[WARNING] ObjectTypeLayout::addObject: layout '" + << l->objectName().cstring() << "' already has a parent.\n"; + return; + } + + l->setParent(this); + + if (parent() && !parent()->isLayoutType()) + l->reparentChildren(parent()); + } + + m_objects.push_back(obj); +} + +std::list<ObjectType*> ObjectTypeLayout::objects() const +{ + return m_objects; +} + +void ObjectTypeLayout::reparentChildren(ObjectType *parent) +{ + for (auto *o : m_objects) { + if (o->isLayoutType()) + reinterpret_cast<ObjectTypeLayout *>(o)->reparentChildren(parent); + else + o->setParent(parent); + } +} diff --git a/sources/shiboken6/tests/libsample/objecttypelayout.h b/sources/shiboken6/tests/libsample/objecttypelayout.h new file mode 100644 index 000000000..0aa9fad6e --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttypelayout.h @@ -0,0 +1,32 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OBJECTTYPELAYOUT_H +#define OBJECTTYPELAYOUT_H + +#include "libsamplemacros.h" +#include "objecttype.h" + +#include <list> + +class ObjectType; + +class LIBSAMPLE_API ObjectTypeLayout : public ObjectType +{ +public: + void addObject(ObjectType *obj); + std::list<ObjectType*> objects() const; + + bool isLayoutType() override { return true; } + inline static ObjectTypeLayout *create() { return new ObjectTypeLayout(); } + + ObjectType *takeChild(const Str &name) override { return ObjectType::takeChild(name); } + +private: + std::list<ObjectType*> m_objects; + + void reparentChildren(ObjectType *parent); + friend LIBSAMPLE_API void ObjectType::setLayout(ObjectTypeLayout *l); +}; + +#endif // OBJECTTYPELAYOUT_H diff --git a/sources/shiboken6/tests/libsample/objecttypeoperators.cpp b/sources/shiboken6/tests/libsample/objecttypeoperators.cpp new file mode 100644 index 000000000..c78387a3e --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttypeoperators.cpp @@ -0,0 +1,38 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "objecttypeoperators.h" + +ObjectTypeOperators::ObjectTypeOperators(const std::string key) : m_key(key) +{ +} + +bool ObjectTypeOperators::operator==(const ObjectTypeOperators &other) const +{ + return m_key == other.m_key; +} + +const ObjectTypeOperators &ObjectTypeOperators::operator<(const ObjectTypeOperators &other) const +{ + return m_key < other.m_key ? *this : other; +} + +bool operator==(const ObjectTypeOperators *obj, const std::string &str) +{ + return obj->key() == str; +} + +bool operator==(const std::string &str, const ObjectTypeOperators *obj) +{ + return str == obj->key(); +} + +std::string operator+(const ObjectTypeOperators *obj, const std::string &str) +{ + return obj->key() + str; +} + +std::string operator+(const std::string &str, const ObjectTypeOperators *obj) +{ + return str + obj->key(); +} diff --git a/sources/shiboken6/tests/libsample/objecttypeoperators.h b/sources/shiboken6/tests/libsample/objecttypeoperators.h new file mode 100644 index 000000000..6144952ca --- /dev/null +++ b/sources/shiboken6/tests/libsample/objecttypeoperators.h @@ -0,0 +1,36 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OBJECTTYPEOPERATORS_H +#define OBJECTTYPEOPERATORS_H + +#include "libsamplemacros.h" + +#include <string> + +class LIBSAMPLE_API ObjectTypeOperators +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeOperators) + + explicit ObjectTypeOperators(const std::string key); + virtual ~ObjectTypeOperators() = default; + + bool operator==(const ObjectTypeOperators &other) const; + const ObjectTypeOperators &operator<(const ObjectTypeOperators &other) const; + + // chaos! + virtual void operator>(const ObjectTypeOperators &) { m_key.append("operator>"); } + + std::string key() const { return m_key; } + +private: + std::string m_key; +}; + +LIBSAMPLE_API bool operator==(const ObjectTypeOperators *obj, const std::string &str); +LIBSAMPLE_API bool operator==(const std::string &str, const ObjectTypeOperators *obj); +LIBSAMPLE_API std::string operator+(const ObjectTypeOperators *obj, const std::string &str); +LIBSAMPLE_API std::string operator+(const std::string &str, const ObjectTypeOperators *obj); + +#endif // OBJECTTYPEOPERATORS_H diff --git a/sources/shiboken6/tests/libsample/objectview.cpp b/sources/shiboken6/tests/libsample/objectview.cpp new file mode 100644 index 000000000..1b727f88c --- /dev/null +++ b/sources/shiboken6/tests/libsample/objectview.cpp @@ -0,0 +1,24 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "objectview.h" +#include "objectmodel.h" +#include "str.h" + +Str ObjectView::displayModelData() +{ + if (!m_model) + return {"(NULL)"}; + return Str("Name: %VAR").arg(m_model->objectName()); +} + +void ObjectView::modifyModelData(Str &data) +{ + if (m_model) + m_model->setObjectName(data); +} + +ObjectType *ObjectView::getRawModelData() +{ + return m_model->data(); +} diff --git a/sources/shiboken6/tests/libsample/objectview.h b/sources/shiboken6/tests/libsample/objectview.h new file mode 100644 index 000000000..2567deee5 --- /dev/null +++ b/sources/shiboken6/tests/libsample/objectview.h @@ -0,0 +1,31 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OBJECTVIEW_H +#define OBJECTVIEW_H + +#include "objecttype.h" +#include "libsamplemacros.h" + +class Str; +class ObjectModel; + +class LIBSAMPLE_API ObjectView : public ObjectType +{ +public: + explicit ObjectView(ObjectModel *model = nullptr, ObjectType *parent = nullptr) + : ObjectType(parent), m_model(model) {} + + inline void setModel(ObjectModel *model) { m_model = model; } + inline ObjectModel *model() const { return m_model; } + + Str displayModelData(); + void modifyModelData(Str &data); + + ObjectType *getRawModelData(); + +private: + ObjectModel *m_model; +}; + +#endif // OBJECTVIEW_H diff --git a/sources/shiboken6/tests/libsample/oddbool.cpp b/sources/shiboken6/tests/libsample/oddbool.cpp new file mode 100644 index 000000000..bc1ee833f --- /dev/null +++ b/sources/shiboken6/tests/libsample/oddbool.cpp @@ -0,0 +1,27 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "oddbool.h" + +ComparisonTester::ComparisonTester(int v) : m_value(v) +{ +} + +ComparisonTester &ComparisonTester::operator=(int v) +{ + m_value = v; + return *this; +} + +int ComparisonTester::compare(const ComparisonTester &rhs) const +{ + if (m_value < rhs.m_value) + return -1; + if (m_value > rhs.m_value) + return 1; + return 0; +} + +SpaceshipComparisonTester::SpaceshipComparisonTester(int v) : m_value(v) +{ +} diff --git a/sources/shiboken6/tests/libsample/oddbool.h b/sources/shiboken6/tests/libsample/oddbool.h new file mode 100644 index 000000000..dd2d32604 --- /dev/null +++ b/sources/shiboken6/tests/libsample/oddbool.h @@ -0,0 +1,106 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef ODDBOOL_H +#define ODDBOOL_H + +#include "libsamplemacros.h" + +#include <type_traits> + +#if __cplusplus >= 202002 || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002) +# include <compare> +#endif + +class OddBool +{ + +public: + inline explicit OddBool(bool b) noexcept : m_value(b) {} + bool value() const { return m_value; } + + inline OddBool operator!() const { return OddBool(!m_value); } + +private: + bool m_value; +}; + +inline bool operator==(OddBool b1, bool b2) { return (!b1).value() == !b2; } +inline bool operator==(bool b1, OddBool b2) { return (!b1) == (!b2).value(); } +inline bool operator==(OddBool b1, OddBool b2) { return (!b1).value() == (!b2).value(); } +inline bool operator!=(OddBool b1, bool b2) { return (!b1).value() != !b2; } +inline bool operator!=(bool b1, OddBool b2) { return (!b1) != (!b2).value(); } +inline bool operator!=(OddBool b1, OddBool b2) { return (!b1).value() != (!b2).value(); } + +class OddBoolUser +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(OddBoolUser) + + OddBoolUser() noexcept : m_oddbool(OddBool(false)) {} + OddBoolUser(const OddBool &oddBool) : m_oddbool(oddBool) {} + virtual ~OddBoolUser() = default; + + inline OddBool oddBool() { return m_oddbool; } + inline void setOddBool(OddBool oddBool) { m_oddbool = oddBool; } + + virtual OddBool invertedOddBool() + { + return !m_oddbool; + } + + inline OddBool callInvertedOddBool() + { + return invertedOddBool(); + } + + static inline OddBool getOddBool(const OddBoolUser &oddBoolUser) + { + return oddBoolUser.m_oddbool; + } + +private: + OddBool m_oddbool; +}; + +class LIBSAMPLE_API ComparisonTester +{ +public: + explicit ComparisonTester(int v); + ComparisonTester &operator=(int v); + + int compare(const ComparisonTester &rhs) const; + +private: + int m_value; +}; + +// Hide the comparison operators from the clang parser (see typesystem_sample.xml:184, +// oddbool_test.py) + +inline std::enable_if<std::is_assignable<ComparisonTester, int>::value, bool>::type + operator==(const ComparisonTester &c1, const ComparisonTester &c2) +{ return c1.compare(c2) == 0; } + +inline std::enable_if<std::is_assignable<ComparisonTester, int>::value, bool>::type + operator!=(const ComparisonTester &c1, const ComparisonTester &c2) +{ return c1.compare(c2) != 0; } + +class LIBSAMPLE_API SpaceshipComparisonTester +{ +public: + explicit SpaceshipComparisonTester(int v); + +#if __cplusplus >= 202002 || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002) + auto operator<=>(const SpaceshipComparisonTester &rhs) const = default; + + enum Enabled { HasSpaceshipOperator = 1 }; +#else + enum Enabled { HasSpaceshipOperator = 0 }; +#endif // C++ 20 + +private: + int m_value; +}; + +#endif // ODDBOOL_H diff --git a/sources/shiboken6/tests/libsample/onlycopy.cpp b/sources/shiboken6/tests/libsample/onlycopy.cpp new file mode 100644 index 000000000..981ea88a4 --- /dev/null +++ b/sources/shiboken6/tests/libsample/onlycopy.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "onlycopy.h" + +class OnlyCopyPrivate +{ +public: + explicit OnlyCopyPrivate(int v = 0) : value(v) {} + + int value; +}; + +OnlyCopy::OnlyCopy(int value) : d(std::make_shared<OnlyCopyPrivate>(value)) +{ +} + +OnlyCopy::~OnlyCopy() = default; + +int OnlyCopy::value() const +{ + return d->value; +} + +OnlyCopy FriendOfOnlyCopy::createOnlyCopy(int value) +{ + return OnlyCopy(value); +} + +std::list<OnlyCopy> FriendOfOnlyCopy::createListOfOnlyCopy(int quantity) +{ + std::list<OnlyCopy> list; + for (int i = 0; i < quantity; ++i) + list.push_back(createOnlyCopy(i)); + return list; +} diff --git a/sources/shiboken6/tests/libsample/onlycopy.h b/sources/shiboken6/tests/libsample/onlycopy.h new file mode 100644 index 000000000..7dc3e0069 --- /dev/null +++ b/sources/shiboken6/tests/libsample/onlycopy.h @@ -0,0 +1,42 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef ONLYCOPYCLASS_H +#define ONLYCOPYCLASS_H + +#include "libsamplemacros.h" + +#include <list> +#include <memory> + +// These classes simulate a situation found in QWebEngineHistoryItem. + +class OnlyCopyPrivate; + +class LIBSAMPLE_API OnlyCopy +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(OnlyCopy) + + ~OnlyCopy(); + + int value() const; + static int getValue(OnlyCopy onlyCopy) { return onlyCopy.value(); } + static int getValueFromReference(const OnlyCopy &onlyCopy) { return onlyCopy.value(); } + +private: + friend class FriendOfOnlyCopy; + + explicit OnlyCopy(int value); + + std::shared_ptr<OnlyCopyPrivate> d; +}; + +class LIBSAMPLE_API FriendOfOnlyCopy +{ +public: + static OnlyCopy createOnlyCopy(int value); + static std::list<OnlyCopy> createListOfOnlyCopy(int quantity); +}; + +#endif // ONLYCOPYCLASS_H diff --git a/sources/shiboken6/tests/libsample/overload.cpp b/sources/shiboken6/tests/libsample/overload.cpp new file mode 100644 index 000000000..34da28e03 --- /dev/null +++ b/sources/shiboken6/tests/libsample/overload.cpp @@ -0,0 +1,203 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "overload.h" + +Overload::FunctionEnum Overload::overloaded() +{ + return Function0; +} + +Overload::FunctionEnum Overload::overloaded(Size *) +{ + return Function1; +} + +Overload::FunctionEnum Overload::overloaded(Point *, ParamEnum) +{ + return Function2; +} + +Overload::FunctionEnum Overload::overloaded(const Point &) +{ + return Function3; +} + +void Overload::differentReturnTypes(ParamEnum) +{ + +} + +int Overload::differentReturnTypes(ParamEnum, int val) +{ + return val; +} + +int Overload::intOverloads(const Point &, double) +{ + return 1; +} + +int Overload::intOverloads(int, int) +{ + return 2; +} + +int Overload::intOverloads(int, int, double) +{ + return 3; +} + +Overload::FunctionEnum Overload::intDoubleOverloads(double, double) const +{ + return Function1; +} + +Overload::FunctionEnum Overload::intDoubleOverloads(int, int) const +{ + return Function0; +} + +void Overload::singleOverload(Point *) +{ +} + +Overload::FunctionEnum Overload::wrapperIntIntOverloads(const Polygon &, int, int) +{ + return Function1; +} + +Overload::FunctionEnum Overload::wrapperIntIntOverloads(const Point &, int, int) +{ + return Function0; +} + +Overload::FunctionEnum Overload::strBufferOverloads(const Str &, const char *, bool) +{ + return Function0; +} + +Overload::FunctionEnum Overload::strBufferOverloads(unsigned char *, int) +{ + return Function1; +} + +Overload::FunctionEnum Overload::drawText(const PointF &, const Str &) +{ + return Function1; +} + +Overload::FunctionEnum Overload::drawText(const Point &, const Str &) +{ + return Function0; +} + +Overload::FunctionEnum Overload::drawText(const RectF &, const Str &, const Echo &) +{ + return Function4; +} + +Overload::FunctionEnum Overload::drawText(const RectF &, int, const Str &) +{ + return Function3; +} + +Overload::FunctionEnum Overload::drawText(const Rect &, int, const Str &) +{ + return Function2; +} + +Overload::FunctionEnum Overload::drawText(int, int, const Str &) +{ + return Function5; +} + +Overload::FunctionEnum Overload::drawText(int, int, int, int, int, const Str &) +{ + return Function6; +} + +Overload::FunctionEnum Overload::drawText2(const PointF &, const Str &) +{ + return Function1; +} + +Overload::FunctionEnum Overload::drawText2(const Point &, const Str &) +{ + return Function0; +} + +Overload::FunctionEnum Overload::drawText2(int, int, const Str &) +{ + return Function5; +} + +Overload::FunctionEnum Overload::drawText2(const RectF &, const Str &, const Echo &) +{ + return Function4; +} + +Overload::FunctionEnum Overload::drawText2(const RectF &, int, const Str &) +{ + return Function3; +} + +Overload::FunctionEnum Overload::drawText2(const Rect &, int, const Str &) +{ + return Function2; +} + +Overload::FunctionEnum Overload::drawText2(int, int, int, int, int, const Str &) +{ + return Function6; +} + +Overload::FunctionEnum Overload::drawText3(const Str &, const Str &, const Str &) +{ + return Function0; +} + +Overload::FunctionEnum Overload::drawText3(int, int, int, int, int) +{ + return Function1; +} + +Overload::FunctionEnum Overload::drawText4(int, int, int) +{ + return Function0; +} + +Overload::FunctionEnum Overload::drawText4(int, int, int, int, int) +{ + return Function1; +} + +Overload::FunctionEnum Overload::acceptSequence() +{ + return Function0; +} + +Overload::FunctionEnum Overload::acceptSequence(const Str &, ParamEnum) +{ + return Function2; +} + +Overload::FunctionEnum Overload::acceptSequence(int, int) +{ + return Function1; +} + +Overload::FunctionEnum Overload::acceptSequence(void *) +{ + return Function5; +} + +Overload::FunctionEnum Overload::acceptSequence(const char *const[]) +{ + return Function4; +} + +Overload::FunctionEnum Overload::acceptSequence(const Size &) +{ + return Function3; +} diff --git a/sources/shiboken6/tests/libsample/overload.h b/sources/shiboken6/tests/libsample/overload.h new file mode 100644 index 000000000..b640bf7c7 --- /dev/null +++ b/sources/shiboken6/tests/libsample/overload.h @@ -0,0 +1,121 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OVERLOAD_H +#define OVERLOAD_H + +#include "echo.h" +#include "str.h" +#include "size.h" +#include "point.h" +#include "pointf.h" +#include "polygon.h" +#include "rect.h" + +#include "libsamplemacros.h" + +class LIBSAMPLE_API Overload +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(Overload) + + enum FunctionEnum { + Function0, + Function1, + Function2, + Function3, + Function4, + Function5, + Function6 + }; + + enum ParamEnum { + Param0, + Param1 + }; + + Overload() noexcept = default; + virtual ~Overload() = default; + + FunctionEnum overloaded(); + FunctionEnum overloaded(Size *size); + FunctionEnum overloaded(Point *point, ParamEnum param); + FunctionEnum overloaded(const Point &point); + + void differentReturnTypes(ParamEnum param = Param0); + int differentReturnTypes(ParamEnum param, int val); + + int intOverloads(const Point &p, double d); + int intOverloads(int i, int i2); + int intOverloads(int i, int removedArg, double d); + + FunctionEnum intDoubleOverloads(int a0, int a1) const; + FunctionEnum intDoubleOverloads(double a0, double a1) const; + + void singleOverload(Point *x); + Point *singleOverload() { return new Point(); } + + // Similar to QImage::trueMatrix(QMatrix,int,int) and QImage::trueMatrix(QTransform,int,int) + FunctionEnum wrapperIntIntOverloads(const Point &arg0, int arg1, int arg2); + FunctionEnum wrapperIntIntOverloads(const Polygon &arg0, int arg1, int arg2); + + // Similar to QImage constructor + FunctionEnum strBufferOverloads(const Str &arg0, const char *arg1 = nullptr, + bool arg2 = true); + FunctionEnum strBufferOverloads(unsigned char *arg0, int arg1); + FunctionEnum strBufferOverloads() { return Function2; } + + // Similar to QPainter::drawText(...) + FunctionEnum drawText(const Point &a0, const Str &a1); + FunctionEnum drawText(const PointF &a0, const Str &a1); + FunctionEnum drawText(const Rect &a0, int a1, const Str &a2); + FunctionEnum drawText(const RectF &a0, int a1, const Str &a2); + FunctionEnum drawText(const RectF &a0, const Str &a1, const Echo &a2 = Echo()); + FunctionEnum drawText(int a0, int a1, const Str &a2); + FunctionEnum drawText(int a0, int a1, int a2, int a3, int a4, const Str &a5); + + // A variant of the one similar to QPainter::drawText(...) + FunctionEnum drawText2(const Point &a0, const Str &a1); + FunctionEnum drawText2(const PointF &a0, const Str &a1); + FunctionEnum drawText2(const Rect &a0, int a1, const Str &a2); + FunctionEnum drawText2(const RectF &a0, int a1, const Str &a2); + FunctionEnum drawText2(const RectF &a0, const Str &a1, const Echo &a2 = Echo()); + FunctionEnum drawText2(int a0, int a1, const Str &a2); + FunctionEnum drawText2(int a0, int a1, int a2, int a3 = 0, int a4 = 0, + const Str &a5 = Str()); + + // A simpler variant of the one similar to QPainter::drawText(...) + FunctionEnum drawText3(const Str &a0, const Str &a1, const Str &a2); + FunctionEnum drawText3(int a0, int a1, int a2, int a3, int a4); + + // Another simpler variant of the one similar to QPainter::drawText(...) + FunctionEnum drawText4(int a0, int a1, int a2); + FunctionEnum drawText4(int a0, int a1, int a2, int a3, int a4); + + FunctionEnum acceptSequence(); + FunctionEnum acceptSequence(int a0, int a1); + FunctionEnum acceptSequence(const Str &a0, ParamEnum a1 = Param0); + FunctionEnum acceptSequence(const Size &a0); + // The type must be changed to PySequence. + FunctionEnum acceptSequence(const char *const a0[]); + FunctionEnum acceptSequence(void *a0); +}; + +class LIBSAMPLE_API Overload2 : public Overload +{ +public: + // test bug#616, public and private method differ only by const + void doNothingInPublic() const {} + void doNothingInPublic(int) {} + virtual void doNothingInPublic3() const {} + void doNothingInPublic3(int) const {} +protected: + void doNothingInPublic2() const {} + void doNothingInPublic2(int) {} +private: + void doNothingInPublic() {} + void doNothingInPublic2() {} + void doNothingInPublic3() {} +}; + +#endif // OVERLOAD_H diff --git a/sources/shiboken6/tests/libsample/overloadsort.cpp b/sources/shiboken6/tests/libsample/overloadsort.cpp new file mode 100644 index 000000000..a9b4b0972 --- /dev/null +++ b/sources/shiboken6/tests/libsample/overloadsort.cpp @@ -0,0 +1,49 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "overloadsort.h" + +const char *SortedOverload::overload(int) +{ + return "int"; +} + +const char *SortedOverload::overload(double) +{ + return "double"; +} + +const char *SortedOverload::overload(ImplicitBase) +{ + return "ImplicitBase"; +} + +const char *SortedOverload::overload(ImplicitTarget) +{ + return "ImplicitTarget"; +} + +const char *SortedOverload::overload(const std::list<ImplicitBase> &) +{ + return "list(ImplicitBase)"; +} + +int SortedOverload::implicit_overload(const ImplicitBase &) +{ + return 1; +} + +const char *SortedOverload::overloadDeep(int, ImplicitBase &) +{ + return "ImplicitBase"; +} + +int CustomOverloadSequence::overload(short v) const +{ + return v + int(sizeof(v)); +} + +int CustomOverloadSequence::overload(int v) const +{ + return v + 4; +} diff --git a/sources/shiboken6/tests/libsample/overloadsort.h b/sources/shiboken6/tests/libsample/overloadsort.h new file mode 100644 index 000000000..ee269cc21 --- /dev/null +++ b/sources/shiboken6/tests/libsample/overloadsort.h @@ -0,0 +1,54 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef OVERLOADSORT_H +#define OVERLOADSORT_H + +#include "libsamplemacros.h" + +#include <list> + +class ImplicitTarget +{ +public: + ImplicitTarget() = default; +}; + +class ImplicitBase +{ +public: + ImplicitBase() = default; + ImplicitBase(const ImplicitTarget &b); +}; + +inline ImplicitBase::ImplicitBase(const ImplicitTarget &) +{ +} + +class LIBSAMPLE_API SortedOverload +{ +public: + + const char *overload(int x); + const char *overload(double x); + const char *overload(ImplicitBase x); + const char *overload(ImplicitTarget x); + const char *overload(const std::list<ImplicitBase> &x); + + int implicit_overload(const ImplicitBase &x); + + const char *overloadDeep(int x, ImplicitBase &y); + + inline const char *pyObjOverload(int, int) { return "int,int"; } + inline const char *pyObjOverload(unsigned char *, int) + { return "PyObject,int"; } +}; + +class LIBSAMPLE_API CustomOverloadSequence +{ +public: + int overload(short v) const; + int overload(int v) const; +}; + +#endif // OVERLOADSORT_H diff --git a/sources/shiboken6/tests/libsample/pairuser.cpp b/sources/shiboken6/tests/libsample/pairuser.cpp new file mode 100644 index 000000000..5b7eb4d8c --- /dev/null +++ b/sources/shiboken6/tests/libsample/pairuser.cpp @@ -0,0 +1,24 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "pairuser.h" + +std::pair<int, int> PairUser::callCreatePair() +{ + return createPair(); +} + +std::pair<int, int> PairUser::createPair() +{ + return {10, 20}; +} + +std::pair<Complex, Complex> PairUser::createComplexPair(Complex cpx0, Complex cpx1) +{ + return {cpx0, cpx1}; +} + +double PairUser::sumPair(std::pair<int, double> pair) +{ + return ((double) pair.first) + pair.second; +} diff --git a/sources/shiboken6/tests/libsample/pairuser.h b/sources/shiboken6/tests/libsample/pairuser.h new file mode 100644 index 000000000..ee51d818e --- /dev/null +++ b/sources/shiboken6/tests/libsample/pairuser.h @@ -0,0 +1,32 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef PAIRUSER_H +#define PAIRUSER_H + +#include "libsamplemacros.h" +#include "complex.h" + +#include <utility> + +class LIBSAMPLE_API PairUser +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(PairUser) + + PairUser() noexcept = default; + virtual ~PairUser() = default; + + virtual std::pair<int, int> createPair(); + std::pair<int, int> callCreatePair(); + static std::pair<Complex, Complex> createComplexPair(Complex cpx0, Complex cpx1); + double sumPair(std::pair<int, double> pair); + + inline void setPair(std::pair<int, int> pair) { m_pair = pair; } + inline std::pair<int, int> getPair() { return m_pair; } + +private: + std::pair<int, int> m_pair; +}; + +#endif // PAIRUSER_H diff --git a/sources/shiboken6/tests/libsample/pen.cpp b/sources/shiboken6/tests/libsample/pen.cpp new file mode 100644 index 000000000..76473a264 --- /dev/null +++ b/sources/shiboken6/tests/libsample/pen.cpp @@ -0,0 +1,83 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "pen.h" + +Color::Color(SampleNamespace::InValue) : m_null(false) +{ +} + +Color::Color(unsigned int) : m_null(false) +{ +} + +bool Color::isNull() const +{ + return m_null; +} + +Brush::Brush(const Color &c) : m_color(c) +{ +} + +Brush::operator bool() const +{ + return !m_color.isNull(); +} + +Brush::Style Brush::style() const +{ + return m_style; +} + +void Brush::setStyle(Style newStyle) +{ + m_style = newStyle; +} + +const Color &Brush::color() const +{ + return m_color; +} + +void Brush::setColor(const Color &newColor) +{ + m_color = newColor; +} + +Pen::Pen() = default; + +Pen::Pen(SampleNamespace::Option) : m_ctor(EnumCtor) +{ +} + +Pen::Pen(const Color &) : m_ctor(ColorCtor) +{ +} + +Pen::Pen(const Pen &) : m_ctor(CopyCtor) +{ +} + +Pen::Pen(Pen &&) noexcept = default; +Pen &Pen::operator=(const Pen &pen) = default; +Pen &Pen::operator=(Pen &&) noexcept = default; + +int Pen::ctorType() +{ + return m_ctor; +} + +void Pen::drawLine(int, int, int, int, RenderHints) +{ +} + +Pen::RenderHints Pen::getRenderHints() const +{ + return m_renderHints; +} + +void Pen::setRenderHints(RenderHints h) +{ + m_renderHints = h; +} diff --git a/sources/shiboken6/tests/libsample/pen.h b/sources/shiboken6/tests/libsample/pen.h new file mode 100644 index 000000000..6f528f0f9 --- /dev/null +++ b/sources/shiboken6/tests/libsample/pen.h @@ -0,0 +1,72 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef PEN_H +#define PEN_H + +#include "libsamplemacros.h" +#include "samplenamespace.h" + +class LIBSAMPLE_API Color +{ +public: + Color() = default; + Color(SampleNamespace::InValue arg); + Color(unsigned int arg); + + bool isNull() const; + +private: + bool m_null = true; +}; + +class LIBSAMPLE_API Brush +{ +public: + enum Style { Solid, Cross }; + + explicit Brush(const Color &c = {}); + + operator bool() const; + + Style style() const; + void setStyle(Style newStyle); + + const Color &color() const; + void setColor(const Color &newColor); + +private: + Style m_style = Solid; + Color m_color; +}; + +class LIBSAMPLE_API Pen +{ +public: + enum { EmptyCtor, EnumCtor, ColorCtor, CopyCtor }; + + enum RenderHints { None = 0, Antialiasing = 0x1, TextAntialiasing = 0x2 }; + + Pen(); + Pen(SampleNamespace::Option option); + Pen(const Color &color); + Pen(const Pen &pen); + Pen(Pen &&) noexcept; + Pen &operator=(const Pen &pen); + Pen &operator=(Pen &&) noexcept; + ~Pen() = default; + + // PYSIDE-1325, default initializer + void drawLine(int x1, int y1, int x2, int y2, RenderHints renderHints = {}); + + int ctorType(); + + RenderHints getRenderHints() const; + void setRenderHints(RenderHints h); + +private: + int m_ctor = EmptyCtor; + RenderHints m_renderHints = None; +}; + +#endif diff --git a/sources/shiboken6/tests/libsample/photon.cpp b/sources/shiboken6/tests/libsample/photon.cpp new file mode 100644 index 000000000..2a7f20e33 --- /dev/null +++ b/sources/shiboken6/tests/libsample/photon.cpp @@ -0,0 +1,31 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "photon.h" + +namespace Photon +{ + +const ClassType Base::staticType; + +int callCalculateForValueDuplicatorPointer(ValueDuplicator *value) +{ + return value->calculate(); +} + +int callCalculateForValueDuplicatorReference(ValueDuplicator &value) +{ + return value.calculate(); +} + +int countValueIdentities(const std::list<ValueIdentity> &values) +{ + return values.size(); +} + +int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> > &values) +{ + return values.size(); +} + +} // namespace Photon diff --git a/sources/shiboken6/tests/libsample/photon.h b/sources/shiboken6/tests/libsample/photon.h new file mode 100644 index 000000000..2debe47d1 --- /dev/null +++ b/sources/shiboken6/tests/libsample/photon.h @@ -0,0 +1,110 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef PHOTON_H +#define PHOTON_H + +#include "libsamplemacros.h" + +#include <list> + +// This namespace and classes simulate +// situations found in Qt's phonon module. + +namespace Photon +{ + +enum ClassType { + BaseType = 0, + IdentityType = 1, + DuplicatorType = 2 +}; + +class LIBSAMPLE_API Base +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Base) + + explicit Base(int value) noexcept : m_value(value) {} + virtual ~Base() = default; + + inline void setValue(int value) { m_value = value; } + inline int value() const { return m_value; } + + template <class T> bool isType() { return type() == T::staticType; } + bool isType(ClassType t) { return type() == t; } + + virtual ClassType type() const { return BaseType; }; + static const ClassType staticType = BaseType; + +protected: + int m_value; +}; + +template<ClassType CLASS_TYPE> +class LIBSAMPLE_API TemplateBase : public Base +{ +public: + explicit TemplateBase(int value) : Base(value) {} + inline int multiplicator() const { return int(CLASS_TYPE); } + inline int calculate() const { return m_value * (int(CLASS_TYPE)); } + static inline ClassType classType() { return CLASS_TYPE; } + + inline int sumValueUsingPointer(TemplateBase<CLASS_TYPE> *other) const + { return m_value + other->m_value; } + inline int sumValueUsingReference(TemplateBase<CLASS_TYPE> &other) const + { return m_value + other.m_value; } + + inline std::list<TemplateBase<CLASS_TYPE> > getListOfThisTemplateBase() + { + std::list<TemplateBase<CLASS_TYPE> > objs; + objs.push_back(*this); + objs.push_back(*this); + return objs; + } + + static inline TemplateBase<CLASS_TYPE> *passPointerThrough(TemplateBase<CLASS_TYPE> *obj) + { return obj; } + + ClassType type() const override { return CLASS_TYPE; } + static const ClassType staticType = CLASS_TYPE; +}; + +#if defined _WIN32 || defined __CYGWIN__ +template class LIBSAMPLE_API TemplateBase<IdentityType>; +template class LIBSAMPLE_API TemplateBase<DuplicatorType>; +#endif + +using ValueIdentity = TemplateBase<IdentityType>; +using ValueDuplicator = TemplateBase<DuplicatorType>; + +LIBSAMPLE_API int callCalculateForValueDuplicatorPointer(ValueDuplicator *value); +LIBSAMPLE_API int callCalculateForValueDuplicatorReference(ValueDuplicator &value); +LIBSAMPLE_API int countValueIdentities(const std::list<ValueIdentity> &values); +LIBSAMPLE_API int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> > &values); + +class Pointer +{ +public: + Pointer() noexcept = default; + explicit Pointer(int *p) : px(p) {} + + void reset() noexcept { Pointer().swap(*this); } + + int *get() const noexcept { return px; } + int &operator*() const { return *px; } + + void swap(Pointer &rhs) noexcept + { + int *tmp = px; + px = rhs.px; + rhs.px = tmp; + } + +private: + int *px = nullptr; +}; + +} // namespace Photon + +#endif // PHOTON_H diff --git a/sources/shiboken6/tests/libsample/point.cpp b/sources/shiboken6/tests/libsample/point.cpp new file mode 100644 index 000000000..0a28e877f --- /dev/null +++ b/sources/shiboken6/tests/libsample/point.cpp @@ -0,0 +1,111 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "point.h" + +#include <iostream> + +Point::Point(int x, int y) noexcept : m_x(x), m_y(y) +{ +} + +Point::Point(double x, double y) noexcept : m_x(x), m_y(y) +{ +} + +void Point::midpoint(const Point &other, Point *midpoint) const +{ + if (!midpoint) + return; + midpoint->setX((m_x + other.m_x) / 2.0); + midpoint->setY((m_y + other.m_y) / 2.0); +} + +Point *Point::copy() const +{ + Point *pt = new Point(); + pt->m_x = m_x; + pt->m_y = m_y; + return pt; +} + +void Point::show() const +{ + std::cout << "(x: " << m_x << ", y: " << m_y << ")"; +} + +bool Point::operator==(const Point &other) const +{ + return m_x == other.m_x && m_y == other.m_y; +} + +Point Point::operator+(const Point &other) +{ + return {m_x + other.m_x, m_y + other.m_y}; +} + +Point Point::operator-(const Point &other) +{ + return {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*(const Point &pt, double mult) +{ + return Point(pt.m_x * mult, pt.m_y * mult); +} + +Point operator*(const Point &pt, int mult) +{ + return {int(pt.m_x) * mult, int(pt.m_y) * mult}; +} + +Point operator*(double mult, const Point &pt) +{ + return {pt.m_x * mult, pt.m_y * mult}; +} + +Point operator*(int mult, const Point &pt) +{ + return {int(pt.m_x) * mult, int(pt.m_y) * mult}; +} + +Point operator-(const Point &pt) +{ + return {-pt.m_x, -pt.m_y}; +} + +bool operator!(const Point &pt) +{ + return pt.m_x == 0.0 && pt.m_y == 0.0; +} + +Point Point::operator/(int operand) +{ + return {m_x/operand, m_y/operand}; +} + +Complex transmutePointIntoComplex(const Point &point) +{ + Complex cpx(point.x(), point.y()); + return cpx; +} + +Point transmuteComplexIntoPoint(const Complex &cpx) +{ + Point pt(cpx.real(), cpx.imag()); + return pt; +} diff --git a/sources/shiboken6/tests/libsample/point.h b/sources/shiboken6/tests/libsample/point.h new file mode 100644 index 000000000..7e5d128ab --- /dev/null +++ b/sources/shiboken6/tests/libsample/point.h @@ -0,0 +1,76 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef POINT_H +#define POINT_H + +#include "libsamplemacros.h" +#include "complex.h" + +#include <utility> + +class LIBSAMPLE_API Point +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Point) + + Point(int x = 0, int y = 0) noexcept; + Point(double x, double y) noexcept; + ~Point() = default; + + inline double x() const { return m_x; } + inline double y() const { return m_y; } + + inline void setX(double x) { m_x = x; } + inline void setY(double y) { m_y = y; } + inline void setXAsUint(unsigned int x) { m_x = x; } + inline void setYAsUint(unsigned int y) { m_y = y; } + + // This method could simply return the midpoint, + // but the interesting part of the test is to set the + // result in the pointer argument. + void midpoint(const Point &other, Point *midpoint) const; + + Point *copy() const; + + inline const Point &getConstReferenceToSelf() const { return *this; } + inline const Point *getSelf() const { return this; } + + // The != operator is not implemented for the purpose of testing + // for the absense of the __ne__ method in the Python binding. + bool operator==(const Point &other) const; + + Point operator+(const Point &other); + Point operator-(const Point &other); + Point operator/(int operand); + + friend LIBSAMPLE_API Point operator*(const Point &pt, double mult); + friend LIBSAMPLE_API Point operator*(const Point &pt, int mult); + friend LIBSAMPLE_API Point operator*(double mult, const Point &pt); + friend LIBSAMPLE_API Point operator*(int mult, const Point &pt); + friend LIBSAMPLE_API Point operator-(const Point &pt); + friend LIBSAMPLE_API bool operator!(const Point &pt); + + Point &operator+=(Point &other); + Point &operator-=(Point &other); + + void show() const; + +private: + double m_x; + double m_y; +}; + +LIBSAMPLE_API Point operator*(const Point &pt, double mult); +LIBSAMPLE_API Point operator*(const Point &pt, int mult); +LIBSAMPLE_API Point operator*(double mult, const Point &pt); +LIBSAMPLE_API Point operator*(int mult, const Point &pt); +LIBSAMPLE_API Point operator-(const Point &pt); +LIBSAMPLE_API bool operator!(const Point &pt); + +LIBSAMPLE_API Complex transmutePointIntoComplex(const Point &point); +LIBSAMPLE_API Point transmuteComplexIntoPoint(const Complex &cpx); + +LIBSAMPLE_API Point operator*(const Point &pt, double multiplier); + +#endif // POINT_H diff --git a/sources/shiboken6/tests/libsample/pointerholder.h b/sources/shiboken6/tests/libsample/pointerholder.h new file mode 100644 index 000000000..26f1cf0a6 --- /dev/null +++ b/sources/shiboken6/tests/libsample/pointerholder.h @@ -0,0 +1,23 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef POINTERHOLDER_H +#define POINTERHOLDER_H + +#include "libsamplemacros.h" + +class PointerHolder +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(PointerHolder) + + explicit PointerHolder(void *ptr) : m_pointer(ptr) {} + ~PointerHolder() = default; + + inline void *pointer() const { return m_pointer; } + +private: + void *m_pointer; +}; + +#endif // POINTERHOLDER_H diff --git a/sources/shiboken6/tests/libsample/pointf.cpp b/sources/shiboken6/tests/libsample/pointf.cpp new file mode 100644 index 000000000..736a5c6b5 --- /dev/null +++ b/sources/shiboken6/tests/libsample/pointf.cpp @@ -0,0 +1,86 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "pointf.h" + +#include <iostream> + +PointF::PointF(const Point &point) noexcept : m_x(point.x()), m_y(point.y()) +{ +} + +PointF::PointF(double x, double y) noexcept : m_x(x), m_y(y) +{ +} + +void PointF::midpoint(const PointF &other, PointF *midpoint) const +{ + if (!midpoint) + return; + midpoint->setX((m_x + other.m_x) / 2.0); + midpoint->setY((m_y + other.m_y) / 2.0); +} + +void PointF::show() const +{ + std::cout << "(x: " << m_x << ", y: " << m_y << ")"; +} + +bool PointF::operator==(const PointF &other) const +{ + return m_x == other.m_x && m_y == other.m_y; +} + +PointF PointF::operator+(const PointF &other) +{ + return {m_x + other.m_x, m_y + other.m_y}; +} + +PointF PointF::operator-(const PointF &other) +{ + return {m_x - other.m_x, m_y - other.m_y}; +} + +PointF &PointF::operator+=(PointF &other) +{ + m_x += other.m_x; + m_y += other.m_y; + return *this; +} + +PointF &PointF::operator-=(PointF &other) +{ + m_x -= other.m_x; + m_y -= other.m_y; + return *this; +} + +PointF operator*(const PointF &pt, double mult) +{ + return {pt.m_x * mult, pt.m_y * mult}; +} + +PointF operator*(const PointF &pt, int mult) +{ + return PointF(int(pt.m_x) * mult, int(pt.m_y) * mult); +} + +PointF operator*(double mult, const PointF &pt) +{ + return {pt.m_x * mult, pt.m_y * mult}; +} + +PointF operator*(int mult, const PointF &pt) +{ + return PointF(int(pt.m_x) * mult, int(pt.m_y) * mult); +} + +PointF operator-(const PointF &pt) +{ + return {-pt.m_x, -pt.m_y}; +} + +bool operator!(const PointF &pt) +{ + return pt.m_x == 0.0 && pt.m_y == 0.0; +} diff --git a/sources/shiboken6/tests/libsample/pointf.h b/sources/shiboken6/tests/libsample/pointf.h new file mode 100644 index 000000000..49e009467 --- /dev/null +++ b/sources/shiboken6/tests/libsample/pointf.h @@ -0,0 +1,65 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef POINTF_H +#define POINTF_H + +#include "libsamplemacros.h" +#include "point.h" + +#include <utility> + +class LIBSAMPLE_API PointF +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(PointF) + + PointF(const Point &point) noexcept; + PointF(double x = 0.0, double y = 0.0) noexcept; + ~PointF() noexcept = default; + + inline double x() const { return m_x; } + inline double y() const { return m_y; } + + inline void setX(double x) { m_x = x; } + inline void setY(double y) { m_y = y; } + + // This method could simply return the midpoint, + // but the interesting part of the test is to set the + // result in the pointer argument. + void midpoint(const PointF &other, PointF *midpoint) const; + + // The != operator is not implemented for the purpose of testing + // for the absence of the __ne__ method in the Python binding. + bool operator==(const PointF &other) const; + + PointF operator+(const PointF &other); + PointF operator-(const PointF &other); + + friend LIBSAMPLE_API PointF operator*(const PointF &pt, double mult); + friend LIBSAMPLE_API PointF operator*(const PointF &pt, int mult); + friend LIBSAMPLE_API PointF operator*(double mult, const PointF &pt); + friend LIBSAMPLE_API PointF operator*(int mult, const PointF &pt); + friend LIBSAMPLE_API PointF operator-(const PointF &pt); + friend LIBSAMPLE_API bool operator!(const PointF &pt); + + PointF &operator+=(PointF &other); + PointF &operator-=(PointF &other); + + void show() const; + +private: + double m_x; + double m_y; +}; + +LIBSAMPLE_API PointF operator*(const PointF &pt, double mult); +LIBSAMPLE_API PointF operator*(const PointF &pt, int mult); +LIBSAMPLE_API PointF operator*(double mult, const PointF &pt); +LIBSAMPLE_API PointF operator*(int mult, const PointF &pt); +LIBSAMPLE_API PointF operator-(const PointF &pt); +LIBSAMPLE_API bool operator!(const PointF &pt); + +LIBSAMPLE_API PointF operator*(const PointF &pt, double multiplier); + +#endif // POINTF_H diff --git a/sources/shiboken6/tests/libsample/polygon.cpp b/sources/shiboken6/tests/libsample/polygon.cpp new file mode 100644 index 000000000..6af597192 --- /dev/null +++ b/sources/shiboken6/tests/libsample/polygon.cpp @@ -0,0 +1,39 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "polygon.h" + +Polygon::Polygon(double x, double y) : m_points({Point(x, y)}) +{ +} + +Polygon::Polygon(Point point) : m_points({point}) +{ +} + +Polygon::Polygon(PointList points) : m_points(points) +{ +} + +void Polygon::addPoint(Point point) +{ + m_points.push_back(point); +} + +Polygon Polygon::doublePolygonScale(Polygon polygon) +{ + Polygon result; + for (const auto &point : polygon.points()) + result.addPoint(point * 2.0); + return result; +} + +void Polygon::stealOwnershipFromPython(Point *point) +{ + delete point; +} + +void Polygon::stealOwnershipFromPython(Polygon *polygon) +{ + delete polygon; +} diff --git a/sources/shiboken6/tests/libsample/polygon.h b/sources/shiboken6/tests/libsample/polygon.h new file mode 100644 index 000000000..2424ddd51 --- /dev/null +++ b/sources/shiboken6/tests/libsample/polygon.h @@ -0,0 +1,39 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef POLYGON_H +#define POLYGON_H + +#include "libsamplemacros.h" +#include "point.h" + +#include <list> + +class LIBSAMPLE_API Polygon // should be moveable +{ +public: + using PointList = std::list<Point>; + + Polygon() noexcept = default; + Polygon(double x, double y); + Polygon(Point point); + Polygon(PointList points); + + void addPoint(Point point); + + inline const PointList &points() const { return m_points; } + + // This method intentionally receives and returns copies of a Polygon object. + static Polygon doublePolygonScale(Polygon polygon); + + // This method invalidates the argument to be used for Polygon(Point) implicit conversion. + static void stealOwnershipFromPython(Point *point); + + // This method invalidates the argument to be used in a call to doublePolygonScale(Polygon). + static void stealOwnershipFromPython(Polygon *polygon); + +private: + PointList m_points; +}; + +#endif // POLYGON_H diff --git a/sources/shiboken6/tests/libsample/privatector.h b/sources/shiboken6/tests/libsample/privatector.h new file mode 100644 index 000000000..3b38414f8 --- /dev/null +++ b/sources/shiboken6/tests/libsample/privatector.h @@ -0,0 +1,42 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef PRIVATECTOR_H +#define PRIVATECTOR_H + +#include "libsamplemacros.h" + +class PrivateCtor +{ +public: + inline static PrivateCtor *instance() + { + static PrivateCtor self; + self.m_instantiations++; + return &self; + } + + inline int instanceCalls() + { + return m_instantiations; + } + +private: + int m_instantiations = 0; + + PrivateCtor() = default; +}; + +class DeletedDefaultCtor +{ +public: + DeletedDefaultCtor() = delete; + + DeletedDefaultCtor(const DeletedDefaultCtor &) = default; + DeletedDefaultCtor(DeletedDefaultCtor &&) = default; + DeletedDefaultCtor &operator=(const DeletedDefaultCtor &) = default; + DeletedDefaultCtor &operator=(DeletedDefaultCtor &&) = default; + ~DeletedDefaultCtor() = default; +}; + +#endif // PRIVATECTOR_H diff --git a/sources/shiboken6/tests/libsample/privatedtor.h b/sources/shiboken6/tests/libsample/privatedtor.h new file mode 100644 index 000000000..05f18ea53 --- /dev/null +++ b/sources/shiboken6/tests/libsample/privatedtor.h @@ -0,0 +1,36 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef PRIVATEDTOR_H +#define PRIVATEDTOR_H + +#include "libsamplemacros.h" + +class PrivateDtor +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(PrivateDtor) + + inline static PrivateDtor *instance() + { + static PrivateDtor self; + self.m_instantiations++; + return &self; + } + + inline int instanceCalls() + { + return m_instantiations; + } + +protected: + inline int protectedInstanceCalls() { return m_instantiations; } + +private: + int m_instantiations = 0; + + PrivateDtor() noexcept = default; + ~PrivateDtor() = default; +}; + +#endif // PRIVATEDTOR_H diff --git a/sources/shiboken6/tests/libsample/protected.cpp b/sources/shiboken6/tests/libsample/protected.cpp new file mode 100644 index 000000000..7ab52d22b --- /dev/null +++ b/sources/shiboken6/tests/libsample/protected.cpp @@ -0,0 +1,16 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "protected.h" + +int ProtectedVirtualDestructor::dtor_called = 0; + +const char *ProtectedNonPolymorphic::dataTypeName(void *) const +{ + return "pointer"; +} + +const char *ProtectedNonPolymorphic::dataTypeName(int) const +{ + return "integer"; +} diff --git a/sources/shiboken6/tests/libsample/protected.h b/sources/shiboken6/tests/libsample/protected.h new file mode 100644 index 000000000..059cced5d --- /dev/null +++ b/sources/shiboken6/tests/libsample/protected.h @@ -0,0 +1,139 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef PROTECTED_H +#define PROTECTED_H + +#include "libsamplemacros.h" +#include "objecttype.h" +#include "point.h" + +#include <string> +#include <list> + +class LIBSAMPLE_API ProtectedNonPolymorphic +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(ProtectedNonPolymorphic) + + explicit ProtectedNonPolymorphic(const char *name) : m_name(name) {} + ~ProtectedNonPolymorphic() = default; + + inline const char *publicName() { return m_name.c_str(); } + + inline static ProtectedNonPolymorphic *create() + { return new ProtectedNonPolymorphic("created"); } + +protected: + inline const char *protectedName() { return m_name.c_str(); } + inline int protectedSum(int a0, int a1) { return a0 + a1; } + inline int modifiedProtectedSum(int a0, int a1) { return a0 + a1; } + inline static const char *protectedStatic() { return "protectedStatic"; } + const char *dataTypeName(void *data = nullptr) const; + const char *dataTypeName(int data) const; + +private: + std::string m_name; +}; + +class LIBSAMPLE_API ProtectedPolymorphic +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(ProtectedPolymorphic) + + explicit ProtectedPolymorphic(const char *name) : m_name(name) {} + virtual ~ProtectedPolymorphic() = default; + + inline static ProtectedPolymorphic *create() + { return new ProtectedPolymorphic("created"); } + inline const char *publicName() { return m_name.c_str(); } + inline const char *callProtectedName() { return protectedName(); } + +protected: + virtual const char *protectedName() { return m_name.c_str(); } + +private: + std::string m_name; +}; + +class LIBSAMPLE_API ProtectedPolymorphicDaughter : public ProtectedPolymorphic +{ +public: + explicit ProtectedPolymorphicDaughter(const char *name) : + ProtectedPolymorphic(name) {} + inline static ProtectedPolymorphicDaughter *create() + { return new ProtectedPolymorphicDaughter("created"); } +}; + +class LIBSAMPLE_API ProtectedPolymorphicGrandDaughter: public ProtectedPolymorphicDaughter +{ +public: + explicit ProtectedPolymorphicGrandDaughter(const char *name) : + ProtectedPolymorphicDaughter(name) {} + inline static ProtectedPolymorphicGrandDaughter *create() + { return new ProtectedPolymorphicGrandDaughter("created"); } +}; + +class LIBSAMPLE_API ProtectedVirtualDestructor +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(ProtectedVirtualDestructor) + + ProtectedVirtualDestructor() noexcept = default; + inline static ProtectedVirtualDestructor *create() + { return new ProtectedVirtualDestructor(); } + inline static int dtorCalled() { return dtor_called; } + inline static void resetDtorCounter() { dtor_called = 0; } +protected: + virtual ~ProtectedVirtualDestructor() { dtor_called++; } +private: + static int dtor_called; +}; + +class LIBSAMPLE_API ProtectedEnumClass +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(ProtectedEnumClass) + + ProtectedEnumClass() noexcept = default; + virtual ~ProtectedEnumClass() = default; + enum PublicEnum { + PublicItem0, + PublicItem1 + }; +protected: + enum ProtectedEnum { + ProtectedItem0, + ProtectedItem1 + }; + ProtectedEnum callProtectedEnumMethod(ProtectedEnum in) + { return protectedEnumMethod(in); } + inline PublicEnum callPublicEnumMethod(PublicEnum in) + { return publicEnumMethod(in); } + + virtual ProtectedEnum protectedEnumMethod(ProtectedEnum in) { return in; } + virtual PublicEnum publicEnumMethod(PublicEnum in) { return in; } +}; + +class LIBSAMPLE_API ProtectedProperty +{ +public: + ProtectedProperty() = default; + +protected: + // This is deliberately the first member to test wrapper registration + // for value type members sharing the same memory address. + Point protectedValueTypeProperty{0, 0}; + int protectedProperty = 0; + std::list<int> protectedContainerProperty; + Event::EventType protectedEnumProperty = Event::NO_EVENT; + Point *protectedValueTypePointerProperty = nullptr; + ObjectType *protectedObjectTypeProperty = nullptr; +}; + +LIBSAMPLE_API inline ProtectedProperty *createProtectedProperty() +{ + return new ProtectedProperty; +} + +#endif // PROTECTED_H diff --git a/sources/shiboken6/tests/libsample/rect.h b/sources/shiboken6/tests/libsample/rect.h new file mode 100644 index 000000000..53296d26c --- /dev/null +++ b/sources/shiboken6/tests/libsample/rect.h @@ -0,0 +1,54 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef RECT_H +#define RECT_H + +#include "libsamplemacros.h" + +class LIBSAMPLE_API Rect +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Rect) + + Rect() noexcept = default; + explicit Rect(int left, int top, int right, int bottom) noexcept + : m_left(left), m_top(top), m_right(right), m_bottom(bottom) { } + ~Rect() = default; + + inline int left() const { return m_left; } + inline int top() const { return m_top; } + inline int right() const { return m_right; } + inline int bottom() const { return m_bottom; } +private: + int m_left = 0; + int m_top = 0; + int m_right = -1; + int m_bottom = -1; +}; + +class LIBSAMPLE_API RectF +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(RectF) + + RectF() noexcept = default; + explicit RectF(int left, int top, int right, int bottom) noexcept + : m_left(left), m_top(top), m_right(right), m_bottom(bottom) { } + RectF(const Rect &other) noexcept : + m_left(other.left()), m_top(other.top()), + m_right(other.right()), m_bottom(other.bottom()) {} + ~RectF() = default; + + inline double left() const { return m_left; } + inline double top() const { return m_top; } + inline double right() const { return m_right; } + inline double bottom() const { return m_bottom; } +private: + double m_left = 0; + double m_top = 0; + double m_right = -1; + double m_bottom = -1; +}; + +#endif // RECT_H diff --git a/sources/shiboken6/tests/libsample/reference.cpp b/sources/shiboken6/tests/libsample/reference.cpp new file mode 100644 index 000000000..29dcfc054 --- /dev/null +++ b/sources/shiboken6/tests/libsample/reference.cpp @@ -0,0 +1,53 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "reference.h" + +#include <iostream> + +void Reference::show() const +{ + std::cout << "Reference.objId: " << m_objId << ", address: " << this; +} + +Reference &Reference::returnMySecondArg(int, Reference &ref) +{ + return ref; +} + +int Reference::usesReferenceVirtual(Reference &r, int inc) +{ + return r.m_objId + inc; +} + +int Reference::usesConstReferenceVirtual(const Reference &r, int inc) +{ + return r.m_objId + inc; +} + +int Reference::callUsesReferenceVirtual(Reference &r, int inc) +{ + return usesReferenceVirtual(r, inc); +} + +int Reference::callUsesConstReferenceVirtual(const Reference &r, int inc) +{ + return usesConstReferenceVirtual(r, inc); +} + +void Reference::alterReferenceIdVirtual(Reference &r) +{ + r.setObjId(r.objId() * Reference::multiplier()); +} + +void Reference::callAlterReferenceIdVirtual(Reference &r) +{ + alterReferenceIdVirtual(r); +} + +ObjTypeReference::~ObjTypeReference() = default; + +ObjTypeReference &ObjTypeReference::returnMySecondArg(int, ObjTypeReference &ref) +{ + return ref; +} diff --git a/sources/shiboken6/tests/libsample/reference.h b/sources/shiboken6/tests/libsample/reference.h new file mode 100644 index 000000000..52818d9ea --- /dev/null +++ b/sources/shiboken6/tests/libsample/reference.h @@ -0,0 +1,62 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef REFERENCE_H +#define REFERENCE_H + +#include "libsamplemacros.h" + +class LIBSAMPLE_API Reference +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Reference) + + explicit Reference(int objId = -1) noexcept + : m_objId(objId) {} + virtual ~Reference() = default; + + inline int objId() const { return m_objId; } + inline void setObjId(int objId) { m_objId = objId; } + + inline static int usesReference(Reference &r) { return r.m_objId; } + inline static int usesConstReference(const Reference &r) { return r.m_objId; } + + virtual int usesReferenceVirtual(Reference &r, int inc); + virtual int usesConstReferenceVirtual(const Reference &r, int inc); + + int callUsesReferenceVirtual(Reference &r, int inc); + int callUsesConstReferenceVirtual(const Reference &r, int inc); + + virtual void alterReferenceIdVirtual(Reference &r); + void callAlterReferenceIdVirtual(Reference &r); + + void show() const; + + inline static int multiplier() { return 10; } + + virtual Reference &returnMyFirstArg(Reference &ref) { return ref; } + virtual Reference &returnMySecondArg(int a, Reference &ref); + + // nonsense operator to test if Shiboken is ignoring dereference operators. + int operator*() { return m_objId; } + +private: + int m_objId; +}; + +class LIBSAMPLE_API ObjTypeReference +{ +public: + LIBMINIMAL_DISABLE_MOVE(ObjTypeReference) + + ObjTypeReference() noexcept = default; + ObjTypeReference(const ObjTypeReference &) noexcept = default; + ObjTypeReference &operator=(const ObjTypeReference &) = delete; + virtual ~ObjTypeReference(); + + virtual ObjTypeReference &returnMyFirstArg(ObjTypeReference &ref) { return ref; } + virtual ObjTypeReference &returnMySecondArg(int a, ObjTypeReference &ref); + virtual ObjTypeReference &justAPureVirtualFunc(ObjTypeReference &ref) = 0; +}; + +#endif // REFERENCE_H diff --git a/sources/shiboken6/tests/libsample/removednamespaces.h b/sources/shiboken6/tests/libsample/removednamespaces.h new file mode 100644 index 000000000..669f2ebf0 --- /dev/null +++ b/sources/shiboken6/tests/libsample/removednamespaces.h @@ -0,0 +1,48 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef REMOVEDNAMESPACE_H +#define REMOVEDNAMESPACE_H + +#include "libsamplemacros.h" + +namespace RemovedNamespace1 +{ + +enum RemovedNamespace1_Enum { RemovedNamespace1_Enum_Value0 = 0, + RemovedNamespace1_Enum_Value1 = 1 }; + +enum { RemovedNamespace1_AnonymousEnum_Value0 }; + +inline int mathSum(int x, int y) { return x + y; } + +struct ObjectOnInvisibleNamespace +{ + bool exists() const { return true; } + static int toInt(RemovedNamespace1_Enum e) { return static_cast<int>(e); } + static ObjectOnInvisibleNamespace consume(const ObjectOnInvisibleNamespace &other) { return other; } +}; + +namespace RemovedNamespace2 +{ + +enum RemovedNamespace2_Enum { RemovedNamespace2_Enum_Value0 }; + +} // namespace RemovedNamespace2 +} // namespace RemovedNamespace1 + +namespace UnremovedNamespace +{ + +namespace RemovedNamespace3 +{ + enum RemovedNamespace3_Enum { RemovedNamespace3_Enum_Value0 }; + + enum { RemovedNamespace3_AnonymousEnum_Value0 }; + + inline int nestedMathSum(int x, int y) { return x + y; } + +} // namespace RemovedNamespace3 +} // namespace UnremovedNamespace + +#endif // REMOVEDNAMESPACE_H diff --git a/sources/shiboken6/tests/libsample/renaming.cpp b/sources/shiboken6/tests/libsample/renaming.cpp new file mode 100644 index 000000000..d67b42a51 --- /dev/null +++ b/sources/shiboken6/tests/libsample/renaming.cpp @@ -0,0 +1,21 @@ +// Copyright (C) 2019 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "renaming.h" + +#include <iostream> + +int ToBeRenamedValue::value() const +{ + return m_value; +} + +void ToBeRenamedValue::setValue(int v) +{ + m_value = v; +} + +void RenamedUser::useRenamedValue(const ToBeRenamedValue &v) +{ + std::cout << __FUNCTION__ << ' ' << v.value() << '\n'; +} diff --git a/sources/shiboken6/tests/libsample/renaming.h b/sources/shiboken6/tests/libsample/renaming.h new file mode 100644 index 000000000..787ccc2f7 --- /dev/null +++ b/sources/shiboken6/tests/libsample/renaming.h @@ -0,0 +1,25 @@ +// Copyright (C) 2019 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef RENAMING_H +#define RENAMING_H + +#include "libsamplemacros.h" + +class LIBSAMPLE_API ToBeRenamedValue +{ +public: + int value() const; + void setValue(int v); + +private: + int m_value = 42; +}; + +class LIBSAMPLE_API RenamedUser +{ +public: + void useRenamedValue(const ToBeRenamedValue &v); +}; + +#endif // POINT_H diff --git a/sources/shiboken6/tests/libsample/sample.cpp b/sources/shiboken6/tests/libsample/sample.cpp new file mode 100644 index 000000000..5b5f8588b --- /dev/null +++ b/sources/shiboken6/tests/libsample/sample.cpp @@ -0,0 +1,22 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "sample.h" + +namespace sample +{ + +sample::sample(int value) : m_value(value) +{ +} + +int sample::value() const +{ + return m_value; +} + +bool operator==(const sample &s1, const sample &s2) +{ + return s1.value() == s2.value(); +} +} // namespace sample diff --git a/sources/shiboken6/tests/libsample/sample.h b/sources/shiboken6/tests/libsample/sample.h new file mode 100644 index 000000000..27909571a --- /dev/null +++ b/sources/shiboken6/tests/libsample/sample.h @@ -0,0 +1,28 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef SAMPLE_H +#define SAMPLE_H + +#include "libsamplemacros.h" + +// namespace with the same name of the current package to try to mess up with the generator +namespace sample +{ + // to increase the mess we add a class with the same name of the package/namespace + class LIBSAMPLE_API sample + { + public: + sample(int value = 0); + int value() const; + private: + int m_value; + }; + + // shiboken must not generate richcompare for namespace sample + LIBSAMPLE_API bool operator==(const sample &s1, const sample &s2); + + const int INT_CONSTANT = 42; +} + +#endif // SAMPLE_H diff --git a/sources/shiboken6/tests/libsample/samplenamespace.cpp b/sources/shiboken6/tests/libsample/samplenamespace.cpp new file mode 100644 index 000000000..eae5af2d2 --- /dev/null +++ b/sources/shiboken6/tests/libsample/samplenamespace.cpp @@ -0,0 +1,101 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "samplenamespace.h" + +#include <iostream> +#include <cstdlib> +#include <ctime> + +namespace SampleNamespace +{ + +// PYSIDE-817, scoped enums must not be converted to int in the wrappers generated +// for the protected hacks +SomeClass::PublicScopedEnum SomeClass::protectedMethodReturningPublicScopedEnum() const +{ + return PublicScopedEnum::v1; +} + +OutValue enumInEnumOut(InValue in) +{ + auto retval = OutValue(-1); + switch(in) { + case ZeroIn: + retval = ZeroOut; + break; + case OneIn: + retval = OneOut; + break; + case TwoIn: + retval = TwoOut; + break; + default: + break; + } + return retval; +} + +Option enumArgumentWithDefaultValue(Option opt) +{ + return opt; +} + +int getNumber(Option opt) +{ + int retval; + switch(opt) { + case RandomNumber: + retval = rand() % 100; + break; + case UnixTime: + retval = int(std::time(nullptr)); + break; + default: + retval = 0; + break; + } + return retval; +} + +void doSomethingWithArray(const unsigned char *, unsigned int, const char *) +{ + // This function does nothing in fact. + // It is here as a dummy copy of QPixmap.loadFromData method + // to check compilation issues, i.e. if it compiles, it's ok. +} + +int enumItemAsDefaultValueToIntArgument(int value) +{ + return value; +} + +void forceDecisorSideA(ObjectType *) +{ +} + +void forceDecisorSideA(const Point &, const Str &, ObjectType *) +{ +} + +void forceDecisorSideB(int, ObjectType *) +{ +} + +void forceDecisorSideB(int, const Point &, const Str &, ObjectType *) +{ +} + +double passReferenceToValueType(const Point &point, double multiplier) +{ + return (point.x() + point.y()) * multiplier; +} + +int passReferenceToObjectType(const ObjectType &obj, int multiplier) +{ + return obj.objectName().size() * multiplier; +} + +int variableInNamespace = 42; + +} // namespace SampleNamespace diff --git a/sources/shiboken6/tests/libsample/samplenamespace.h b/sources/shiboken6/tests/libsample/samplenamespace.h new file mode 100644 index 000000000..99a0787ee --- /dev/null +++ b/sources/shiboken6/tests/libsample/samplenamespace.h @@ -0,0 +1,164 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef SAMPLENAMESPACE_H +#define SAMPLENAMESPACE_H + +#include "libsamplemacros.h" +#include "str.h" +#include "point.h" +#include "objecttype.h" + +#include <list> + +// Anonymous global enum +enum { + AnonymousGlobalEnum_Value0, + AnonymousGlobalEnum_Value1 +}; + +namespace SampleNamespace +{ + +inline namespace InlineNamespace +{ + enum EnumWithinInlineNamespace { EWIN_Value0, EWIN_Value1 }; + + class LIBSAMPLE_API ClassWithinInlineNamespace { + public: + LIBMINIMAL_DEFAULT_COPY_MOVE(ClassWithinInlineNamespace) + + ClassWithinInlineNamespace() noexcept = default; + ~ClassWithinInlineNamespace() = default; + + void setValue(EnumWithinInlineNamespace v) { m_value = v; } + EnumWithinInlineNamespace value() const { return m_value; } + + private: + EnumWithinInlineNamespace m_value = EWIN_Value0; + }; +} // inline ns + +enum Option { + None_, + RandomNumber, + UnixTime +}; + +enum InValue { + ZeroIn, + OneIn, + TwoIn +}; + +enum OutValue { + ZeroOut, + OneOut, + TwoOut +}; + +// Anonymous non-global enum. +// This counts as a class enum, since C++ namespaces +// are represented as classes in Python. +enum { + AnonymousClassEnum_Value0, + AnonymousClassEnum_Value1 +}; + +LIBSAMPLE_API OutValue enumInEnumOut(InValue in); + +LIBSAMPLE_API Option enumArgumentWithDefaultValue(Option opt = UnixTime); + +LIBSAMPLE_API int getNumber(Option opt); + +inline double powerOfTwo(double num) { + return num * num; +} + +LIBSAMPLE_API void doSomethingWithArray(const unsigned char *data, unsigned int size, + const char *format = nullptr); + +LIBSAMPLE_API int enumItemAsDefaultValueToIntArgument(int value = ZeroIn); + +class LIBSAMPLE_API SomeClass +{ +public: + enum class PublicScopedEnum { v1, v2 }; + + class SomeInnerClass + { + public: + class OkThisIsRecursiveEnough + { + public: + LIBMINIMAL_DISABLE_COPY_MOVE(OkThisIsRecursiveEnough) + + OkThisIsRecursiveEnough() noexcept = default; + virtual ~OkThisIsRecursiveEnough() = default; + enum NiceEnum { + NiceValue1, NiceValue2 + }; + + enum class NiceEnumClass { + NiceClassValue1, NiceClassValue2 + }; + + inline int someMethod(SomeInnerClass *) { return 0; } + virtual OkThisIsRecursiveEnough *someVirtualMethod(OkThisIsRecursiveEnough *arg) + { return arg; } + }; + protected: + enum ProtectedEnum { + ProtectedItem0, + ProtectedItem1 + }; + }; + struct SomeOtherInnerClass { + std::list<SomeInnerClass> someInnerClasses; + }; +protected: + enum ProtectedEnum { + ProtectedItem0, + ProtectedItem1 + }; + + PublicScopedEnum protectedMethodReturningPublicScopedEnum() const; +}; + +LIBSAMPLE_API inline int enumAsInt(SomeClass::PublicScopedEnum value) +{ return static_cast<int>(value); } + +class DerivedFromNamespace : public SomeClass::SomeInnerClass::OkThisIsRecursiveEnough +{ +public: + // FIXME Uncomment this when the fix for MSVC is available + // only to cause namespace confusion +// enum SampleNamespace { +// }; + virtual OkThisIsRecursiveEnough *someVirtualMethod(OkThisIsRecursiveEnough *arg) { return arg; } + inline OkThisIsRecursiveEnough *methodReturningTypeFromParentScope() { return nullptr; } +}; + +// The combination of the following two overloaded methods could trigger a +// problematic behaviour on the overload decisor, if it isn't working properly. +LIBSAMPLE_API void forceDecisorSideA(ObjectType *object = nullptr); +LIBSAMPLE_API void forceDecisorSideA(const Point &pt, const Str &text, + ObjectType *object = nullptr); + +// The combination of the following two overloaded methods could trigger a +// problematic behaviour on the overload decisor, if it isn't working properly. +// This is a variation of forceDecisorSideB. +LIBSAMPLE_API void forceDecisorSideB(int a, ObjectType *object = nullptr); +LIBSAMPLE_API void forceDecisorSideB(int a, const Point &pt, const Str &text, + ObjectType *object = nullptr); + +// Add a new signature on type system with only a Point value as parameter. +LIBSAMPLE_API double passReferenceToValueType(const Point &point, double multiplier); +// Add a new signature on type system with only a ObjectType pointer as parameter. +LIBSAMPLE_API int passReferenceToObjectType(const ObjectType &obj, int multiplier); + +extern LIBSAMPLE_API int variableInNamespace; + +} // namespace SampleNamespace + +#endif // SAMPLENAMESPACE_H diff --git a/sources/shiboken6/tests/libsample/sbkdate.cpp b/sources/shiboken6/tests/libsample/sbkdate.cpp new file mode 100644 index 000000000..fd408f637 --- /dev/null +++ b/sources/shiboken6/tests/libsample/sbkdate.cpp @@ -0,0 +1,23 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "sbkdate.h" + +SbkDate::SbkDate(int d, int m, int y) : m_d(d), m_m(m), m_y(y) +{ +} + +int SbkDate::day() const +{ + return m_d; +} + +int SbkDate::month() const +{ + return m_m; +} + +int SbkDate::year() const +{ + return m_y; +} diff --git a/sources/shiboken6/tests/libsample/sbkdate.h b/sources/shiboken6/tests/libsample/sbkdate.h new file mode 100644 index 000000000..5e1dd0b84 --- /dev/null +++ b/sources/shiboken6/tests/libsample/sbkdate.h @@ -0,0 +1,24 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef SBKDATE_H +#define SBKDATE_H + +#include "libsamplemacros.h" + +class LIBSAMPLE_API SbkDate +{ +public: + explicit SbkDate(int d, int m, int y); + + int day() const; + int month() const; + int year() const; + +private: + int m_d; + int m_m; + int m_y; +}; + +#endif // SBKDATE_H diff --git a/sources/shiboken6/tests/libsample/simplefile.cpp b/sources/shiboken6/tests/libsample/simplefile.cpp new file mode 100644 index 000000000..e51b14088 --- /dev/null +++ b/sources/shiboken6/tests/libsample/simplefile.cpp @@ -0,0 +1,73 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "simplefile.h" + +#include <cstdlib> +#include <cstdio> +#include <string> +#include <filesystem> + +class SimpleFilePrivate +{ +public: + LIBMINIMAL_DISABLE_COPY_MOVE(SimpleFilePrivate) + + SimpleFilePrivate(const char *filename) : m_filename(filename) {} + ~SimpleFilePrivate() = default; + + std::string m_filename; + FILE *m_descriptor = nullptr; + long m_size = 0; +}; + +SimpleFile::SimpleFile(const char *filename) : + p(std::make_unique<SimpleFilePrivate>(filename)) +{ +} + +SimpleFile::~SimpleFile() +{ + close(); +} + +const char *SimpleFile::filename() +{ + return p->m_filename.c_str(); +} + +long SimpleFile::size() const +{ + return p->m_size; +} + +bool SimpleFile::open() +{ + auto *descriptor = std::fopen(p->m_filename.c_str(), "rb"); + if (descriptor == nullptr) + return false; + + p->m_descriptor = descriptor; + const auto size = std::filesystem::file_size(std::filesystem::path(p->m_filename)); + p->m_size = long(size); + + return true; +} + +void SimpleFile::close() +{ + if (p->m_descriptor != nullptr) { + std::fclose(p->m_descriptor); + p->m_descriptor = nullptr; + } +} + +bool SimpleFile::exists() const +{ + return std::filesystem::exists(std::filesystem::path(p->m_filename)); +} + +bool SimpleFile::exists(const char *filename) +{ + return std::filesystem::exists(std::filesystem::path(filename)); +} diff --git a/sources/shiboken6/tests/libsample/simplefile.h b/sources/shiboken6/tests/libsample/simplefile.h new file mode 100644 index 000000000..e4612c944 --- /dev/null +++ b/sources/shiboken6/tests/libsample/simplefile.h @@ -0,0 +1,34 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef SIMPLEFILE_H +#define SIMPLEFILE_H + +#include "libsamplemacros.h" + +#include <memory> + +class SimpleFilePrivate; + +class LIBSAMPLE_API SimpleFile +{ +public: + LIBMINIMAL_DISABLE_COPY(SimpleFile) + LIBMINIMAL_DEFAULT_MOVE(SimpleFile) + + explicit SimpleFile(const char *filename); + ~SimpleFile(); + + const char *filename(); + long size() const; + bool open(); + void close(); + + bool exists() const; + static bool exists(const char *filename); + +private: + std::unique_ptr<SimpleFilePrivate> p; +}; + +#endif // SIMPLEFILE_H diff --git a/sources/shiboken6/tests/libsample/size.cpp b/sources/shiboken6/tests/libsample/size.cpp new file mode 100644 index 000000000..0291d6e86 --- /dev/null +++ b/sources/shiboken6/tests/libsample/size.cpp @@ -0,0 +1,11 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "size.h" + +#include <iostream> + +void Size::show() const +{ + std::cout << "(width: " << m_width << ", height: " << m_height << ")"; +} diff --git a/sources/shiboken6/tests/libsample/size.h b/sources/shiboken6/tests/libsample/size.h new file mode 100644 index 000000000..2d194e96b --- /dev/null +++ b/sources/shiboken6/tests/libsample/size.h @@ -0,0 +1,185 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef SIZE_H +#define SIZE_H + +#include "libsamplemacros.h" + +class LIBSAMPLE_API Size +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Size) + + explicit Size(double width = 0.0, double height = 0.0) noexcept : + m_width(width), m_height(height) {} + ~Size() = default; + + inline double width() const { return m_width; } + inline void setWidth(double width) { m_width = width; } + inline double height() const { return m_height; } + inline void setHeight(double height) { m_height = height; } + + inline double calculateArea() const { return m_width * m_height; } + + // Comparison Operators + inline bool operator<(const Size &other) + { + return calculateArea() < other.calculateArea(); + } + + inline bool operator>(const Size &other) + { + // On some x86 hardware and compiler combinations, floating point + // comparisons may fail due to a hardware bug. One workaround is to + // simplify comparison expressions by putting partial results in + // variables. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323#c109 + // for details. + double a = calculateArea(); + double b = other.calculateArea(); + return a > b; + } + + inline bool operator<=(const Size &other) + { + // See comments for operator>() + double a = calculateArea(); + double b = other.calculateArea(); + return a <= b; + } + + 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 + inline Size &operator+=(const Size &s) + { + m_width += s.m_width; + m_height += s.m_height; + return *this; + } + + inline Size &operator-=(const Size &s) + { + m_width -= s.m_width; + m_height -= s.m_height; + return *this; + } + + inline Size &operator*=(double mult) + { + m_width *= mult; + m_height *= mult; + return *this; + } + + inline 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 bool operator!=(const Size&, const Size&); + friend inline Size operator+(const Size&, const Size&); + friend inline Size operator-(const Size&, const Size&); + friend inline Size operator*(const Size&, double); + friend inline Size operator*(double, const Size&); + friend inline 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==(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 Size operator+(const Size &s1, const Size &s2) +{ + return Size(s1.m_width + s2.m_width, s1.m_height + s2.m_height); +} + +inline Size operator-(const Size &s1, const Size &s2) +{ + return Size(s1.m_width - s2.m_width, s1.m_height - s2.m_height); +} + +inline Size operator*(const Size &s, double mult) +{ + return Size(s.m_width * mult, s.m_height * mult); +} + +inline Size operator*(double mult, const Size &s) +{ + return Size(s.m_width * mult, s.m_height * mult); +} + +inline Size operator/(const Size &s, double div) +{ + return Size(s.m_width / div, s.m_height / div); +} + +using real = double; +using ushort = unsigned short; + +class LIBSAMPLE_API SizeF +{ +public: + explicit SizeF(real width, real height) : m_width(width), m_height(height) {} + real width() const { return m_width; } + real height() const { return m_height; } + static inline ushort passTypedefOfUnsignedShort(ushort value) { return value; } +private: + real m_width; + real m_height; +}; + +#endif // SIZE_H diff --git a/sources/shiboken6/tests/libsample/snakecasetest.cpp b/sources/shiboken6/tests/libsample/snakecasetest.cpp new file mode 100644 index 000000000..8240308b4 --- /dev/null +++ b/sources/shiboken6/tests/libsample/snakecasetest.cpp @@ -0,0 +1,44 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "snakecasetest.h" + +int SnakeCaseGlobalFunction() +{ + return 42; +} + +SnakeCaseTest::SnakeCaseTest() = default; +SnakeCaseTest::~SnakeCaseTest() = default; + +int SnakeCaseTest::testFunction1() const +{ + return 42; +} + +int SnakeCaseTest::testFunctionDisabled() const +{ + return 42; +} + +int SnakeCaseTest::testFunctionBoth() const +{ + return 42; +} + +int SnakeCaseTest::callVirtualFunc() const +{ + return virtualFunc(); +} + +int SnakeCaseTest::virtualFunc() const +{ + return 42; +} + +SnakeCaseDerivedTest::SnakeCaseDerivedTest() = default; + +int SnakeCaseDerivedTest::virtualFunc() const +{ + return 43; +} diff --git a/sources/shiboken6/tests/libsample/snakecasetest.h b/sources/shiboken6/tests/libsample/snakecasetest.h new file mode 100644 index 000000000..757dd23b2 --- /dev/null +++ b/sources/shiboken6/tests/libsample/snakecasetest.h @@ -0,0 +1,40 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef SNAKECASETEST_H +#define SNAKECASETEST_H + +#include "libsamplemacros.h" + +LIBSAMPLE_API int SnakeCaseGlobalFunction(); + +class LIBSAMPLE_API SnakeCaseTest +{ +public: + SnakeCaseTest(); + virtual ~SnakeCaseTest(); + + int testFunction1() const; + int testFunctionDisabled() const; + int testFunctionBoth() const; + + int callVirtualFunc() const; + + int testField = 42; + int testFieldDisabled = 42; + int testFieldBoth = 42; + +protected: + virtual int virtualFunc() const; +}; + +class LIBSAMPLE_API SnakeCaseDerivedTest : public SnakeCaseTest +{ +public: + SnakeCaseDerivedTest(); + +protected: + int virtualFunc() const override; +}; + +#endif // SNAKECASETEST_H diff --git a/sources/shiboken6/tests/libsample/sometime.cpp b/sources/shiboken6/tests/libsample/sometime.cpp new file mode 100644 index 000000000..ad9a0d81c --- /dev/null +++ b/sources/shiboken6/tests/libsample/sometime.cpp @@ -0,0 +1,67 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "sometime.h" + +#include <cstdio> + +void Time::setTime() +{ + m_hour = 0; + m_minute = 0; + m_second = 0; + m_msec = 0; + m_is_null = true; +} + +void Time::setTime(int h, int m, int s, int ms) +{ + m_hour = h; + m_minute = m; + m_second = s; + m_msec = ms; + m_is_null = false; +} + +Time::NumArgs Time::somethingCompletelyDifferent() +{ + return ZeroArgs; +} + +Time::NumArgs Time::somethingCompletelyDifferent(int, int, ImplicitConv ic, ObjectType *type) +{ + if (type) + return FourArgs; + if (ic.ctorEnum() == ImplicitConv::CtorThree && ic.objId() == -1) + return TwoArgs; + return ThreeArgs; +} + +Str Time::toString() const +{ + if (m_is_null) + return Str(); + char buffer[13]; + std::snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d.%03d", + m_hour, m_minute, m_second, m_msec); + return Str(buffer); +} + +bool Time::operator==(const Time &other) const +{ + return m_hour == other.m_hour + && m_minute == other.m_minute + && m_second == other.m_second + && m_msec == other.m_msec + && m_is_null == other.m_is_null; +} + +bool Time::operator!=(const Time &other) const +{ + return !operator==(other); +} + +Time::operator Str() const +{ + return Time::toString(); +} diff --git a/sources/shiboken6/tests/libsample/sometime.h b/sources/shiboken6/tests/libsample/sometime.h new file mode 100644 index 000000000..575d4b136 --- /dev/null +++ b/sources/shiboken6/tests/libsample/sometime.h @@ -0,0 +1,66 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef SOMETIME_H +#define SOMETIME_H + +#include "libsamplemacros.h" +#include "str.h" +#include "implicitconv.h" +#include "objecttype.h" + +class LIBSAMPLE_API Time +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Time) + + enum NumArgs { + ZeroArgs, + TwoArgs, + ThreeArgs, + FourArgs + }; + + Time() noexcept = default; + explicit Time(int h, int m, int s = 0, int ms = 0) noexcept: + m_hour(h), m_minute(m), m_second(s), m_msec(ms), m_is_null(false) + {} + + ~Time() = default; + + inline bool isNull() const { return m_is_null; } + + inline int hour() const { return m_hour; } + inline int minute() const { return m_minute; } + inline int second() const { return m_second; } + inline int msec() const { return m_msec; } + + void setTime(); + void setTime(int h, int m, int s = 0, int ms = 0); + + // This one is completely different from the other methods in this class, + // it was added to give the overload decisor a really hard time with + // an value-type with implicit conversion and a default argument, and also + // an object-type, just because I feel like it. + NumArgs somethingCompletelyDifferent(); + NumArgs somethingCompletelyDifferent(int h, int m, + ImplicitConv ic = ImplicitConv::CtorThree, + ObjectType *type = nullptr); + + Str toString() const; + bool operator==(const Time &other) const; + bool operator!=(const Time &other) const; + + // This cast operator must become an implicit conversion of Str. + operator Str() const; + +private: + int m_hour = 0; + int m_minute = 0; + int m_second = 0; + int m_msec = 0; + + bool m_is_null = true; +}; + +#endif // SOMETIME_H diff --git a/sources/shiboken6/tests/libsample/stdcomplex.cpp b/sources/shiboken6/tests/libsample/stdcomplex.cpp new file mode 100644 index 000000000..847174387 --- /dev/null +++ b/sources/shiboken6/tests/libsample/stdcomplex.cpp @@ -0,0 +1,32 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "stdcomplex.h" + +#include <iostream> + +StdComplex::StdComplex() noexcept = default; + +StdComplex::StdComplex(double re, double img) noexcept : m_impl(re, img) +{ +} + +StdComplex::operator int() const +{ + return std::lround(abs_value()); +} + +StdComplex::StdComplex(const Impl &impl) noexcept : m_impl(impl) +{ +} + +StdComplex StdComplex::pow(const StdComplex &exp) const +{ + return StdComplex(std::pow(m_impl, exp.m_impl)); +} + +std::ostream &operator<<(std::ostream &str, const StdComplex &c) +{ + str << "Complex(" << c.real() << ", " << c.imag() << ')'; + return str; +} diff --git a/sources/shiboken6/tests/libsample/stdcomplex.h b/sources/shiboken6/tests/libsample/stdcomplex.h new file mode 100644 index 000000000..b39b80612 --- /dev/null +++ b/sources/shiboken6/tests/libsample/stdcomplex.h @@ -0,0 +1,55 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef STDCOMPLEX_H +#define STDCOMPLEX_H + +#include "libsamplemacros.h" + +#include <complex> +#include <iosfwd> + +// A complex number based on std::complex for exercising esoteric number +// protocols (Py_nb_). For standard number protocols, see Point. + +class LIBSAMPLE_API StdComplex +{ + using Impl = std::complex<double>; + +public: + StdComplex() noexcept; + explicit StdComplex(double re, double img) noexcept; + + double real() const { return m_impl.real(); } + double imag() const { return m_impl.imag(); } + + double abs_value() const { return std::abs(m_impl); } // abs() is reserved Python word + + StdComplex pow(const StdComplex &exp) const; + + operator double() const { return abs_value(); } + operator int() const; + + friend inline bool operator==(const StdComplex &c1, const StdComplex &c2) noexcept + { return c1.m_impl == c2.m_impl; } + friend inline bool operator!=(const StdComplex &c1, const StdComplex &c2) noexcept + { return c1.m_impl != c2.m_impl; } + + friend inline StdComplex operator+(const StdComplex &c1, const StdComplex &c2) noexcept + { return StdComplex(c1.m_impl + c2.m_impl); } + friend inline StdComplex operator-(const StdComplex &c1, const StdComplex &c2) noexcept + { return StdComplex(c1.m_impl - c2.m_impl); } + friend inline StdComplex operator*(const StdComplex &c1, const StdComplex &c2) noexcept + { return StdComplex(c1.m_impl * c2.m_impl); } + friend inline StdComplex operator/(const StdComplex &c1, const StdComplex &c2) noexcept + { return StdComplex(c1.m_impl / c2.m_impl); } + +private: + explicit StdComplex(const Impl &impl) noexcept; + + Impl m_impl; +}; + +std::ostream &operator<<(std::ostream &str, const StdComplex &c); + +#endif // STDCOMPLEX_H diff --git a/sources/shiboken6/tests/libsample/str.cpp b/sources/shiboken6/tests/libsample/str.cpp new file mode 100644 index 000000000..742c0bb01 --- /dev/null +++ b/sources/shiboken6/tests/libsample/str.cpp @@ -0,0 +1,137 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "str.h" + +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <sstream> + +Str::Str(char c) +{ + char str[2] = { c, 0 }; + init(str); +} + +Str::Str(const char *cstr) +{ + init(cstr); +} + +void Str::init(const char *cstr) +{ + if (cstr) + m_str = cstr; +} + +Str Str::arg(const Str &s) const +{ + size_t idx = m_str.find_first_of("%VAR"); + if (idx == std::string::npos) + return *this; + + std::string result = m_str; + result.replace(idx, 4, s.m_str); + return result.c_str(); +} + +Str &Str::append(const Str &s) +{ + m_str += s.m_str; + return *this; +} + +Str &Str::prepend(const Str &s) +{ + m_str = s.m_str + m_str; + return *this; +} + +const char *Str::cstring() const +{ + return m_str.c_str(); +} + +int Str::toInt(bool *ok, int base) const +{ + int result = 0; + std::istringstream conv(m_str); + switch (base) { + case 8: + conv >> std::oct >> result; + break; + case 10: + conv >> std::dec >> result; + break; + case 16: + conv >> std::hex >> result; + break; + } + const bool my_ok = std::istringstream::eofbit & conv.rdstate(); + if (!my_ok) + result = 0; + if (ok) + *ok = my_ok; + return result; +} + +void Str::show() const +{ + std::printf("%s", cstring()); +} + +char Str::get_char(int pos) const +{ + return m_str[pos]; +} + +bool Str::set_char(int pos, char ch) +{ + m_str[pos] = ch; + return true; +} + +Str Str::operator+(int number) const +{ + std::ostringstream in; + in << m_str << number; + return in.str().c_str(); +} + +bool Str::operator==(const Str &other) const +{ + return m_str == other.m_str; +} + +Str operator+(int number, const Str &str) +{ + std::ostringstream in; + in << number << str.m_str; + return in.str().c_str(); +} + +bool Str::operator<(const Str &other) const +{ + return m_str < other.m_str; +} + +unsigned int strHash(const Str &str) +{ + unsigned int result = 0; + for (char c : str.m_str) + result = 5U * result + unsigned(c); + return result; +} + +void changePStr(PStr *pstr, const char *suffix) +{ + pstr->append(suffix); +} + +void duplicatePStr(PStr *pstr) +{ + if (!pstr) + return; + pstr->append(*pstr); +} diff --git a/sources/shiboken6/tests/libsample/str.h b/sources/shiboken6/tests/libsample/str.h new file mode 100644 index 000000000..6b3386cef --- /dev/null +++ b/sources/shiboken6/tests/libsample/str.h @@ -0,0 +1,52 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef STR_H +#define STR_H + +#include "libsamplemacros.h" + +#include <string> + +class LIBSAMPLE_API Str +{ +public: + Str(char c); + Str(const char *cstr = ""); + + Str arg(const Str &s) const; + + Str &append(const Str &s); + Str &prepend(const Str &s); + + const char *cstring() const; + char get_char(int pos) const; + bool set_char(int pos, char ch); + + int toInt(bool *ok = nullptr, int base = 10) const; + + void show() const; + + inline int size() const { return int(m_str.size()); } + + // nonsense operator just to test reverse operators + Str operator+(int number) const; + bool operator==(const Str &other) const; + bool operator<(const Str &other) const; + +private: + void init(const char *cstr); + std::string m_str; + + friend LIBSAMPLE_API Str operator+(int number, const Str &str); + friend LIBSAMPLE_API unsigned int strHash(const Str &str); +}; + +LIBSAMPLE_API Str operator+(int number, const Str &str); +LIBSAMPLE_API unsigned int strHash(const Str &str); + +using PStr = Str; +LIBSAMPLE_API void changePStr(PStr *pstr, const char *suffix); +LIBSAMPLE_API void duplicatePStr(PStr *pstr = nullptr); + +#endif // STR_H diff --git a/sources/shiboken6/tests/libsample/strlist.cpp b/sources/shiboken6/tests/libsample/strlist.cpp new file mode 100644 index 000000000..5840a0516 --- /dev/null +++ b/sources/shiboken6/tests/libsample/strlist.cpp @@ -0,0 +1,25 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "strlist.h" + +#include <algorithm> + +bool StrList::operator==(const std::list<Str> &other) const +{ + return size() == other.size() + && std::equal(begin(), end(), other.begin()); +} + +Str StrList::join(const Str &sep) const +{ + Str result; + const auto i1 = begin(); + const auto i2 = end(); + for (auto it = i1; i1 != i2; ++it) { + if (it != i1) + result.append(sep); + result.append(*it); + } + return result; +} diff --git a/sources/shiboken6/tests/libsample/strlist.h b/sources/shiboken6/tests/libsample/strlist.h new file mode 100644 index 000000000..01865a5b4 --- /dev/null +++ b/sources/shiboken6/tests/libsample/strlist.h @@ -0,0 +1,49 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef STRLIST_H +#define STRLIST_H + +#include "libsamplemacros.h" +#include "str.h" + +#include <list> + +class LIBSAMPLE_API StrList : public std::list<Str> +{ +public: + enum CtorEnum { + NoParamsCtor, + StrCtor, + CopyCtor, + ListOfStrCtor + }; + + inline StrList() = default; + inline StrList(const std::list<Str> &lst) : + std::list<Str>(lst), m_ctorUsed(ListOfStrCtor) {} + inline explicit StrList(const Str &str) : + m_ctorUsed(StrCtor) { push_back(str); } + inline StrList(const StrList &lst) : + std::list<Str>(lst), m_ctorUsed(CopyCtor) {} + + StrList(StrList &&) = default; + StrList &operator=(const StrList &) = default; + StrList &operator=(StrList &&) = default; + ~StrList() = default; + + inline void append(const Str &str) { push_back(str); } + Str join(const Str &sep) const; + + bool operator==(const std::list<Str> &other) const; + inline bool operator!=(const std::list<Str> &other) const { return !(*this == other); } + + CtorEnum constructorUsed() const { return m_ctorUsed; } + +private: + CtorEnum m_ctorUsed = NoParamsCtor; +}; + +using PStrList = StrList; + +#endif // STRLIST_H diff --git a/sources/shiboken6/tests/libsample/templateptr.cpp b/sources/shiboken6/tests/libsample/templateptr.cpp new file mode 100644 index 000000000..a73f78417 --- /dev/null +++ b/sources/shiboken6/tests/libsample/templateptr.cpp @@ -0,0 +1,8 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "templateptr.h" + +void TemplatePtr::dummy(std::list<std::pair<BlackBox *, BlackBox *> > &) +{ +} diff --git a/sources/shiboken6/tests/libsample/templateptr.h b/sources/shiboken6/tests/libsample/templateptr.h new file mode 100644 index 000000000..bf230c363 --- /dev/null +++ b/sources/shiboken6/tests/libsample/templateptr.h @@ -0,0 +1,19 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef TEMPLATEPTR_H +#define TEMPLATEPTR_H + +#include "libsamplemacros.h" +#include "blackbox.h" + +#include <utility> +#include <list> + +class LIBSAMPLE_API TemplatePtr +{ +public: + void dummy(std::list<std::pair<BlackBox *, BlackBox *> > &items); +}; + +#endif // TEMPLATEPTR_H diff --git a/sources/shiboken6/tests/libsample/transform.cpp b/sources/shiboken6/tests/libsample/transform.cpp new file mode 100644 index 000000000..5ccf5d1ed --- /dev/null +++ b/sources/shiboken6/tests/libsample/transform.cpp @@ -0,0 +1,28 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// Copyright (C) 2013 Kitware, Inc. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "transform.h" + +#include <cmath> + +Point applyHomogeneousTransform(const Point &in, + double m11, double m12, double m13, + double m21, double m22, double m23, + double m31, double m32, double m33, + bool *okay) +{ + double x = m11 * in.x() + m12 * in.y() + m13; + double y = m21 * in.x() + m22 * in.y() + m23; + double w = m31 * in.x() + m32 * in.y() + m33; + + if (std::isfinite(w) && fabs(w) > 1e-10) { + if (okay) + *okay = true; + return {x / w, y / w}; + } + + if (okay) + *okay = false; + return {}; +} diff --git a/sources/shiboken6/tests/libsample/transform.h b/sources/shiboken6/tests/libsample/transform.h new file mode 100644 index 000000000..34ebf40d3 --- /dev/null +++ b/sources/shiboken6/tests/libsample/transform.h @@ -0,0 +1,18 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// Copyright (C) 2013 Kitware, Inc. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef TRANSFORM_H +#define TRANSFORM_H + +#include "point.h" + +#include "libsamplemacros.h" + +LIBSAMPLE_API Point applyHomogeneousTransform(const Point &in, + double m11, double m12, double m13, + double m21, double m22, double m23, + double m31, double m32, double m33, + bool *okay); + +#endif // TRANSFORM_H diff --git a/sources/shiboken6/tests/libsample/typesystypedef.cpp b/sources/shiboken6/tests/libsample/typesystypedef.cpp new file mode 100644 index 000000000..d9c9a92fc --- /dev/null +++ b/sources/shiboken6/tests/libsample/typesystypedef.cpp @@ -0,0 +1,12 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "typesystypedef.h" + +ValueWithUnitUser::ValueWithUnitUser() = default; + +ValueWithUnit<double, LengthUnit::Millimeter> + ValueWithUnitUser::doubleInchToMillimeter(ValueWithUnit<double, LengthUnit::Inch> v) +{ + return ValueWithUnit<double, LengthUnit::Millimeter>(v.value() * 254); +} diff --git a/sources/shiboken6/tests/libsample/typesystypedef.h b/sources/shiboken6/tests/libsample/typesystypedef.h new file mode 100644 index 000000000..be42fbefe --- /dev/null +++ b/sources/shiboken6/tests/libsample/typesystypedef.h @@ -0,0 +1,32 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef TYPESYSTYPEDEF_H +#define TYPESYSTYPEDEF_H + +#include "libsamplemacros.h" + +enum class LengthUnit { Millimeter, Inch }; + +template <class T, LengthUnit Unit> +class ValueWithUnit +{ + public: + explicit ValueWithUnit(T value = {}) : m_value(value) {} + + T value() const { return m_value; } + void setValue(const T &value) { m_value = value; } + +private: + T m_value; +}; + +class LIBSAMPLE_API ValueWithUnitUser +{ +public: + ValueWithUnitUser(); + + static ValueWithUnit<double, LengthUnit::Millimeter> doubleInchToMillimeter(ValueWithUnit<double, LengthUnit::Inch>); +}; + +#endif // TYPESYSTYPEDEF_H diff --git a/sources/shiboken6/tests/libsample/valueandvirtual.h b/sources/shiboken6/tests/libsample/valueandvirtual.h new file mode 100644 index 000000000..799e11e40 --- /dev/null +++ b/sources/shiboken6/tests/libsample/valueandvirtual.h @@ -0,0 +1,25 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef VALUEANDVIRTUAL_H +#define VALUEANDVIRTUAL_H + +#include "libsamplemacros.h" + +class ValueAndVirtual +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(ValueAndVirtual) + + explicit ValueAndVirtual(int id) noexcept : m_id(id) {} + virtual ~ValueAndVirtual() = default; + + bool operator()(int id, int id2) { return id == id2; } + + inline int id() const { return m_id; } + +private: + int m_id; +}; + +#endif // VALUEANDVIRTUAL_H diff --git a/sources/shiboken6/tests/libsample/virtualmethods.cpp b/sources/shiboken6/tests/libsample/virtualmethods.cpp new file mode 100644 index 000000000..515564664 --- /dev/null +++ b/sources/shiboken6/tests/libsample/virtualmethods.cpp @@ -0,0 +1,66 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "virtualmethods.h" + +int VirtualDtor::dtor_called = 0; + +double VirtualMethods::virtualMethod0(Point pt, int val, Complex cpx, bool b) +{ + return (pt.x() * pt.y() * val) + cpx.imag() + ((int) b); +} + +bool VirtualMethods::createStr(const char *text, Str *&ret) +{ + if (!text) { + ret = nullptr; + return false; + } + + ret = new Str(text); + return true; +} + +void VirtualMethods::getMargins(int *left, int *top, int *right, int *bottom) const +{ + *left = m_left; + *top = m_top; + *right = m_right; + *bottom = m_bottom; +} + +int VirtualMethods::recursionOnModifiedVirtual(Str) const +{ + return 0; +} + +const Str & VirtualMethods::returnConstRef() const +{ + static const Str result; + return result; +} + +int VirtualMethods::stringViewLength(std::string_view in) const +{ + return int(in.size()); +} + +double VirtualDaughter2::virtualMethod0(Point pt, int val, Complex cpx, bool b) +{ + return 42 + VirtualMethods::virtualMethod0(pt, val, cpx, b); +} + +int VirtualDaughter2::sum0(int a0, int a1, int a2) +{ + return 42 + VirtualMethods::sum0(a0, a1, a2); +} + +double VirtualFinalDaughter::virtualMethod0(Point pt, int val, Complex cpx, bool b) +{ + return 42 + VirtualMethods::virtualMethod0(pt, val, cpx, b); +} + +int VirtualFinalDaughter::sum0(int a0, int a1, int a2) +{ + return 42 + VirtualMethods::sum0(a0, a1, a2); +} diff --git a/sources/shiboken6/tests/libsample/virtualmethods.h b/sources/shiboken6/tests/libsample/virtualmethods.h new file mode 100644 index 000000000..b7172ad0d --- /dev/null +++ b/sources/shiboken6/tests/libsample/virtualmethods.h @@ -0,0 +1,145 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef VIRTUALMETHODS_H +#define VIRTUALMETHODS_H + +#include "point.h" +#include "complex.h" +#include "str.h" + +#include "libsamplemacros.h" +#include "strlist.h" + +#include <string_view> +#include <string> + +class LIBSAMPLE_API VirtualMethods +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(VirtualMethods) + + explicit VirtualMethods(Str name = "VirtualMethods") : m_name(name) {} + virtual ~VirtualMethods() = default; + + virtual double virtualMethod0(Point pt, int val, Complex cpx, bool b); + double callVirtualMethod0(Point pt, int val, Complex cpx, bool b) + { + return virtualMethod0(pt, val, cpx, b); + } + + // Binding modification: rename. + virtual int sum0(int a0, int a1, int a2) { return a0 + a1 + a2; } + int callSum0(int a0, int a1, int a2) { return sum0(a0, a1, a2); } + + // Binding modification: set default value for the last argument. + virtual int sum1(int a0, int a1, int a2) { return a0 + a1 + a2; } + int callSum1(int a0, int a1, int a2) { return sum1(a0, a1, a2); } + + // Binding modification: remove the last argument and set a default value for it. + virtual int sum2(int a0, int a1, int a2) { return a0 + a1 + a2; } + int callSum2(int a0, int a1, int a2) { return sum2(a0, a1, a2); } + + // Binding modification: remove the second argument. + virtual int sum3(int a0, int a1, int a2) { return a0 + a1 + a2; } + int callSum3(int a0, int a1, int a2) { return sum3(a0, a1, a2); } + + // Binding modification: remove the second argument and set its default + // value, then inject code on the binding reimplementation of the virtual + // (with a native inject-code) to sum the value of the removed + // argument to the first argument before the method is called. + virtual int sum4(int a0, int a1, int a2) { return a0 + a1 + a2; } + int callSum4(int a0, int a1, int a2) { return sum4(a0, a1, a2); } + + // Binding modification: prepend a string to the results of a Python override. + virtual Str name() { return m_name; } + Str callName() { return name(); } + + // Binding modification: code injection that calls the Python override by itself. + virtual void callMe() {} + void callCallMe() { callMe(); } + + // Passing reference to pointers. + virtual bool createStr(const char *text, Str *&ret); + bool callCreateStr(const char *text, Str *&ret) { return createStr(text, ret); } + + // Return a non-binded method + std::list<Str> callStrListToStdList(const StrList &strList) + { return strListToStdList(strList); } + virtual std::list<Str> strListToStdList(const StrList &strList ) + { return strList; } + + void setMargins(int left, int top, int right, int bottom) + { + m_left = left; + m_top = top; + m_right = right; + m_bottom = bottom; + } + virtual void getMargins(int *left, int *top, int *right, int *bottom) const; + void callGetMargins(int *left, int *top, int *right, int *bottom) const + { + getMargins(left, top, right, bottom); + } + + virtual int recursionOnModifiedVirtual(Str arg) const; + int callRecursionOnModifiedVirtual(Str arg) const { return recursionOnModifiedVirtual(arg); } + + virtual const Str &returnConstRef() const; + + virtual int stringViewLength(std::string_view in) const; + +protected: + // PYSIDE-1388: Protected hack with final classes (see VirtualFinalDaughter). + void protectedMethod() {} + +private: + Str m_name; + int m_left = 0; + int m_top = 0; + int m_right = 0; + int m_bottom = 0; +}; + +class LIBSAMPLE_API VirtualDaughter : public VirtualMethods +{ +public: + VirtualDaughter() : VirtualMethods() {} + VirtualDaughter(Str name) : VirtualMethods(name) {} +}; + +class LIBSAMPLE_API VirtualDaughter2 : public VirtualMethods +{ +public: + VirtualDaughter2() : VirtualMethods("VirtualDaughter2") {} + + double virtualMethod0(Point pt, int val, Complex cpx, bool b) override; + int sum0(int a0, int a1, int a2) final; +}; + +class LIBSAMPLE_API VirtualFinalDaughter final : public VirtualMethods +{ +public: + VirtualFinalDaughter() : VirtualMethods("VirtualFinalDaughter") {} + + double virtualMethod0(Point pt, int val, Complex cpx, bool b) override; + int sum0(int a0, int a1, int a2) override; +}; + +class LIBSAMPLE_API VirtualDtor +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(VirtualDtor) + + VirtualDtor() noexcept = default; + virtual ~VirtualDtor() { dtor_called++; } + + static VirtualDtor *create() { return new VirtualDtor(); } + static int dtorCalled() { return dtor_called; } + static void resetDtorCounter() { dtor_called = 0; } + +private: + static int dtor_called; +}; + +#endif // VIRTUALMETHODS_H diff --git a/sources/shiboken6/tests/libsample/voidholder.h b/sources/shiboken6/tests/libsample/voidholder.h new file mode 100644 index 000000000..3f0f4d973 --- /dev/null +++ b/sources/shiboken6/tests/libsample/voidholder.h @@ -0,0 +1,32 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#ifndef VOIDHOLDER_H +#define VOIDHOLDER_H + +#include "libsamplemacros.h" + +class VoidHolder +{ +public: + LIBMINIMAL_DEFAULT_COPY_MOVE(VoidHolder) + + explicit VoidHolder(void *ptr = nullptr) noexcept : m_ptr(ptr) {} + ~VoidHolder() = default; + + inline void *voidPointer() { return m_ptr; } + inline static void *gimmeMeSomeVoidPointer() + { + static void *pointerToSomething = new VoidHolder(); + return pointerToSomething; + } + void *takeVoidPointer(void *item) + { + return item; + } + +private: + void *m_ptr; +}; + +#endif // VOIDHOLDER_H |