diff options
Diffstat (limited to 'sources/shiboken6/tests/libsample')
116 files changed, 2295 insertions, 2000 deletions
diff --git a/sources/shiboken6/tests/libsample/CMakeLists.txt b/sources/shiboken6/tests/libsample/CMakeLists.txt index 6e436ee1f..926972340 100644 --- a/sources/shiboken6/tests/libsample/CMakeLists.txt +++ b/sources/shiboken6/tests/libsample/CMakeLists.txt @@ -1,63 +1,93 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + project(libsample) set(libsample_SRC -abstract.cpp -blackbox.cpp -bytearray.cpp -bucket.cpp -collector.cpp -complex.cpp -ctparam.cpp -onlycopy.cpp -derived.cpp -derivedusingct.cpp -echo.cpp -exceptiontest.cpp -functions.cpp -handle.cpp -implicitconv.cpp -intwrapper.cpp -injectcode.cpp -listuser.cpp -modifications.cpp -mapuser.cpp -modified_constructor.cpp -multiple_derived.cpp -oddbool.cpp -objectmodel.cpp -objecttype.cpp -objecttypeholder.cpp -objecttypelayout.cpp -objecttypeoperators.cpp -objectview.cpp -overload.cpp -overloadsort.cpp -pairuser.cpp -pen.cpp -photon.cpp -point.cpp -pointf.cpp -polygon.cpp -protected.cpp -reference.cpp -renaming.cpp -sample.cpp -samplenamespace.cpp -sbkdate.cpp -simplefile.cpp -size.cpp -snakecasetest.cpp -sometime.cpp -str.cpp -strlist.cpp -templateptr.cpp -transform.cpp -typesystypedef.cpp -virtualmethods.cpp -expression.cpp -filter.cpp +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) diff --git a/sources/shiboken6/tests/libsample/abstract.cpp b/sources/shiboken6/tests/libsample/abstract.cpp index 65fd651ad..0d67d8630 100644 --- a/sources/shiboken6/tests/libsample/abstract.cpp +++ b/sources/shiboken6/tests/libsample/abstract.cpp @@ -1,64 +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 -#include <iostream> #include "abstract.h" -#include "objecttype.h" -using namespace std; +#include <iostream> const int Abstract::staticPrimitiveField = 0; -Abstract::Abstract(int id) : m_id(id) +Abstract::Abstract(int id) noexcept : m_id(id) { - toBeRenamedField = readOnlyField = primitiveField = 123; - valueTypeField = Point(12, 34); - objectTypeField = nullptr; bitField = 0; } -Abstract::~Abstract() -{ -} +Abstract::~Abstract() = default; -void -Abstract::unpureVirtual() +void Abstract::unpureVirtual() { } -void -Abstract::callUnpureVirtual() +void Abstract::callUnpureVirtual() { this->unpureVirtual(); } - -void -Abstract::callPureVirtual() +void Abstract::callPureVirtual() { this->pureVirtual(); } -void -Abstract::show(PrintFormat format) +void Abstract::show(PrintFormat format) const { - cout << '<'; + std::cout << '<'; switch(format) { - case Short: - cout << this; - break; - case Verbose: - cout << "class " << className() << " | cptr: " << this; - cout << ", id: " << m_id; - break; - case OnlyId: - cout << "id: " << m_id; - break; - case ClassNameAndId: - cout << className() << " - id: " << m_id; - break; + 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; } - cout << '>'; + 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) @@ -66,7 +66,6 @@ void Abstract::callVirtualGettingEnum(PrintFormat p) virtualGettingAEnum(p); } -void Abstract::virtualGettingAEnum(Abstract::PrintFormat p) +void Abstract::virtualGettingAEnum(Abstract::PrintFormat) { } - diff --git a/sources/shiboken6/tests/libsample/abstract.h b/sources/shiboken6/tests/libsample/abstract.h index 0e66ad0e1..4c1b98d90 100644 --- a/sources/shiboken6/tests/libsample/abstract.h +++ b/sources/shiboken6/tests/libsample/abstract.h @@ -24,6 +24,8 @@ private: PrivValue2 = PrivValue1 + 2 }; public: + LIBMINIMAL_DISABLE_COPY_MOVE(Abstract) + enum PrintFormat { Short, Verbose, @@ -38,26 +40,26 @@ public: }; static const int staticPrimitiveField; - int primitiveField; + int primitiveField = 123; Complex userPrimitiveField; - Point valueTypeField; - ObjectType* objectTypeField; - int toBeRenamedField; - int readOnlyField; + Point valueTypeField{12, 34}; + ObjectType *objectTypeField = nullptr; + int toBeRenamedField = 123; + int readOnlyField = 123; - Abstract(int id = -1); + explicit Abstract(int id = -1) noexcept; virtual ~Abstract(); - inline int id() { return m_id; } + inline int id() const { return m_id; } // factory method - inline static Abstract* createObject() { return nullptr; } + inline static Abstract *createObject() { return nullptr; } // method that receives an Object Type - inline static int getObjectId(Abstract* obj) { return obj->id(); } + inline static int getObjectId(Abstract *obj) { return obj->id(); } virtual void pureVirtual() = 0; - virtual void* pureVirtualReturningVoidPtr() = 0; + virtual void *pureVirtualReturningVoidPtr() = 0; virtual void unpureVirtual(); virtual PrintFormat returnAnEnum() = 0; @@ -67,13 +69,16 @@ public: void callPureVirtual(); void callUnpureVirtual(); - void show(PrintFormat format = Verbose); + void show(PrintFormat format = Verbose) const; virtual Type type() const { return TpAbstract; } - virtual void hideFunction(HideType* arg) = 0; + virtual void hideFunction(HideType *arg) = 0; + + virtual void virtualWithOutParameter(int &x) const; + int callVirtualWithOutParameter() const; protected: - virtual const char* className() { return "Abstract"; } + virtual const char *className() const { return "Abstract"; } // Protected bit-field structure member. unsigned int bitField: 1; @@ -82,4 +87,5 @@ 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 index f648a3770..2ac435d3d 100644 --- a/sources/shiboken6/tests/libsample/blackbox.cpp +++ b/sources/shiboken6/tests/libsample/blackbox.cpp @@ -3,102 +3,79 @@ #include "blackbox.h" -using namespace std; - BlackBox::~BlackBox() { // Free all maps. - while (!m_objects.empty()) { - delete (*m_objects.begin()).second; - m_objects.erase(m_objects.begin()); - } - while (!m_points.empty()) { - delete (*m_points.begin()).second; - m_points.erase(m_points.begin()); - } + for (const auto &p :m_objects) + delete p.second; + for (const auto &p : m_points) + delete p.second; } -int -BlackBox::keepObjectType(ObjectType* object) +int BlackBox::keepObjectType(ObjectType *object) { - m_ticket++; - std::pair<int, ObjectType*> item(m_ticket, object); - m_objects.insert(item); + ++m_ticket; + m_objects.insert({m_ticket, object}); object->setParent(nullptr); return m_ticket; } -ObjectType* -BlackBox::retrieveObjectType(int ticket) +ObjectType *BlackBox::retrieveObjectType(int ticket) { const auto it = m_objects.find(ticket); if (it != m_objects.end()) { - ObjectType* second = it->second; + ObjectType *second = it->second; m_objects.erase(it); return second; } return nullptr; } -void -BlackBox::disposeObjectType(int ticket) +void BlackBox::disposeObjectType(int ticket) { - ObjectType* object = retrieveObjectType(ticket); - if (object) - delete object; + delete retrieveObjectType(ticket); } -int -BlackBox::keepPoint(Point* point) +int BlackBox::keepPoint(Point *point) { - m_ticket++; - std::pair<int, Point*> item(m_ticket, point); - m_points.insert(item); - + ++m_ticket; + m_points.insert({m_ticket, point}); return m_ticket; } -Point* -BlackBox::retrievePoint(int ticket) +Point *BlackBox::retrievePoint(int ticket) { const auto it = m_points.find(ticket); if (it != m_points.end()) { - Point* second = it->second; + Point *second = it->second; m_points.erase(it); return second; } return nullptr; } -void -BlackBox::disposePoint(int ticket) +void BlackBox::disposePoint(int ticket) { - Point* point = retrievePoint(ticket); - if (point) - delete point; + delete retrievePoint(ticket); } - -std::list<ObjectType*> -BlackBox::objects() +std::list<ObjectType*> BlackBox::objects() { std::list<ObjectType*> l; - for (auto it = m_objects.begin(), end = m_objects.end(); it != end; ++it) - l.push_back((*it).second); + for (const auto &p : m_objects) + l.push_back(p.second); return l; } -std::list<Point*> -BlackBox::points() +std::list<Point*> BlackBox::points() { std::list<Point*> l; - for (auto it = m_points.begin(), end = m_points.end(); it != end; ++it) - l.push_back((*it).second); + 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 index bfcbd2128..9d32670dd 100644 --- a/sources/shiboken6/tests/libsample/blackbox.h +++ b/sources/shiboken6/tests/libsample/blackbox.h @@ -5,25 +5,28 @@ #define BLACKBOX_H #include "libsamplemacros.h" -#include <map> #include "objecttype.h" #include "point.h" +#include <list> +#include <map> + class LIBSAMPLE_API BlackBox { public: - typedef std::map<int, ObjectType*> ObjectTypeMap; - typedef std::map<int, Point*> PointMap; + using ObjectTypeMap = std::map<int, ObjectType*>; + using PointMap = std::map<int, Point*>; - BlackBox() { m_ticket = -1;} + LIBMINIMAL_DEFAULT_COPY_MOVE(BlackBox) + BlackBox() noexcept = default; ~BlackBox(); - int keepObjectType(ObjectType* object); - ObjectType* retrieveObjectType(int ticket); + int keepObjectType(ObjectType *object); + ObjectType *retrieveObjectType(int ticket); void disposeObjectType(int ticket); - int keepPoint(Point* point); - Point* retrievePoint(int ticket); + int keepPoint(Point *point); + Point *retrievePoint(int ticket); void disposePoint(int ticket); std::list<ObjectType*> objects(); @@ -35,8 +38,7 @@ public: private: ObjectTypeMap m_objects; PointMap m_points; - int m_ticket; + int m_ticket = -1; }; #endif // BLACKBOX_H - diff --git a/sources/shiboken6/tests/libsample/bucket.cpp b/sources/shiboken6/tests/libsample/bucket.cpp index 01a1f591e..cafd382a9 100644 --- a/sources/shiboken6/tests/libsample/bucket.cpp +++ b/sources/shiboken6/tests/libsample/bucket.cpp @@ -2,23 +2,20 @@ // 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. -#include <windows.h> -#define SLEEP(x) Sleep(x) +# 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) +# include <unistd.h> +# define SLEEP(x) usleep(x) #endif - -using namespace std; - -Bucket::Bucket() : m_locked(false) -{ -} - void Bucket::push(int x) { m_data.push_back(x); @@ -28,7 +25,7 @@ int Bucket::pop(void) { int x = 0; - if (m_data.size() > 0) { + if (!m_data.empty()) { x = m_data.front(); m_data.pop_front(); } @@ -44,7 +41,9 @@ bool Bucket::empty() void Bucket::lock() { m_locked = true; - while (m_locked) { SLEEP(300); } + while (m_locked) { + SLEEP(300); + } } void Bucket::unlock() @@ -58,4 +57,3 @@ bool Bucket::virtualBlockerMethod() // 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 index 4a45802a4..73e8edd78 100644 --- a/sources/shiboken6/tests/libsample/bucket.h +++ b/sources/shiboken6/tests/libsample/bucket.h @@ -6,6 +6,7 @@ #include "libsamplemacros.h" #include "objecttype.h" + #include <list> class ObjectType; @@ -13,7 +14,7 @@ class ObjectType; class LIBSAMPLE_API Bucket : public ObjectType { public: - Bucket(); + Bucket() = default; void push(int); int pop(); bool empty(); @@ -27,8 +28,7 @@ public: private: std::list<int> m_data; - volatile bool m_locked; + volatile bool m_locked = false; }; #endif // BUCKET_H - diff --git a/sources/shiboken6/tests/libsample/bytearray.cpp b/sources/shiboken6/tests/libsample/bytearray.cpp index 40f1ebc84..78d5162b0 100644 --- a/sources/shiboken6/tests/libsample/bytearray.cpp +++ b/sources/shiboken6/tests/libsample/bytearray.cpp @@ -1,13 +1,14 @@ // 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 <cstring> #include "bytearray.h" -ByteArray::ByteArray() +#include <algorithm> +#include <iterator> +#include <cstring> + +ByteArray::ByteArray() : m_data(1, '\0') { - m_data = std::vector<char>(1); - m_data[0] = '\0'; } ByteArray::ByteArray(char c) @@ -17,48 +18,37 @@ ByteArray::ByteArray(char c) m_data[1] = '\0'; } -ByteArray::ByteArray(const char* data) +ByteArray::ByteArray(const char *data) { - size_t len = strlen(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) +ByteArray::ByteArray(const char *data, int len) { m_data = std::vector<char>(len + 1); memcpy(&m_data[0], data, len); m_data[len] = '\0'; } -ByteArray::ByteArray(const ByteArray& other) -{ - m_data = std::vector<char>(other.size() + 1); - memcpy(&m_data[0], &other.m_data[0], other.size()); - m_data[other.size()] = '\0'; -} - -int -ByteArray::size() const +int ByteArray::size() const { return m_data.size() - 1; } -char -ByteArray::at(int pos) const +char ByteArray::at(int pos) const { return m_data[pos]; } -const char* -ByteArray::data() const +const char *ByteArray::data() const { return &(m_data[0]); } -ByteArray& -ByteArray::append(char c) +ByteArray &ByteArray::append(char c) { m_data.pop_back(); m_data.push_back(c); @@ -66,37 +56,30 @@ ByteArray::append(char c) return *this; } -ByteArray& -ByteArray::append(const char* data) +ByteArray &ByteArray::append(const char *data) { m_data.pop_back(); - for (int i = 0; i < (int)strlen(data); ++i) - m_data.push_back(data[i]); + 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) +ByteArray &ByteArray::append(const char *data, int len) { m_data.pop_back(); - for (int i = 0; i < len; ++i) - m_data.push_back(data[i]); + std::copy(data, data + len, std::back_inserter(m_data)); m_data.push_back('\0'); return *this; } -ByteArray& -ByteArray::append(const ByteArray& other) +ByteArray &ByteArray::append(const ByteArray &other) { m_data.pop_back(); - for (int i = 0; i < (int)other.m_data.size(); ++i) - m_data.push_back(other.m_data[i]); - m_data.push_back('\0'); + 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) +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]) @@ -105,85 +88,79 @@ static bool compare(const std::vector<char>& mine, const char* other) return true; } -bool -ByteArray::operator==(const ByteArray& other) const +bool ByteArray::operator==(const ByteArray &other) const { - return compare(m_data, &other.m_data[0]); + return m_data == other.m_data; } -bool -operator==(const ByteArray& ba1, const char* ba2) +bool operator==(const ByteArray &ba1, const char *ba2) { return compare(ba1.m_data, ba2); } -bool -operator==(const char* ba1, const ByteArray& ba2) + +bool operator==(const char *ba1, const ByteArray &ba2) { return compare(ba2.m_data, ba1); } -bool -ByteArray::operator!=(const ByteArray& other) const +bool ByteArray::operator!=(const ByteArray &other) const { - return !(m_data == other.m_data); + return m_data != other.m_data; } -bool -operator!=(const ByteArray& ba1, const char* ba2) + +bool operator!=(const ByteArray &ba1, const char *ba2) { return !(ba1 == ba2); } -bool -operator!=(const char* ba1, const ByteArray& ba2) + +bool operator!=(const char *ba1, const ByteArray &ba2) { return !(ba1 == ba2); } -ByteArray& -ByteArray::operator+=(char c) +ByteArray &ByteArray::operator+=(char c) { return append(c); } -ByteArray& -ByteArray::operator+=(const char* data) + +ByteArray &ByteArray::operator+=(const char *data) { return append(data); } -ByteArray& -ByteArray::operator+=(const ByteArray& other) + +ByteArray &ByteArray::operator+=(const ByteArray &other) { return append(other); } -ByteArray -operator+(const ByteArray& ba1, const ByteArray& ba2) +ByteArray operator+(const ByteArray &ba1, const ByteArray &ba2) { return ByteArray(ba1) += ba2; } -ByteArray -operator+(const ByteArray& ba1, const char* ba2) + +ByteArray operator+(const ByteArray &ba1, const char *ba2) { return ByteArray(ba1) += ByteArray(ba2); } -ByteArray -operator+(const char* ba1, const ByteArray& ba2) + +ByteArray operator+(const char *ba1, const ByteArray &ba2) { return ByteArray(ba1) += ba2; } -ByteArray -operator+(const ByteArray& ba1, char ba2) + +ByteArray operator+(const ByteArray &ba1, char ba2) { return ByteArray(ba1) += ByteArray(ba2); } -ByteArray -operator+(char ba1, const ByteArray& ba2) + +ByteArray operator+(char ba1, const ByteArray &ba2) { return ByteArray(ba1) += ba2; } -unsigned int -ByteArray::hash(const ByteArray& byteArray) +unsigned int ByteArray::hash(const ByteArray &byteArray) { unsigned int result = 0; - for (int i = 0; i < (int)byteArray.m_data.size(); ++i) - result = 5 * result + byteArray.m_data[i]; + 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 index 3e5d4b100..35ff22367 100644 --- a/sources/shiboken6/tests/libsample/bytearray.h +++ b/sources/shiboken6/tests/libsample/bytearray.h @@ -6,59 +6,59 @@ #include "str.h" #include "libsamplemacros.h" + #include <vector> class LIBSAMPLE_API ByteArray { public: ByteArray(); - ByteArray(char data); - ByteArray(const char* data); - ByteArray(const char* data, int len); - ByteArray(const ByteArray& other); + 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; + 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); + 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; + 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); + ByteArray &operator+=(char c); + ByteArray &operator+=(const char *data); + ByteArray &operator+=(const ByteArray &other); - static unsigned int hash(const ByteArray& byteArray); + 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 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); + 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 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); +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 index 2adff6628..579239bcb 100644 --- a/sources/shiboken6/tests/libsample/collector.cpp +++ b/sources/shiboken6/tests/libsample/collector.cpp @@ -8,13 +8,13 @@ void Collector::clear() m_items.clear(); } -Collector& Collector::operator<<(ObjectType::Identifier item) +Collector &Collector::operator<<(ObjectType::Identifier item) { m_items.push_back(item); return *this; } -Collector& Collector::operator<<(const ObjectType *obj) +Collector &Collector::operator<<(const ObjectType *obj) { m_items.push_back(obj->identifier()); return *this; @@ -25,9 +25,9 @@ std::list<ObjectType::Identifier> Collector::items() return m_items; } -int Collector::size() +int Collector::size() const { - return (int) m_items.size(); + return int(m_items.size()); } Collector &operator<<(Collector &s, const IntWrapper &w) diff --git a/sources/shiboken6/tests/libsample/collector.h b/sources/shiboken6/tests/libsample/collector.h index 1ef3281e5..26766847a 100644 --- a/sources/shiboken6/tests/libsample/collector.h +++ b/sources/shiboken6/tests/libsample/collector.h @@ -4,36 +4,34 @@ #ifndef COLLECTOR_H #define COLLECTOR_H -#include <list> #include "libsamplemacros.h" - #include "intwrapper.h" #include "objecttype.h" +#include <list> + class LIBSAMPLE_API Collector { public: - Collector() {} - virtual ~Collector() {} + Collector() noexcept = default; + virtual ~Collector() = default; + LIBMINIMAL_DISABLE_COPY_MOVE(Collector) void clear(); - Collector& operator<<(ObjectType::Identifier item); + Collector &operator<<(ObjectType::Identifier item); - Collector& operator<<(const ObjectType *); + Collector &operator<<(const ObjectType *); std::list<ObjectType::Identifier> items(); - int size(); + int size() const; private: std::list<ObjectType::Identifier> m_items; - - Collector(const Collector&); - Collector& operator=(const Collector&); }; /* Helper for testing external operators */ -LIBSAMPLE_API Collector &operator<<(Collector&, const IntWrapper&); +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 index ce2c2b7de..e3bec9aae 100644 --- a/sources/shiboken6/tests/libsample/complex.cpp +++ b/sources/shiboken6/tests/libsample/complex.cpp @@ -1,18 +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 <iostream> #include "complex.h" -using namespace std; +#include <iostream> -Complex::Complex(double real, double imag) +Complex::Complex(double real, double imag) noexcept : m_real(real), m_imag(imag) { } -Complex -Complex::operator+(Complex& other) +Complex Complex::operator+(const Complex &other) { Complex result; result.setReal(m_real + other.real()); @@ -20,10 +18,7 @@ Complex::operator+(Complex& other) return result; } -void -Complex::show() +void Complex::show() const { - cout << "(real: " << m_real << ", imag: " << m_imag << ")"; + std::cout << "(real: " << m_real << ", imag: " << m_imag << ")"; } - - diff --git a/sources/shiboken6/tests/libsample/complex.h b/sources/shiboken6/tests/libsample/complex.h index 54fb99ed1..168fe5c44 100644 --- a/sources/shiboken6/tests/libsample/complex.h +++ b/sources/shiboken6/tests/libsample/complex.h @@ -9,17 +9,19 @@ class LIBSAMPLE_API Complex { public: - Complex(double real = 0.0, double imag = 0.0); - ~Complex() {} + 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+(Complex& other); + Complex operator+(const Complex &other); - void show(); + void show() const; private: double m_real; diff --git a/sources/shiboken6/tests/libsample/ctorconvrule.h b/sources/shiboken6/tests/libsample/ctorconvrule.h index cd7d1c669..a5411b749 100644 --- a/sources/shiboken6/tests/libsample/ctorconvrule.h +++ b/sources/shiboken6/tests/libsample/ctorconvrule.h @@ -9,8 +9,10 @@ class CtorConvRule { public: - explicit CtorConvRule(long value) : m_value(value) {} - virtual ~CtorConvRule() {} + 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: diff --git a/sources/shiboken6/tests/libsample/cvlist.h b/sources/shiboken6/tests/libsample/cvlist.h index eb635c83b..e09c7d943 100644 --- a/sources/shiboken6/tests/libsample/cvlist.h +++ b/sources/shiboken6/tests/libsample/cvlist.h @@ -12,7 +12,7 @@ class CVValueType CVValueType(); }; -typedef std::list<const CVValueType*> const_ptr_value_list; +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 @@ -21,8 +21,8 @@ typedef std::list<const CVValueType*> const_ptr_value_list; class CVListUser { public: - static const_ptr_value_list produce() { return const_ptr_value_list(); } - static void consume(const const_ptr_value_list& l) { (void)l; } + 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 index ad68d2614..d20880431 100644 --- a/sources/shiboken6/tests/libsample/derived.cpp +++ b/sources/shiboken6/tests/libsample/derived.cpp @@ -1,44 +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 <iostream> #include "derived.h" -using namespace std; +#include <iostream> -Derived::Derived(int id) : Abstract(id) +Derived::Derived(int id) noexcept : Abstract(id) { } -Derived::~Derived() -{ -} +Derived::~Derived() = default; -Abstract* -Derived::createObject() +Abstract *Derived::createObject() { static int id = 100; return new Derived(id++); } -void -Derived::pureVirtual() +void Derived::pureVirtual() { } -void* -Derived::pureVirtualReturningVoidPtr() +void *Derived::pureVirtualReturningVoidPtr() { return nullptr; } -void -Derived::unpureVirtual() +void Derived::unpureVirtual() { } -bool -Derived::singleArgument(bool b) +bool Derived::singleArgument(bool b) { return !b; } @@ -49,40 +41,36 @@ Derived::defaultValue(int n) return ((double) n) + 0.1; } -OverloadedFuncEnum -Derived::overloaded(int i, int d) +OverloadedFuncEnum Derived::overloaded(int, int) { return OverloadedFunc_ii; } -OverloadedFuncEnum -Derived::overloaded(double n) +OverloadedFuncEnum Derived::overloaded(double) { return OverloadedFunc_d; } -Derived::OtherOverloadedFuncEnum -Derived::otherOverloaded(int a, int b, bool c, double d) +Derived::OtherOverloadedFuncEnum Derived::otherOverloaded(int, int, bool, double) { return OtherOverloadedFunc_iibd; } -Derived::OtherOverloadedFuncEnum -Derived::otherOverloaded(int a, double b) +Derived::OtherOverloadedFuncEnum Derived::otherOverloaded(int, double) { return OtherOverloadedFunc_id; } struct SecretClass : public Abstract { - virtual void pureVirtual() {} - virtual void *pureVirtualReturningVoidPtr() { return nullptr; } - virtual PrintFormat returnAnEnum() { return Short; } - void hideFunction(HideType*){}; + void pureVirtual() override {} + void *pureVirtualReturningVoidPtr() override { return nullptr; } + PrintFormat returnAnEnum() override { return Short; } + void hideFunction(HideType*) override {}; private: - virtual void pureVirtualPrivate() {} + void pureVirtualPrivate() override {} }; -Abstract* Derived::triggerImpossibleTypeDiscovery() +Abstract *Derived::triggerImpossibleTypeDiscovery() { return new SecretClass; } @@ -90,7 +78,7 @@ Abstract* Derived::triggerImpossibleTypeDiscovery() struct AnotherSecretClass : public Derived { }; -Abstract* Derived::triggerAnotherImpossibleTypeDiscovery() +Abstract *Derived::triggerAnotherImpossibleTypeDiscovery() { return new AnotherSecretClass; } diff --git a/sources/shiboken6/tests/libsample/derived.h b/sources/shiboken6/tests/libsample/derived.h index 5d5010857..b7736c37a 100644 --- a/sources/shiboken6/tests/libsample/derived.h +++ b/sources/shiboken6/tests/libsample/derived.h @@ -15,6 +15,8 @@ enum OverloadedFuncEnum { class LIBSAMPLE_API Derived : public Abstract { public: + LIBMINIMAL_DISABLE_COPY_MOVE(Derived) + enum OtherOverloadedFuncEnum { OtherOverloadedFunc_iibd, OtherOverloadedFunc_id @@ -23,21 +25,21 @@ public: class SomeInnerClass { public: void uselessMethod() {} - SomeInnerClass operator+(const SomeInnerClass& other) { return other; } - bool operator==(const SomeInnerClass& other) { return true; } + SomeInnerClass operator+(const SomeInnerClass &other) { return other; } + bool operator==(const SomeInnerClass &) { return true; } }; - Derived(int id = -1); + explicit Derived(int id = -1) noexcept; ~Derived() override; void pureVirtual() override; - void* pureVirtualReturningVoidPtr() override; + void *pureVirtualReturningVoidPtr() override; void unpureVirtual() override; PrintFormat returnAnEnum() override { return Short; } Type type() const override { return TpDerived; } // factory method - static Abstract* createObject(); + static Abstract *createObject(); // single argument bool singleArgument(bool b); @@ -53,15 +55,15 @@ public: OtherOverloadedFuncEnum otherOverloaded(int a, int b, bool c, double d); OtherOverloadedFuncEnum otherOverloaded(int a, double b); - inline SomeInnerClass returnMyParameter(const SomeInnerClass& s) { return s; } + inline SomeInnerClass returnMyParameter(const SomeInnerClass &s) { return s; } - static Abstract* triggerImpossibleTypeDiscovery(); - static Abstract* triggerAnotherImpossibleTypeDiscovery(); + static Abstract *triggerImpossibleTypeDiscovery(); + static Abstract *triggerAnotherImpossibleTypeDiscovery(); void hideFunction(HideType*) override {} protected: - const char* getClassName() { return className(); } - virtual const char* className() override { return "Derived"; } + const char *getClassName() { return className(); } + virtual const char *className() const override { return "Derived"; } private: void pureVirtualPrivate() override; diff --git a/sources/shiboken6/tests/libsample/echo.h b/sources/shiboken6/tests/libsample/echo.h index 4a655fec1..01b11a4a6 100644 --- a/sources/shiboken6/tests/libsample/echo.h +++ b/sources/shiboken6/tests/libsample/echo.h @@ -12,19 +12,49 @@ class ObjectType; class Echo { public: - Echo(){} - ~Echo(){} + LIBMINIMAL_DEFAULT_COPY_MOVE(Echo) - void doNothingWithConstBool(const bool hi) {} - void methodWithNamedArg(const Str& string = Str("")) {} + Echo() noexcept = default; + ~Echo() = default; - Str operator()(const Str& s, const int i) { return s + i; } + 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) { return *this; } - Echo& operator<<(signed int item) { return *this; } - Echo& operator<<(const ObjectType* item) { return *this; } - Echo& operator<<(Str str) { return *this; } + Echo &operator<<(unsigned int item); + Echo &operator<<(signed int item); + Echo &operator<<(const ObjectType *item); + Echo &operator<<(Str str); }; -#endif +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 index 35da4e90b..56144e086 100644 --- a/sources/shiboken6/tests/libsample/exceptiontest.cpp +++ b/sources/shiboken6/tests/libsample/exceptiontest.cpp @@ -37,3 +37,10 @@ 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 index 4931fc2ed..b5812a090 100644 --- a/sources/shiboken6/tests/libsample/exceptiontest.h +++ b/sources/shiboken6/tests/libsample/exceptiontest.h @@ -18,6 +18,8 @@ class LIBSAMPLE_API ExceptionTest 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 index 21a51a288..6f3c5fdc5 100644 --- a/sources/shiboken6/tests/libsample/expression.cpp +++ b/sources/shiboken6/tests/libsample/expression.cpp @@ -3,112 +3,77 @@ #include "expression.h" -#include <sstream> - -Expression::Expression() : m_value(0), m_operation(None), m_operand1(nullptr), m_operand2(nullptr) -{ -} - -Expression::Expression(int number) : m_value(number), m_operation(None), m_operand1(nullptr), m_operand2(nullptr) -{ -} -Expression::Expression(const Expression& other) -{ - m_operand1 = other.m_operand1 ? new Expression(*other.m_operand1) : nullptr; - m_operand2 = other.m_operand2 ? new Expression(*other.m_operand2) : nullptr; - m_value = other.m_value; - m_operation = other.m_operation; -} +#include <sstream> -Expression& Expression::operator=(const Expression& other) -{ - if (&other == this) - return *this; - delete m_operand1; - delete m_operand2; - m_operand1 = other.m_operand1 ? new Expression(*other.m_operand1) : nullptr; - m_operand2 = other.m_operand2 ? new Expression(*other.m_operand2) : nullptr; - m_operation = other.m_operation; - m_value = other.m_value; - return *this; -} +Expression::Expression() noexcept = default; -Expression::~Expression() +Expression::Expression(int number) noexcept : m_value(number) { - delete m_operand1; - delete m_operand2; } -Expression Expression::operator+(const Expression& other) +Expression Expression::operator+(const Expression &other) { Expression expr; expr.m_operation = Add; - expr.m_operand1 = new Expression(*this); - expr.m_operand2 = new Expression(other); + 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 Expression::operator-(const Expression &other) { Expression expr; expr.m_operation = Add; - expr.m_operand1 = new Expression(*this); - expr.m_operand2 = new Expression(other); + 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 Expression::operator<(const Expression &other) { Expression expr; expr.m_operation = LessThan; - expr.m_operand1 = new Expression(*this); - expr.m_operand2 = new Expression(other); + 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 Expression::operator>(const Expression &other) { Expression expr; expr.m_operation = GreaterThan; - expr.m_operand1 = new Expression(*this); - expr.m_operand2 = new Expression(other); + 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) { - std::ostringstream s; s << m_value; return s.str(); } - std::string result; - result += '('; - result += m_operand1->toString(); - char op; + s << '(' << m_operand1->toString(); switch (m_operation) { case Add: - op = '+'; + s << '+'; break; case Sub: - op = '-'; + s << '-'; break; case LessThan: - op = '<'; + s << '<'; break; case GreaterThan: - op = '<'; + s << '<'; break; - case None: // just to avoid the compiler warning default: - op = '?'; + s << '?'; break; } - result += op; - result += m_operand2->toString(); - result += ')'; - return result; + s << m_operand2->toString() << ')'; + return s.str(); } - diff --git a/sources/shiboken6/tests/libsample/expression.h b/sources/shiboken6/tests/libsample/expression.h index cf41cb620..e7c5b7306 100644 --- a/sources/shiboken6/tests/libsample/expression.h +++ b/sources/shiboken6/tests/libsample/expression.h @@ -6,34 +6,35 @@ #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 }; - Expression(int number); - Expression(const Expression& other); - Expression& operator=(const Expression& other); - - ~Expression(); + 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); + 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; - Operation m_operation; - Expression* m_operand1; - Expression* m_operand2; + int m_value = 0; + Operation m_operation = None; + std::shared_ptr<Expression> m_operand1; + std::shared_ptr<Expression> m_operand2; - Expression(); + Expression() noexcept; }; #endif // EXPRESSION_H diff --git a/sources/shiboken6/tests/libsample/filter.cpp b/sources/shiboken6/tests/libsample/filter.cpp index 3f2ac70b0..950847985 100644 --- a/sources/shiboken6/tests/libsample/filter.cpp +++ b/sources/shiboken6/tests/libsample/filter.cpp @@ -1,44 +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 -#include <string> #include "filter.h" + Data::Data(Field field, std::string value) : m_field(field), m_value(value) { } -Union::Union(const Data& filter) +Union::Union(const Data &filter) { m_filters.push_back(filter); } -Union::Union(const Intersection& filter) +Union::Union(const Intersection &filter) { m_filters.push_back(filter); } -Union::Union(const Union& filter) -{ - m_filters = filter.filters(); -} - -Intersection::Intersection(const Data& filter) +Intersection::Intersection(const Data &filter) { m_filters.push_back(filter); } -Intersection::Intersection(const Union& filter) +Intersection::Intersection(const Union &filter) { m_filters.push_back(filter); } -Intersection::Intersection(const Intersection& filter) -{ - m_filters = filter.filters(); -} - -Intersection operator&(const Intersection& a, const Intersection& b) +Intersection operator&(const Intersection &a, const Intersection &b) { Intersection filter; filter.addFilter(a); diff --git a/sources/shiboken6/tests/libsample/filter.h b/sources/shiboken6/tests/libsample/filter.h index 266785ad7..d82d38eb8 100644 --- a/sources/shiboken6/tests/libsample/filter.h +++ b/sources/shiboken6/tests/libsample/filter.h @@ -4,11 +4,11 @@ #ifndef FILTER_H #define FILTER_H +#include "libsamplemacros.h" + #include <string> #include <list> -#include "libsamplemacros.h" - class Intersection; class LIBSAMPLE_API Filter @@ -17,7 +17,6 @@ class LIBSAMPLE_API Filter class LIBSAMPLE_API Data : public Filter { - public: enum Field { Name, @@ -25,7 +24,7 @@ public: Year }; - Data(Field field, std::string value); + explicit Data(Field field, std::string value); Field field() const { return m_field; } std::string value() const { return m_value; } @@ -39,13 +38,12 @@ class LIBSAMPLE_API Union : public Filter { public: - Union(const Data&); - Union(const Intersection&); - Union() {}; - Union(const Union&); + 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); } + void addFilter(const Filter &data) { m_filters.push_back(data); } private: std::list<Filter> m_filters; @@ -54,20 +52,18 @@ private: class LIBSAMPLE_API Intersection : public Filter { public: - - Intersection(const Data&); - Intersection(const Union&); - Intersection() {}; - Intersection(const Intersection&); + 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); } + 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); +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 index 7325aad3a..ad2f4dd5a 100644 --- a/sources/shiboken6/tests/libsample/functions.cpp +++ b/sources/shiboken6/tests/libsample/functions.cpp @@ -2,37 +2,33 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "functions.h" -#include <string.h> +#include "polygon.h" + +#include <cstring> #include <algorithm> #include <iostream> #include <numeric> -using namespace std; - -void -printSomething() +void printSomething() { - cout << __FUNCTION__ << endl; + std::cout << __FUNCTION__ << std::endl; } -int -gimmeInt() +int gimmeInt() { static int val = 2; val = val * 1.3; return val; } -double -gimmeDouble() +double gimmeDouble() { static double val = 7.77; val = val * 1.3; return val; } -std::list<Complex> -gimmeComplexList() +std::list<Complex> gimmeComplexList() { std::list<Complex> lst; lst.push_back(Complex()); @@ -41,135 +37,114 @@ gimmeComplexList() return lst; } -Complex -sumComplexPair(std::pair<Complex, Complex> cpx_pair) +Complex sumComplexPair(std::pair<Complex, Complex> cpx_pair) { return cpx_pair.first + cpx_pair.second; } -double -multiplyPair(std::pair<double, double> pair) +double multiplyPair(std::pair<double, double> pair) { return pair.first * pair.second; } -int -countCharacters(const char* text) +int countCharacters(const char *text) { - if (!text) - return -1; - int count; - for(count = 0; text[count] != '\0'; count++) - ; - return count; + return text != nullptr ? int(std::strlen(text)) : -1; } -char* -makeCString() +char *makeCString() { - char* string = new char[strlen(__FUNCTION__) + 1]; - strcpy(string, __FUNCTION__); + char *string = new char[std::strlen(__FUNCTION__) + 1]; + std::strcpy(string, __FUNCTION__); return string; } -const char* -returnCString() +const char *returnCString() { return __FUNCTION__; } -GlobalOverloadFuncEnum -overloadedFunc(int val) +GlobalOverloadFuncEnum overloadedFunc(int) { return GlobalOverloadFunc_i; } -GlobalOverloadFuncEnum -overloadedFunc(double val) +GlobalOverloadFuncEnum overloadedFunc(double) { return GlobalOverloadFunc_d; } -char* -returnNullPrimitivePointer() +char *returnNullPrimitivePointer() { return nullptr; } -ObjectType* -returnNullObjectTypePointer() +ObjectType *returnNullObjectTypePointer() { return nullptr; } -Event* -returnNullValueTypePointer() +Event *returnNullValueTypePointer() { return nullptr; } -unsigned int -doubleUnsignedInt(unsigned int value) +unsigned int doubleUnsignedInt(unsigned int value) { return value * 2; } -long long -doubleLongLong(long long value) +long long doubleLongLong(long long value) { return value * 2; } -unsigned long long -doubleUnsignedLongLong(unsigned long long value) +unsigned long long doubleUnsignedLongLong(unsigned long long value) { return value * 2; } -short -doubleShort(short value) +short doubleShort(short value) { return value * 2; } -int -acceptInt(int x) +int acceptInt(int x) { return x; } -unsigned int -acceptUInt(unsigned int x) +const int *acceptIntReturnPtr(int x) +{ + return new int(x); +} + +unsigned int acceptUInt(unsigned int x) { return x; } -long -acceptLong(long x) +long acceptLong(long x) { return x; } -unsigned long -acceptULong(unsigned long x) +unsigned long acceptULong(unsigned long x) { return x; } -double -acceptDouble(double x) +double acceptDouble(double x) { return x; } -int -acceptIntReference(int& x) +int acceptIntReference(int &x) { return x; } -OddBool -acceptOddBoolReference(OddBool& x) +OddBool acceptOddBoolReference(OddBool &x) { return x; } @@ -204,9 +179,7 @@ double sumDoubleMatrix(double m[2][3]) return result; } -ArrayModifyTest::ArrayModifyTest() -{ -} +ArrayModifyTest::ArrayModifyTest() = default; int ArrayModifyTest::sumIntArray(int n, int *array) { @@ -229,7 +202,7 @@ void ClassWithFunctionPointer::doNothing(void *operand) (void) operand; } -string addStdStrings(const std::string &s1, const std::string &s2) +std::string addStdStrings(const std::string &s1, const std::string &s2) { return s1 + s2; } @@ -241,5 +214,19 @@ std::wstring addStdWStrings(const std::wstring &s1, const std::wstring &s2) void testNullPtrT(std::nullptr_t) { - cout << __FUNCTION__ << '\n'; + 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 index 7492ec4c2..b745aed6b 100644 --- a/sources/shiboken6/tests/libsample/functions.h +++ b/sources/shiboken6/tests/libsample/functions.h @@ -5,12 +5,15 @@ #define FUNCTIONS_H #include "libsamplemacros.h" -#include <list> -#include <utility> #include "oddbool.h" #include "complex.h" #include "objecttype.h" +#include <list> +#include <utility> + +class Polygon; + enum GlobalEnum { NoThing, FirstThing, @@ -30,13 +33,13 @@ 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 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(); +LIBSAMPLE_API char *returnNullPrimitivePointer(); +LIBSAMPLE_API ObjectType *returnNullObjectTypePointer(); +LIBSAMPLE_API Event *returnNullValueTypePointer(); // Tests overloading on functions (!methods) LIBSAMPLE_API GlobalOverloadFuncEnum overloadedFunc(int val); @@ -48,13 +51,14 @@ 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 acceptIntReference(int &x); +LIBSAMPLE_API OddBool acceptOddBoolReference(OddBool &x); LIBSAMPLE_API int sumIntArray(int array[4]); LIBSAMPLE_API double sumDoubleArray(double array[4]); @@ -66,6 +70,9 @@ LIBSAMPLE_API std::wstring addStdWStrings(const std::wstring &s1, const std::wst LIBSAMPLE_API void testNullPtrT(std::nullptr_t); +LIBSAMPLE_API int takePolygon(Polygon &&p); +LIBSAMPLE_API int takeObjectType(ObjectType &&o); + class LIBSAMPLE_API ArrayModifyTest { public: diff --git a/sources/shiboken6/tests/libsample/handle.cpp b/sources/shiboken6/tests/libsample/handle.cpp index e92c24c89..93c2abe47 100644 --- a/sources/shiboken6/tests/libsample/handle.cpp +++ b/sources/shiboken6/tests/libsample/handle.cpp @@ -3,17 +3,17 @@ #include "handle.h" -HANDLE HandleHolder::createHandle() +SAMPLE_HANDLE HandleHolder::createHandle() { - return (HANDLE) new OBJ; + return (SAMPLE_HANDLE) new OBJ; } -bool HandleHolder::compare(HandleHolder* other) +bool HandleHolder::compare(HandleHolder *other) { return other->m_handle == m_handle; } -bool HandleHolder::compare2(HandleHolder* other) +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 index d54dd9f11..07fc89d15 100644 --- a/sources/shiboken6/tests/libsample/handle.h +++ b/sources/shiboken6/tests/libsample/handle.h @@ -8,35 +8,41 @@ /* See http://bugs.pyside.org/show_bug.cgi?id=1105. */ namespace Foo { - using HANDLE = unsigned long; + using SAMPLE_HANDLE = unsigned long; } class LIBSAMPLE_API OBJ { }; -using HANDLE = OBJ *; +using SAMPLE_HANDLE = OBJ *; class LIBSAMPLE_API HandleHolder { public: - explicit HandleHolder(HANDLE ptr = nullptr) : m_handle(ptr) {} - explicit HandleHolder(Foo::HANDLE val): m_handle2(val) {} + explicit HandleHolder(SAMPLE_HANDLE ptr = nullptr) : m_handle(ptr) {} + explicit HandleHolder(Foo::SAMPLE_HANDLE val): m_handle2(val) {} - inline void set(HANDLE ptr) { HANDLE tmp; tmp = m_handle; m_handle = tmp; } - inline void set(const Foo::HANDLE& val) { m_handle2 = val; } - inline HANDLE handle() { return m_handle; } - inline Foo::HANDLE handle2() { return m_handle2; } + 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 HANDLE createHandle(); - bool compare(HandleHolder* other); - bool compare2(HandleHolder* other); + static SAMPLE_HANDLE createHandle(); + bool compare(HandleHolder *other); + bool compare2(HandleHolder *other); private: - HANDLE m_handle; - Foo::HANDLE m_handle2; + 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 diff --git a/sources/shiboken6/tests/libsample/implicitconv.cpp b/sources/shiboken6/tests/libsample/implicitconv.cpp index 054aa4b75..887fa6b1c 100644 --- a/sources/shiboken6/tests/libsample/implicitconv.cpp +++ b/sources/shiboken6/tests/libsample/implicitconv.cpp @@ -3,39 +3,37 @@ #include "implicitconv.h" -ImplicitConv -ImplicitConv::implicitConvCommon(ImplicitConv implicit) +ImplicitConv::ImplicitConv(const Null &) : + m_ctorEnum(CtorPrimitiveType) +{ +} + +ImplicitConv ImplicitConv::implicitConvCommon(ImplicitConv implicit) { return implicit; } -ImplicitConv -ImplicitConv::implicitConvDefault(ImplicitConv implicit) +ImplicitConv ImplicitConv::implicitConvDefault(ImplicitConv implicit) { return implicit; } -ImplicitConv::ICOverloadedFuncEnum -ImplicitConv::implicitConvOverloading(ImplicitConv implicit, int dummyArg) +ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(ImplicitConv, int) { return ImplicitConv::OverFunc_Ii; } -ImplicitConv::ICOverloadedFuncEnum -ImplicitConv::implicitConvOverloading(ImplicitConv implicit, bool dummyArg) +ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(ImplicitConv, bool) { return ImplicitConv::OverFunc_Ib; } -ImplicitConv::ICOverloadedFuncEnum -ImplicitConv::implicitConvOverloading(int dummyArg) +ImplicitConv::ICOverloadedFuncEnum ImplicitConv::implicitConvOverloading(int) { return ImplicitConv::OverFunc_i; } -ImplicitConv::ICOverloadedFuncEnum -ImplicitConv::implicitConvOverloading(CtorEnum dummyArg) +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 index aafd919b9..5d69eb487 100644 --- a/sources/shiboken6/tests/libsample/implicitconv.h +++ b/sources/shiboken6/tests/libsample/implicitconv.h @@ -12,6 +12,8 @@ class ObjectType; class LIBSAMPLE_API ImplicitConv { public: + LIBMINIMAL_DEFAULT_COPY_MOVE(ImplicitConv) + enum CtorEnum { CtorNone, CtorOne, @@ -28,17 +30,17 @@ public: OverFunc_C }; - ImplicitConv() : m_ctorEnum(CtorNone), m_objId(-1), m_value(-1.0) {} - ImplicitConv(int objId) : m_ctorEnum(CtorOne), m_objId(objId), m_value(-1.0) {} - ImplicitConv(CtorEnum ctorEnum) : m_ctorEnum(ctorEnum), m_objId(-1), m_value(-1.0) {} - ImplicitConv(ObjectType&) : m_ctorEnum(CtorObjectTypeReference), m_objId(-1), m_value(-1.0) {} + 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) : m_ctorEnum(CtorPrimitiveType) {} - ~ImplicitConv() {} + ImplicitConv(const Null &null); + ~ImplicitConv() = default; - inline CtorEnum ctorEnum() { return m_ctorEnum; } - inline int objId() { return m_objId; } - inline double value() { return m_value; } + 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); @@ -50,9 +52,9 @@ public: static ICOverloadedFuncEnum implicitConvOverloading(CtorEnum dummyArg); private: - CtorEnum m_ctorEnum; - int m_objId; - double m_value; + 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 index 488f7faae..707d14ed8 100644 --- a/sources/shiboken6/tests/libsample/injectcode.cpp +++ b/sources/shiboken6/tests/libsample/injectcode.cpp @@ -2,20 +2,15 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "injectcode.h" -#include <sstream> -using namespace std; +#include <sstream> -InjectCode::InjectCode() -{ -} +InjectCode::InjectCode() noexcept = default; -InjectCode::~InjectCode() -{ -} +InjectCode::~InjectCode() = default; template<typename T> -const char* InjectCode::toStr(const T& value) +const char *InjectCode::toStr(const T &value) { std::ostringstream s; s << value; @@ -23,41 +18,41 @@ const char* InjectCode::toStr(const T& value) return m_valueHolder.c_str(); } -const char* InjectCode::simpleMethod1(int arg0, int arg1) +const char *InjectCode::simpleMethod1(int arg0, int arg1) { return toStr(arg0 + arg1); } -const char* InjectCode::simpleMethod2() +const char *InjectCode::simpleMethod2() { return "_"; } -const char* InjectCode::simpleMethod3(int argc, char** argv) +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) +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) +const char *InjectCode::overloadedMethod(int arg0, double arg1) { return toStr(arg0 + arg1); } -const char* InjectCode::overloadedMethod(int argc, char** argv) +const char *InjectCode::overloadedMethod(int argc, char **argv) { return simpleMethod3(argc, argv); } -const char* InjectCode::virtualMethod(int arg) +const char *InjectCode::virtualMethod(int arg) { return toStr(arg); } @@ -70,13 +65,13 @@ int InjectCode::arrayMethod(int count, int *values) const return ret; } -int InjectCode::sumArrayAndLength(int* values) const +int InjectCode::sumArrayAndLength(int *values) const { int sum = 0; - while(*values) { + while (*values) { sum = sum + *values + 1; - values++; + ++values; } return sum; diff --git a/sources/shiboken6/tests/libsample/injectcode.h b/sources/shiboken6/tests/libsample/injectcode.h index 43a3e8468..74046dad5 100644 --- a/sources/shiboken6/tests/libsample/injectcode.h +++ b/sources/shiboken6/tests/libsample/injectcode.h @@ -5,27 +5,31 @@ #define INJECTCODE_H #include "libsamplemacros.h" + #include <utility> #include <string> class LIBSAMPLE_API InjectCode { public: - InjectCode(); + 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 *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); + 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; + 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; + 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 @@ -33,7 +37,7 @@ private: std::string m_valueHolder; template<typename T> - const char* toStr(const T& value); + const char *toStr(const T &value); }; #endif // INJECTCODE_H diff --git a/sources/shiboken6/tests/libsample/list.h b/sources/shiboken6/tests/libsample/list.h index 59a46960e..5e06d2a66 100644 --- a/sources/shiboken6/tests/libsample/list.h +++ b/sources/shiboken6/tests/libsample/list.h @@ -18,6 +18,8 @@ class List : public std::list<T> class IntList : public List<int> { public: + LIBMINIMAL_DEFAULT_MOVE(IntList) + enum CtorEnum { NoParamsCtor, IntCtor, @@ -25,10 +27,13 @@ public: ListOfIntCtor }; - inline IntList() : m_ctorUsed(NoParamsCtor) {} + inline IntList() noexcept : m_ctorUsed(NoParamsCtor) {} inline explicit IntList(int val) : m_ctorUsed(IntCtor) { push_back(val); } - inline IntList(const IntList& lst) : List<int>(lst), m_ctorUsed(CopyCtor) {} - inline IntList(const List<int>& lst) : List<int>(lst), m_ctorUsed(ListOfIntCtor) {} + 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; } @@ -39,6 +44,8 @@ private: class PointValueList : public List<Point> { public: + LIBMINIMAL_DEFAULT_MOVE(PointValueList) + enum CtorEnum { NoParamsCtor, PointCtor, @@ -46,10 +53,13 @@ public: ListOfPointValuesCtor }; - inline PointValueList() : m_ctorUsed(NoParamsCtor) {} + inline PointValueList() noexcept : m_ctorUsed(NoParamsCtor) {} inline explicit PointValueList(Point val) : m_ctorUsed(PointCtor) { push_back(val); } - inline PointValueList(const PointValueList& lst) : List<Point>(lst), m_ctorUsed(CopyCtor) {} - inline PointValueList(const List<Point>& lst) : List<Point>(lst), m_ctorUsed(ListOfPointValuesCtor) {} + 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; } @@ -60,6 +70,8 @@ private: class ObjectTypePtrList : public List<ObjectType*> { public: + LIBMINIMAL_DEFAULT_MOVE(ObjectTypePtrList) + enum CtorEnum { NoParamsCtor, ObjectTypeCtor, @@ -67,15 +79,21 @@ public: ListOfObjectTypePtrCtor }; - inline ObjectTypePtrList() : m_ctorUsed(NoParamsCtor) {} - inline explicit ObjectTypePtrList(ObjectType* val) : m_ctorUsed(ObjectTypeCtor) { push_back(val); } - inline ObjectTypePtrList(const ObjectTypePtrList& lst) : List<ObjectType*>(lst), m_ctorUsed(CopyCtor) {} - inline ObjectTypePtrList(const List<ObjectType*>& lst) : List<ObjectType*>(lst), m_ctorUsed(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); } + inline void append(ObjectType *v) { insert(end(), v); } CtorEnum constructorUsed() { return m_ctorUsed; } private: - CtorEnum m_ctorUsed; + CtorEnum m_ctorUsed = NoParamsCtor; }; #endif // LIST_H diff --git a/sources/shiboken6/tests/libsample/listuser.cpp b/sources/shiboken6/tests/libsample/listuser.cpp index f68b82b5a..9bb7f7798 100644 --- a/sources/shiboken6/tests/libsample/listuser.cpp +++ b/sources/shiboken6/tests/libsample/listuser.cpp @@ -1,20 +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 <numeric> -#include <cstdlib> #include "listuser.h" -using namespace std; +#include <numeric> +#include <cstdlib> -std::list<int> -ListUser::callCreateList() +std::list<int> ListUser::callCreateList() { return createList(); } -std::list<int> -ListUser::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++) @@ -22,8 +26,7 @@ ListUser::createList() return retval; } -std::list<Complex> -ListUser::createComplexList(Complex cpx0, Complex cpx1) +std::list<Complex> ListUser::createComplexList(Complex cpx0, Complex cpx1) { std::list<Complex> retval; retval.push_back(cpx0); @@ -31,36 +34,30 @@ ListUser::createComplexList(Complex cpx0, Complex cpx1) return retval; } -double -ListUser::sumList(std::list<int> vallist) +double ListUser::sumList(std::list<int> vallist) { return std::accumulate(vallist.begin(), vallist.end(), 0.0); } -double -ListUser::sumList(std::list<double> vallist) +double ListUser::sumList(std::list<double> vallist) { return std::accumulate(vallist.begin(), vallist.end(), 0.0); } -ListUser::ListOfSomething -ListUser::listOfPoints(const std::list<Point>& pointlist) +ListUser::ListOfSomething ListUser::listOfPoints(const std::list<Point> &) { return ListOfPoint; } -ListUser::ListOfSomething -ListUser::listOfPoints(const std::list<PointF>& pointlist) +ListUser::ListOfSomething ListUser::listOfPoints(const std::list<PointF> &) { return ListOfPointF; } -void -ListUser::multiplyPointList(PointList& points, double multiplier) +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 index 0f564f0e5..96781ed16 100644 --- a/sources/shiboken6/tests/libsample/listuser.h +++ b/sources/shiboken6/tests/libsample/listuser.h @@ -4,13 +4,14 @@ #ifndef LISTUSER_H #define LISTUSER_H -#include <list> #include "complex.h" #include "point.h" #include "pointf.h" #include "libsamplemacros.h" +#include <list> + class LIBSAMPLE_API ListUser { public: @@ -21,9 +22,12 @@ public: ListOfPointF }; - ListUser() {} - ListUser(const ListUser& other) : m_lst(other.m_lst) {} - virtual ~ListUser() {} + 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(); @@ -33,13 +37,13 @@ public: 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 ListOfSomething listOfPoints(const std::list<Point> &pointlist); + static ListOfSomething listOfPoints(const std::list<PointF> &pointlist); - static void multiplyPointList(PointList& points, double multiplier); + static void multiplyPointList(PointList &points, double multiplier); inline void setList(std::list<int> lst) { m_lst = lst; } - inline std::list<int> getList() { return m_lst; } + inline std::list<int> getList() const { return m_lst; } private: std::list<int> m_lst; diff --git a/sources/shiboken6/tests/libsample/main.cpp b/sources/shiboken6/tests/libsample/main.cpp index 9d62e753b..1b44642ae 100644 --- a/sources/shiboken6/tests/libsample/main.cpp +++ b/sources/shiboken6/tests/libsample/main.cpp @@ -12,207 +12,197 @@ #include "listuser.h" #include "samplenamespace.h" -using namespace std; - int main(int argv, char **argc) { - cout << endl; + std::cout << std::endl; Derived derived; - cout << endl; + std::cout << std::endl; derived.unpureVirtual(); derived.pureVirtual(); derived.callPureVirtual(); - cout << endl; - Abstract* abs; - abs = Abstract::createObject(); - cout << "Abstract::createObject(): " << abs << endl << endl; + std::cout << std::endl; + auto *abs = Abstract::createObject(); + std::cout << "Abstract::createObject(): " << abs << std::endl << std::endl; delete abs; abs = Derived::createObject(); - cout << "Derived::createObject() : "; + std::cout << "Derived::createObject() : "; abs->show(); - cout << endl; + std::cout << std::endl; delete abs; - cout << endl; + std::cout << std::endl; abs = Derived::createObject(); - cout << "Derived::createObject() : "; + std::cout << "Derived::createObject() : "; abs->show(); - cout << endl; + std::cout << std::endl; delete abs; - cout << endl; + std::cout << std::endl; - cout << endl << "-----------------------------------------" << endl; + std::cout << "\n-----------------------------------------\n"; KinderGarten kg; - Derived* d[] = { 0, 0, 0 }; + Derived *d[] = { 0, 0, 0 }; for (int i = 0; i < 3; i++) { d[i] = new Derived(i); d[i]->show(); - cout << endl; + std::cout << std::endl; kg.addChild(d[i]); } kg.show(); - cout << endl; + std::cout << std::endl; - cout << endl << "* kill child "; + std::cout << "\n* kill child "; d[2]->show(); - cout << " ----------------" << endl; + std::cout << " ----------------\n"; kg.killChild(d[2]); kg.show(); - cout << endl; + std::cout << std::endl; - cout << endl << "* release child "; + std::cout << "\n* release child "; d[1]->show(); - cout << " -------------" << endl; - Abstract* released = kg.releaseChild(d[1]); - cout << "released: "; + std::cout << " -------------\n"; + Abstract *released = kg.releaseChild(d[1]); + std::cout << "released: "; released->show(); - cout << endl; + std::cout << std::endl; kg.show(); - cout << endl; - - cout << endl << "* kill children ------------------------------------" << endl; + std::cout << "\n\n* kill children ------------------------------------\n"; kg.killChildren(); kg.show(); - cout << endl << endl; - - cout << "-----------------------------------------" << endl; + std::cout << "\n\n-----------------------------------------\n"; ListUser lu; - cout << "ListUser::createList()" << endl; + std::cout << "ListUser::createList()\n"; std::list<int> intlist = lu.createList(); - for (std::list<int>::iterator it = intlist.begin(); it != intlist.end(); it++) { - cout << "* " << *it << endl; - } + for (std::list<int>::iterator it = intlist.begin(); it != intlist.end(); it++) + std::cout << "* " << *it << std::endl; - cout << "ListUser::createComplexList" << 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++) { - cout << "* "; + std::cout << "* "; (*it).show(); - cout << endl; + std::cout << std::endl; } - cout << endl; - - cout << "-----------------------------------------" << endl; - cout << "SampleNamespace" << endl; - - cout << "SampleNamespace::RandomNumber: "; - cout << SampleNamespace::getNumber(SampleNamespace::RandomNumber); - cout << endl; - cout << "SampleNamespace::UnixTime: "; - cout << SampleNamespace::getNumber(SampleNamespace::UnixTime); - cout << endl; + 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; - cout << "SampleNamespace::powerOfTwo(" << val_d << "): "; - cout << SampleNamespace::powerOfTwo(val_d) << endl; + std::cout << "SampleNamespace::powerOfTwo(" << val_d << "): "; + std::cout << SampleNamespace::powerOfTwo(val_d) << std::endl; int val_i = 7; - cout << "SampleNamespace::powerOfTwo(" << val_i << "): "; - cout << SampleNamespace::powerOfTwo(val_i) << endl; - cout << endl; + std::cout << "SampleNamespace::powerOfTwo(" << val_i << "): "; + std::cout << SampleNamespace::powerOfTwo(val_i) << std::endl; + std::cout << std::endl; - cout << "-----------------------------------------" << endl; - cout << "Point" << endl; + std::cout << "-----------------------------------------" << std::endl; + std::cout << "Point" << std::endl; Point p1(1.1, 2.2); - cout << "p1: "; + std::cout << "p1: "; p1.show(); - cout << endl; + std::cout << std::endl; Point p2(3.4, 5.6); - cout << "p2: "; + std::cout << "p2: "; p2.show(); - cout << endl; + std::cout << std::endl; - cout << "p1 + p2 == "; + std::cout << "p1 + p2 == "; (p1 + p2).show(); - cout << endl; + std::cout << std::endl; - cout << "p1 * 2.0 == "; + std::cout << "p1 * 2.0 == "; (p1 * 2.0).show(); - cout << endl; + std::cout << std::endl; - cout << "1.5 * p2 == "; + std::cout << "1.5 * p2 == "; (1.5 * p2).show(); - cout << endl; + std::cout << std::endl; - cout << "p1: "; + std::cout << "p1: "; p1.show(); - cout << endl << "p2: "; + std::cout << std::endl << "p2: "; p2.show(); - cout << endl << "p1 += p2" << endl; + std::cout << std::endl << "p1 += p2" << std::endl; p1 += p2; - cout << "p1: "; + std::cout << "p1: "; p1.show(); - cout << endl; + std::cout << std::endl; - cout << "p1 == p2 ? " << ((p1 == p2) ? "true" : "false") << endl; - cout << "p1 == p1 ? " << ((p1 == p1) ? "true" : "false") << endl; - cout << "p2 == p2 ? " << ((p2 == p2) ? "true" : "false") << endl; + 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; - cout << "-----------------------------------------" << endl; - cout << "Size" << endl; + std::cout << "-----------------------------------------" << std::endl; + std::cout << "Size" << std::endl; Size s1(2, 2); - cout << "s1: "; + std::cout << "s1: "; s1.show(); - cout << ", area: " << s1.calculateArea(); - cout << endl; + std::cout << ", area: " << s1.calculateArea(); + std::cout << std::endl; Size s2(3, 5); - cout << "s2: "; + std::cout << "s2: "; s2.show(); - cout << ", area: " << s2.calculateArea(); - cout << endl; - - cout << endl; - - cout << "s1 == s2 ? " << ((s1 == s2) ? "true" : "false") << endl; - cout << "s1 != s2 ? " << ((s1 != s2) ? "true" : "false") << endl; - - cout << "s1 < s2 ? " << ((s1 < s2) ? "true" : "false") << endl; - cout << "s1 <= s2 ? " << ((s1 <= s2) ? "true" : "false") << endl; - cout << "s1 > s2 ? " << ((s1 > s2) ? "true" : "false") << endl; - cout << "s1 >= s2 ? " << ((s1 >= s2) ? "true" : "false") << endl; - - cout << "s1 < 10 ? " << ((s1 < 10) ? "true" : "false") << endl; - cout << "s1 <= 10 ? " << ((s1 <= 10) ? "true" : "false") << endl; - cout << "s1 > 10 ? " << ((s1 > 10) ? "true" : "false") << endl; - cout << "s1 >= 10 ? " << ((s1 >= 10) ? "true" : "false") << endl; - cout << "s2 < 10 ? " << ((s2 < 10) ? "true" : "false") << endl; - cout << "s2 <= 10 ? " << ((s2 <= 10) ? "true" : "false") << endl; - cout << "s2 > 10 ? " << ((s2 > 10) ? "true" : "false") << endl; - cout << "s2 >= 10 ? " << ((s2 >= 10) ? "true" : "false") << endl; - cout << endl; - - cout << "s1: "; + 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(); - cout << endl << "s2: "; + std::cout << std::endl << "s2: "; s2.show(); - cout << endl << "s1 += s2" << endl; + std::cout << std::endl << "s1 += s2" << std::endl; s1 += s2; - cout << "s1: "; + std::cout << "s1: "; s1.show(); - cout << endl; + std::cout << std::endl; - cout << endl; + std::cout << std::endl; - cout << "s1: "; + std::cout << "s1: "; s1.show(); - cout << endl << "s1 *= 2.0" << endl; + std::cout << std::endl << "s1 *= 2.0" << std::endl; s1 *= 2.0; - cout << "s1: "; + std::cout << "s1: "; s1.show(); - cout << endl; + std::cout << std::endl; - cout << endl; + std::cout << std::endl; return 0; } diff --git a/sources/shiboken6/tests/libsample/mapuser.cpp b/sources/shiboken6/tests/libsample/mapuser.cpp index de96fb40e..40059bbcd 100644 --- a/sources/shiboken6/tests/libsample/mapuser.cpp +++ b/sources/shiboken6/tests/libsample/mapuser.cpp @@ -1,44 +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 -#include <iostream> #include "mapuser.h" -using namespace std; +#include <iostream> -std::map<std::string, std::pair<Complex, int> > -MapUser::callCreateMap() +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> > MapUser::createMap() { std::map<std::string, std::pair<Complex, int> > retval; - std::pair<std::string, std::pair<Complex, int> > - item0("zero", std::pair<Complex, int>(Complex(1.2, 3.4), 2)); - retval.insert(item0); + std::pair<Complex, int> value{Complex(1.2, 3.4), 2}; + retval.insert({"zero", value}); - std::pair<std::string, std::pair<Complex, int> > - item1("one", std::pair<Complex, int>(Complex(5.6, 7.8), 3)); - retval.insert(item1); + value = {Complex(5.6, 7.8), 3}; + retval.insert({"one", value}); - std::pair<std::string, std::pair<Complex, int> > - item2("two", std::pair<Complex, int>(Complex(9.1, 2.3), 5)); - retval.insert(item2); + value = {Complex(9.1, 2.3), 5}; + retval.insert({"two", value}); return retval; } -void -MapUser::showMap(std::map<std::string, int> mapping) +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> &) { - cout << __FUNCTION__ << endl; - for (auto it = mapping.begin(), end = mapping.end(); it != end; ++it) - cout << (*it).first << " => " << (*it).second << endl; } std::map<int, std::list<std::list<double> > > MapUser::foo() const diff --git a/sources/shiboken6/tests/libsample/mapuser.h b/sources/shiboken6/tests/libsample/mapuser.h index 93cbd0f1e..1677a4bfb 100644 --- a/sources/shiboken6/tests/libsample/mapuser.h +++ b/sources/shiboken6/tests/libsample/mapuser.h @@ -4,20 +4,23 @@ #ifndef MAPUSER_H #define MAPUSER_H +#include "libsamplemacros.h" + +#include "complex.h" +#include "bytearray.h" + #include <map> #include <list> #include <utility> #include <string> -#include "complex.h" -#include "bytearray.h" - -#include "libsamplemacros.h" class LIBSAMPLE_API MapUser { public: - MapUser() {} - virtual ~MapUser() {} + 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(); @@ -28,10 +31,10 @@ public: 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) {} + 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; } + 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; diff --git a/sources/shiboken6/tests/libsample/modelindex.h b/sources/shiboken6/tests/libsample/modelindex.h index 21980c887..48e1b7de3 100644 --- a/sources/shiboken6/tests/libsample/modelindex.h +++ b/sources/shiboken6/tests/libsample/modelindex.h @@ -4,29 +4,30 @@ #ifndef MODELINDEX_H #define MODELINDEX_H -#include "libsamplemacros.h" - class ModelIndex { public: - ModelIndex() : m_value(0) {} - ModelIndex(const ModelIndex& other) { m_value = other.m_value; } + 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(); } + static int getValue(const ModelIndex &index) { return index.value(); } + private: - int m_value; + int m_value = 0; }; class ReferentModelIndex { public: - ReferentModelIndex() {} - ReferentModelIndex(const ModelIndex& index) : m_index(index) {} - ReferentModelIndex(const ReferentModelIndex& other) { m_index = other.m_index; } + 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; }; @@ -34,14 +35,16 @@ private: class PersistentModelIndex { public: - PersistentModelIndex() {} - PersistentModelIndex(const ModelIndex& index) : m_index(index) {} - PersistentModelIndex(const PersistentModelIndex& other) { m_index = other.m_index; } + 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 +#endif // MODELINDEX_H diff --git a/sources/shiboken6/tests/libsample/modifications.cpp b/sources/shiboken6/tests/libsample/modifications.cpp index 69481443e..6d627c4c1 100644 --- a/sources/shiboken6/tests/libsample/modifications.cpp +++ b/sources/shiboken6/tests/libsample/modifications.cpp @@ -1,15 +1,14 @@ // 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 "modifications.h" #include "objecttype.h" -using namespace std; +#include <iostream> Modifications::Modifications() + : m_object(new ObjectType()) { - m_object = new ObjectType(); m_object->setObjectName("MyObject"); } @@ -18,30 +17,87 @@ Modifications::~Modifications() delete m_object; } -std::pair<double, double> -Modifications::pointToPair(Point pt, bool* ok) +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 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) +int Modifications::doublePlus(int value, int plus) { return (2 * value) + plus; } -int -Modifications::power(int base, int exponent) +int Modifications::power(int base, int exponent) { if (exponent == 0) return 1; @@ -51,38 +107,32 @@ Modifications::power(int base, int exponent) return retval; } -int -Modifications::timesTen(int number) +int Modifications::timesTen(int number) { return number * 10; } -int -Modifications::increment(int number) +int Modifications::increment(int number) { return ++number; } -void -Modifications::exclusiveCppStuff() +void Modifications::exclusiveCppStuff() { - cout << __FUNCTION__ << endl; + std::cout << __FUNCTION__ << std::endl; } -int -Modifications::cppMultiply(int a, int b) +int Modifications::cppMultiply(int a, int b) { return a * b; } -const char* -Modifications::className() +const char *Modifications::className() { return "Modifications"; } -Point -Modifications::sumPointArray(int arraySize, const Point pointArray[]) +Point Modifications::sumPointArray(int arraySize, const Point pointArray[]) { Point point; for (int i = 0; i < arraySize; ++i) @@ -90,21 +140,18 @@ Modifications::sumPointArray(int arraySize, const Point pointArray[]) return point; } -int -Modifications::getSize(const void* data, int size) +int Modifications::getSize(const void *data, int size) { (void)data; return size; } -int -Modifications::sumPointCoordinates(const Point* point) +int Modifications::sumPointCoordinates(const Point *point) { return point->x() + point->y(); } -double -Modifications::differenceOfPointCoordinates(const Point* pt, bool* ok) +double Modifications::differenceOfPointCoordinates(const Point *pt, bool *ok) { if (!pt) { *ok = false; @@ -117,8 +164,7 @@ Modifications::differenceOfPointCoordinates(const Point* pt, bool* ok) return result; } -bool -Modifications::nonConversionRuleForArgumentWithDefaultValue(ObjectType** object) +bool Modifications::nonConversionRuleForArgumentWithDefaultValue(ObjectType **object) { if (object) *object = m_object; diff --git a/sources/shiboken6/tests/libsample/modifications.h b/sources/shiboken6/tests/libsample/modifications.h index 5caabcd9a..5bd1bac47 100644 --- a/sources/shiboken6/tests/libsample/modifications.h +++ b/sources/shiboken6/tests/libsample/modifications.h @@ -5,15 +5,18 @@ #define MODIFICATIONS_H #include "libsamplemacros.h" -#include <utility> #include "point.h" #include "oddbool.h" +#include <utility> + class ObjectType; class LIBSAMPLE_API Modifications { public: + LIBMINIMAL_DISABLE_COPY_MOVE(Modifications) + Modifications(); virtual ~Modifications(); @@ -33,34 +36,38 @@ public: // those overloaded methods should be heavily modified // to push the overload decisor to its limits - inline OverloadedModFunc overloaded(int a0, bool b0, int c0, double d0) { return Overloaded_ibid; } - inline OverloadedModFunc overloaded(int a1, bool b1, int c1, bool d1) { return Overloaded_ibib; } - inline OverloadedModFunc overloaded(int a2, bool b2, int c2, Point d2) { return Overloaded_ibiP; } - inline OverloadedModFunc overloaded(int a3, bool b3, int c3 = 123, int d3 = 456) { return Overloaded_ibii; } - inline OverloadedModFunc overloaded(int a4, bool b4, Point c4, Point d4) { return Overloaded_ibPP; } + 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); - inline void argRemoval0(int a0, bool a1, int a2 = 123, int a3 = 456) {} - inline void argRemoval0(int a0, bool a1, int a2, bool a3) {} + void argRemoval0(int a0, bool a1, int a2 = 123, int a3 = 456); + void argRemoval0(int a0, bool a1, int a2, bool a3); - inline void argRemoval1(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), int a4 = 333) {} - inline void argRemoval1(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); - inline void argRemoval2(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), int a4 = 333) {} + void argRemoval2(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), + int a4 = 333); - inline void argRemoval3(int a0, Point a1 = Point(1, 2), bool a2 = true, 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); - inline void argRemoval4(int a0, Point a1, bool a2, Point a3 = Point(3, 4), int a4 = 333) {} + void argRemoval4(int a0, Point a1, bool a2, Point a3 = Point(3, 4), int a4 = 333); - inline void argRemoval5(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), int a4 = 333) {} - inline void argRemoval5(int a0, bool a1, int a2, bool a3) {} + 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); + 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); + double multiplyPointCoordsPlusValue(bool *ok, Point pt, double value); // completely remove 'plus' from the Python side int doublePlus(int value, int plus = 0); @@ -81,24 +88,25 @@ public: int cppMultiply(int a, int b); // change the name of this virtual method - virtual const char* className(); + virtual const char *className(); Point sumPointArray(int arraySize, const Point pointArray[]); // Replace 'const void*' by 'ByteArray&'. - int getSize(const void* data, int size); + 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); + 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); } + 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; } + 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; } @@ -114,7 +122,7 @@ public: void notifySetAttroCalled(); private: - ObjectType* m_object; + ObjectType *m_object; TestEnum m_enumValue = TestEnumValue1; bool m_getAttroCalled = false; bool m_setAttroCalled = false; @@ -123,8 +131,10 @@ private: class LIBSAMPLE_API AbstractModifications : public Modifications { public: - AbstractModifications() {} - virtual ~AbstractModifications() {} + LIBMINIMAL_DISABLE_COPY_MOVE(AbstractModifications) + + AbstractModifications() noexcept = default; + ~AbstractModifications() override = default; inline bool invert(bool value) { return !value; } diff --git a/sources/shiboken6/tests/libsample/modified_constructor.cpp b/sources/shiboken6/tests/libsample/modified_constructor.cpp index d53815243..c39c97738 100644 --- a/sources/shiboken6/tests/libsample/modified_constructor.cpp +++ b/sources/shiboken6/tests/libsample/modified_constructor.cpp @@ -8,8 +8,7 @@ ModifiedConstructor::ModifiedConstructor(int first_arg) m_stored_value = first_arg; } -int -ModifiedConstructor::retrieveValue() +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 index 48cb812a6..a27899f3f 100644 --- a/sources/shiboken6/tests/libsample/modified_constructor.h +++ b/sources/shiboken6/tests/libsample/modified_constructor.h @@ -10,8 +10,8 @@ class LIBSAMPLE_API ModifiedConstructor { public: - ModifiedConstructor(int first_arg); - int retrieveValue(); + explicit ModifiedConstructor(int first_arg); + int retrieveValue() const; private: int m_stored_value; diff --git a/sources/shiboken6/tests/libsample/multiple_derived.cpp b/sources/shiboken6/tests/libsample/multiple_derived.cpp index 9797a397b..be535c62f 100644 --- a/sources/shiboken6/tests/libsample/multiple_derived.cpp +++ b/sources/shiboken6/tests/libsample/multiple_derived.cpp @@ -3,37 +3,22 @@ #include "multiple_derived.h" -MDerived1::MDerived1() : m_value(100) -{ -} +MDerived1::MDerived1() noexcept = default; -MDerived2::MDerived2() : m_value(200) -{ -} +MDerived2::MDerived2() noexcept = default; -MDerived3::MDerived3() : m_value(3000) -{ -} +MDerived3::MDerived3() noexcept = default; -MDerived4::MDerived4() -{ -} +MDerived4::MDerived4() noexcept = default; -MDerived5::MDerived5() -{ -} +MDerived5::MDerived5() noexcept = default; -MDerived1* -MDerived1::transformFromBase1(Base1* self) +MDerived1 *MDerived1::transformFromBase1(Base1 *self) { - MDerived1* ptr = dynamic_cast<MDerived1*>(self); - return ptr; + return dynamic_cast<MDerived1*>(self); } -MDerived1* -MDerived1::transformFromBase2(Base2* self) +MDerived1 *MDerived1::transformFromBase2(Base2 *self) { - MDerived1* ptr = dynamic_cast<MDerived1*>(self); - return ptr; + return dynamic_cast<MDerived1*>(self); } - diff --git a/sources/shiboken6/tests/libsample/multiple_derived.h b/sources/shiboken6/tests/libsample/multiple_derived.h index b91fb34cd..8c2143ed6 100644 --- a/sources/shiboken6/tests/libsample/multiple_derived.h +++ b/sources/shiboken6/tests/libsample/multiple_derived.h @@ -5,70 +5,86 @@ #define MDERIVED_H #include "libsamplemacros.h" + #include <string> class Base1 { public: - Base1() : m_value(1) {} - virtual ~Base1() {} + LIBMINIMAL_DISABLE_COPY_MOVE(Base1) + + Base1() noexcept = default; + virtual ~Base1() = default; + virtual int base1Method() { return m_value; } virtual void publicMethod() {}; + private: - int m_value; + int m_value = 1; }; class Base2 { public: - Base2() : m_value(2) {} - virtual ~Base2() {} + LIBMINIMAL_DISABLE_COPY_MOVE(Base2) + + Base2() noexcept = default; + virtual ~Base2() = default; virtual int base2Method() { return m_value; } + private: - int m_value; + int m_value = 2; }; class LIBSAMPLE_API MDerived1 : public Base1, public Base2 { public: - MDerived1(); - ~MDerived1() override {} + 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; } + inline Base1 *castToBase1() { return (Base1*) this; } + inline Base2 *castToBase2() { return (Base2*) this; } - static MDerived1* transformFromBase1(Base1 *self); - static MDerived1* transformFromBase2(Base2 *self); + static MDerived1 *transformFromBase1(Base1 *self); + static MDerived1 *transformFromBase2(Base2 *self); private: void publicMethod() override {} - int m_value; + int m_value = 100; }; class SonOfMDerived1 : public MDerived1 { public: - SonOfMDerived1() : m_value(0) {} - ~SonOfMDerived1() {} + LIBMINIMAL_DISABLE_COPY_MOVE(SonOfMDerived1) + + SonOfMDerived1() noexcept = default; + ~SonOfMDerived1() = default; - inline MDerived1* castToMDerived1() { return (MDerived1*) this; } + inline MDerived1 *castToMDerived1() { return this; } int sonOfMDerived1Method() { return m_value; } + private: - int m_value; + int m_value = 0; }; class Base3 { public: - explicit Base3(int val = 3) : m_value(val) {} - virtual ~Base3() {} + 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; }; @@ -76,80 +92,95 @@ private: class Base4 { public: - Base4() : m_value(4) {} - virtual ~Base4() {} + LIBMINIMAL_DISABLE_COPY_MOVE(Base4) + + Base4() noexcept = default; + virtual ~Base4() = default; int base4Method() { return m_value; } + private: - int m_value; + int m_value = 4; }; class Base5 { public: - Base5() : m_value(5) {} - virtual ~Base5() {} + LIBMINIMAL_DISABLE_COPY_MOVE(Base5) + + Base5() noexcept = default; + virtual ~Base5() = default; virtual int base5Method() { return m_value; } + private: - int m_value; + int m_value = 5; }; class Base6 { public: - Base6() : m_value(6) {} - virtual ~Base6() {} + LIBMINIMAL_DISABLE_COPY_MOVE(Base6) + + Base6() noexcept = default; + virtual ~Base6() = default; virtual int base6Method() { return m_value; } + private: - int m_value; + int m_value = 6; }; - class LIBSAMPLE_API MDerived2 : public Base3, public Base4, public Base5, public Base6 { public: - MDerived2(); - virtual ~MDerived2() {} + 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 (Base3*) this; } - inline Base4* castToBase4() { return (Base4*) this; } - inline Base5* castToBase5() { return (Base5*) this; } - inline Base6* castToBase6() { return (Base6*) this; } + inline Base3 *castToBase3() { return this; } + inline Base4 *castToBase4() { return this; } + inline Base5 *castToBase5() { return this; } + inline Base6 *castToBase6() { return this; } private: - int m_value; + int m_value = 200; }; class LIBSAMPLE_API MDerived3 : public MDerived1, public MDerived2 { public: - MDerived3(); - virtual ~MDerived3() {} + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived3) + + MDerived3() noexcept; + virtual ~MDerived3() = default; inline virtual int mderived3Method() { return m_value; } - inline MDerived1* castToMDerived1() { return (MDerived1*) this; } - inline MDerived2* castToMDerived2() { return (MDerived2*) this; } + inline MDerived1 *castToMDerived1() { return this; } + inline MDerived2 *castToMDerived2() { return this; } - inline Base3* castToBase3() { return (Base3*) this; } + inline Base3 *castToBase3() { return (Base3*) this; } private: - int m_value; + int m_value = 3000; }; class LIBSAMPLE_API MDerived4 : public Base3, public Base4 { public: - MDerived4(); - ~MDerived4() {} + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived4) + + MDerived4() noexcept; + ~MDerived4() = default; inline int mderived4Method() { return 0; } inline int justDummyMethod() { return m_value; } - inline Base3* castToBase3() { return (Base3*) this; } - inline Base4* castToBase4() { return (Base4*) this; } + inline Base3 *castToBase3() { return this; } + inline Base4 *castToBase4() { return this; } + private: int m_value; }; @@ -157,14 +188,15 @@ private: class LIBSAMPLE_API MDerived5 : public Base3, public Base4 { public: - MDerived5(); - virtual ~MDerived5() {} + LIBMINIMAL_DISABLE_COPY_MOVE(MDerived5) + + MDerived5() noexcept; + virtual ~MDerived5() = default; virtual int mderived5Method() { return 0; } - inline Base3* castToBase3() { return (Base3*) this; } - inline Base4* castToBase4() { return (Base4*) this; } + 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 index e7d738037..a0b91380b 100644 --- a/sources/shiboken6/tests/libsample/noimplicitconversion.h +++ b/sources/shiboken6/tests/libsample/noimplicitconversion.h @@ -13,9 +13,12 @@ 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; } + 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; }; diff --git a/sources/shiboken6/tests/libsample/nondefaultctor.h b/sources/shiboken6/tests/libsample/nondefaultctor.h index c410515ad..fa97b8859 100644 --- a/sources/shiboken6/tests/libsample/nondefaultctor.h +++ b/sources/shiboken6/tests/libsample/nondefaultctor.h @@ -8,13 +8,16 @@ class NonDefaultCtor { - int m_value; public: - NonDefaultCtor(int value) : m_value(value) + LIBMINIMAL_DEFAULT_COPY_MOVE(NonDefaultCtor) + + explicit NonDefaultCtor(int value) noexcept : m_value(value) { } - inline int value() + virtual ~NonDefaultCtor() = default; + + inline int value() const { return m_value; } @@ -44,7 +47,8 @@ public: return returnMyselfVirtual(); } - virtual ~NonDefaultCtor() {} +private: + int m_value; }; -#endif +#endif // NONDEFAULTCTOR_H diff --git a/sources/shiboken6/tests/libsample/nontypetemplate.h b/sources/shiboken6/tests/libsample/nontypetemplate.h index d3bc7fb8a..e41c21604 100644 --- a/sources/shiboken6/tests/libsample/nontypetemplate.h +++ b/sources/shiboken6/tests/libsample/nontypetemplate.h @@ -21,7 +21,7 @@ private: int m_array[Size]; }; -typedef IntArray<2> IntArray2; -typedef IntArray<3> IntArray3; +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 index 9a618095c..945a89fa2 100644 --- a/sources/shiboken6/tests/libsample/null.h +++ b/sources/shiboken6/tests/libsample/null.h @@ -8,12 +8,12 @@ class Null { public: Null(bool value) : m_isNull(value) {} - Null() : m_isNull(false) {} + Null() = default; + void setIsNull(bool flag) { m_isNull = flag; } private: - bool m_isNull; + bool m_isNull = false; }; -#endif // STR_H - +#endif // NULL_H diff --git a/sources/shiboken6/tests/libsample/objectmodel.cpp b/sources/shiboken6/tests/libsample/objectmodel.cpp index 7ba762d36..56ed86577 100644 --- a/sources/shiboken6/tests/libsample/objectmodel.cpp +++ b/sources/shiboken6/tests/libsample/objectmodel.cpp @@ -3,15 +3,22 @@ #include "objectmodel.h" -void -ObjectModel::setData(ObjectType* data) +void ObjectModel::setData(ObjectType *data) { m_data = data; } -ObjectType* -ObjectModel::data() const +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 index 6f99c41e0..6d2f97aee 100644 --- a/sources/shiboken6/tests/libsample/objectmodel.h +++ b/sources/shiboken6/tests/libsample/objectmodel.h @@ -11,23 +11,21 @@ class LIBSAMPLE_API ObjectModel : public ObjectType { public: explicit ObjectModel(ObjectType *parent = nullptr) - : ObjectType(parent), m_data(nullptr) - {} + : ObjectType(parent) {} - void setData(ObjectType* data); - virtual ObjectType* data() const; + 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) { return ObjectModel::ObjectTypeCalled; } - static MethodCalled receivesObjectTypeFamily(const ObjectModel& object) { return ObjectModel::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; + ObjectType *m_data = nullptr; }; #endif // OBJECTMODEL_H - diff --git a/sources/shiboken6/tests/libsample/objecttype.cpp b/sources/shiboken6/tests/libsample/objecttype.cpp index 03c677104..fa3e7357c 100644 --- a/sources/shiboken6/tests/libsample/objecttype.cpp +++ b/sources/shiboken6/tests/libsample/objecttype.cpp @@ -3,44 +3,36 @@ #include "objecttype.h" #include "objecttypelayout.h" + #include <algorithm> #include <iostream> #include <string> #include <assert.h> -#include <algorithm> - -using namespace std; - -ObjectType::ObjectType(ObjectType* parent) : m_parent(nullptr), m_layout(nullptr), m_call_id(-1) +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 *ObjectType::createWithChild() { - ObjectType* parent = create(); - ObjectType* child = create(); + ObjectType *parent = create(); + ObjectType *child = create(); child->setObjectName("child"); child->setParent(parent); return parent; } -const ObjectType *ObjectType::defaultInstance() -{ - static ObjectType result; - return &result; -} - -void -ObjectType::removeChild(ObjectType* child) +void ObjectType::removeChild(ObjectType *child) { if (!child) return; @@ -52,8 +44,7 @@ ObjectType::removeChild(ObjectType* child) } } -ObjectType* -ObjectType::takeChild(ObjectType* child) +ObjectType *ObjectType::takeChild(ObjectType *child) { if (!child) return nullptr; @@ -67,8 +58,7 @@ ObjectType::takeChild(ObjectType* child) return nullptr; } -ObjectType* -ObjectType::takeChild(const Str& name) +ObjectType *ObjectType::takeChild(const Str &name) { return takeChild(findChild(name)); @@ -82,15 +72,13 @@ ObjectTypeList::iterator ObjectType::findChildByName(const Str &name) }); } -ObjectType* -ObjectType::findChild(const Str& name) +ObjectType *ObjectType::findChild(const Str &name) { auto it = findChildByName(name); return it != m_children.end() ? *it : nullptr; } -void -ObjectType::killChild(const Str& name) +void ObjectType::killChild(const Str &name) { auto it = findChildByName(name); if (it != m_children.end()) { @@ -100,8 +88,7 @@ ObjectType::killChild(const Str& name) } } -void -ObjectType::setParent(ObjectType* parent) +void ObjectType::setParent(ObjectType *parent) { if (m_parent == parent) return; @@ -114,33 +101,28 @@ ObjectType::setParent(ObjectType* parent) m_parent->m_children.push_back(this); } -void -ObjectType::setObjectName(const Str& name) +void ObjectType::setObjectName(const Str &name) { m_objectName = name; } -Str -ObjectType::objectName() const +Str ObjectType::objectName() const { return m_objectName; } -bool -ObjectType::causeEvent(Event::EventType eventType) +bool ObjectType::causeEvent(Event::EventType eventType) { Event e(eventType); return event(&e); } -bool -ObjectType::event(Event* event) +bool ObjectType::event(Event *) { return true; } -int -ObjectType::processEvent(ObjectTypeList objects, Event *event) +int ObjectType::processEvent(ObjectTypeList objects, Event *event) { return std::count_if(objects.begin(), objects.end(), [event] (ObjectType *o) { @@ -148,38 +130,43 @@ ObjectType::processEvent(ObjectTypeList objects, Event *event) }); } -void -ObjectType::callInvalidateEvent(Event* event) +void ObjectType::callInvalidateEvent(Event *event) { invalidateEvent(event); } -void -ObjectType::setLayout(ObjectTypeLayout* l) +void ObjectType::invalidateEvent(Event *) +{ +} + +void ObjectType::setLayout(ObjectTypeLayout *l) { if (!l) { - cerr << "[WARNING] ObjectType::setLayout: Cannot set layout to 0." << endl; + std::cerr << "[WARNING] ObjectType::setLayout: Cannot set layout to 0.\n"; return; } if (layout()) { if (layout() != l) { - cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" << l->objectName().cstring(); - cerr << "' on ObjectType '" << objectName().cstring() << "', which already has a layout." << endl; + 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(); + ObjectType *oldParent = l->parent(); if (oldParent && oldParent != this) { if (oldParent->isLayoutType()) { - cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" << l->objectName().cstring(); - cerr << "' on ObjectType '" << objectName().cstring() << "', when the ObjectTypeLayout already has a parent layout." << endl; + 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; - } else { - // Steal the layout from an ObjectType parent. - oldParent->takeLayout(); } + // Steal the layout from an ObjectType parent. + oldParent->takeLayout(); } m_layout = l; @@ -189,9 +176,9 @@ ObjectType::setLayout(ObjectTypeLayout* l) } } -ObjectTypeLayout* ObjectType::takeLayout() +ObjectTypeLayout *ObjectType::takeLayout() { - ObjectTypeLayout* l = layout(); + ObjectTypeLayout *l = layout(); if (!l) return nullptr; m_layout = nullptr; @@ -199,39 +186,35 @@ ObjectTypeLayout* ObjectType::takeLayout() return l; } -unsigned int -objectTypeHash(const ObjectType* objectType) +unsigned int objectTypeHash(const ObjectType *objectType) { return reinterpret_cast<std::size_t>(objectType); } -unsigned char -ObjectType::callWithEnum(const Str& prefix, Event::EventType type, unsigned char value){ - return value*value; +unsigned char ObjectType::callWithEnum(const Str &, Event::EventType, unsigned char value) +{ + return value * value; } -unsigned char -ObjectType::callWithEnum(const Str& prefix, unsigned char value) { +unsigned char ObjectType::callWithEnum(const Str &, unsigned char value) +{ return value; } -void -ObjectType::setObjectSplittedName(const char*, const Str& prefix, const Str& suffix) +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) +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) +void ObjectType::setObjectNameWithSize(const Str &name, int size) { setObjectNameWithSize("", size, name); } @@ -251,37 +234,31 @@ int ObjectType::callId() const return m_call_id; } - void ObjectType::callVirtualCreateChild() { - ObjectType* fake_parent = new ObjectType(); - ObjectType* fake_child = createChild(fake_parent); + 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) +ObjectType *ObjectType::createChild(ObjectType *parent) { return new ObjectType(parent); } std::size_t ObjectType::createObjectType() { - void* addr = new ObjectType(); + void *addr = new ObjectType(); return (std::size_t) addr; } -OtherBase::~OtherBase() -{ -} +OtherBase::~OtherBase() = default; -ObjectTypeDerived::~ObjectTypeDerived() -{ -} +ObjectTypeDerived::~ObjectTypeDerived() = default; -bool -ObjectTypeDerived::event(Event* event) +bool ObjectTypeDerived::event(Event *) { return true; } diff --git a/sources/shiboken6/tests/libsample/objecttype.h b/sources/shiboken6/tests/libsample/objecttype.h index 798b932f9..498556459 100644 --- a/sources/shiboken6/tests/libsample/objecttype.h +++ b/sources/shiboken6/tests/libsample/objecttype.h @@ -4,13 +4,12 @@ #ifndef OBJECTTYPE_H #define OBJECTTYPE_H -#include <list> #include "str.h" #include "null.h" #include "libsamplemacros.h" -#include <stddef.h> +#include <list> struct Event { @@ -26,11 +25,12 @@ struct Event Value2 }; - Event(EventType eventType) : m_eventType(eventType) {} - EventType eventType() { return m_eventType; } + 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; @@ -48,67 +48,72 @@ public: 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(); - - static const ObjectType *defaultInstance(); - - 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); + 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); + 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); + virtual bool event(Event *event); static int processEvent(ObjectTypeList objects, Event *event); - void callInvalidateEvent(Event* event); - virtual void invalidateEvent(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; } + 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); + 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); + 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&); + 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); + virtual ObjectType *createChild(ObjectType *parent); static std::size_t createObjectType(); //return a parent from C++ - ObjectType* getCppParent() { + ObjectType *getCppParent() { if (!m_parent) { - ObjectType* parent = new ObjectType(); + ObjectType *parent = new ObjectType(); setParent(parent); } return m_parent; @@ -123,41 +128,39 @@ public: // 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; } + ObjectType *nextInFocusChain() { return m_parent; } private: - ObjectType(const ObjectType&); - ObjectType& operator=(const ObjectType&); - - ObjectTypeLayout* takeLayout(); + ObjectTypeLayout *takeLayout(); ObjectTypeList::iterator findChildByName(const Str &name); Str m_objectName; - ObjectType* m_parent; + ObjectType *m_parent = nullptr; ObjectTypeList m_children; - ObjectTypeLayout* m_layout; - - + ObjectTypeLayout *m_layout = nullptr; //used on overload null test - int m_call_id; + int m_call_id = -1; }; -LIBSAMPLE_API unsigned int objectTypeHash(const ObjectType* objectType); +LIBSAMPLE_API unsigned int objectTypeHash(const ObjectType *objectType); class LIBSAMPLE_API OtherBase { public: - OtherBase() {}; + LIBMINIMAL_DISABLE_COPY_MOVE(OtherBase) + + OtherBase() noexcept = default; virtual ~OtherBase(); }; class LIBSAMPLE_API ObjectTypeDerived: public ObjectType, public OtherBase { public: - ObjectTypeDerived(): ObjectType(), OtherBase() {}; + LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeDerived) - bool event(Event* event) override; + 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 index ff981b517..7b12ff945 100644 --- a/sources/shiboken6/tests/libsample/objecttypebyvalue.h +++ b/sources/shiboken6/tests/libsample/objecttypebyvalue.h @@ -3,19 +3,29 @@ #ifndef OBJECTTYPEBYVALUE_H #define OBJECTTYPEBYVALUE_H -#include <list> + #include "protected.h" +#include <list> + class ObjectTypeByValue { public: - ObjectTypeByValue returnSomeKindOfMe() { return ObjectTypeByValue(); } - void acceptKindOfMeAsValue(ObjectTypeByValue kindOfMe) {} + ObjectTypeByValue returnSomeKindOfMe() { return {}; } + void acceptKindOfMeAsValue(ObjectTypeByValue kindOfMe); - void acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue> listOfMe) {} + void acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue> listOfMe); // prop used to check for segfaults ProtectedProperty prop; }; -#endif +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 index 076023470..c0950d09c 100644 --- a/sources/shiboken6/tests/libsample/objecttypeholder.cpp +++ b/sources/shiboken6/tests/libsample/objecttypeholder.cpp @@ -3,14 +3,14 @@ #include "objecttypeholder.h" -ObjectTypeHolder::ObjectTypeHolder(const char* objectName) +ObjectTypeHolder::ObjectTypeHolder(const char *objectName) { - auto object = new ObjectType(); + auto *object = new ObjectType(); object->setObjectName(objectName); m_objectType = object; } -ObjectTypeHolder::ObjectTypeHolder(const ObjectType *object) : +ObjectTypeHolder::ObjectTypeHolder(const ObjectType *object) noexcept : m_objectType(object) { } @@ -20,14 +20,12 @@ ObjectTypeHolder::~ObjectTypeHolder() delete m_objectType; } -Str -ObjectTypeHolder::passObjectTypeAsReference(const ObjectType& objectType) +Str ObjectTypeHolder::passObjectTypeAsReference(const ObjectType &objectType) { return objectType.objectName(); } -Str -ObjectTypeHolder::callPassObjectTypeAsReference() +Str ObjectTypeHolder::callPassObjectTypeAsReference() { return passObjectTypeAsReference(*m_objectType); } diff --git a/sources/shiboken6/tests/libsample/objecttypeholder.h b/sources/shiboken6/tests/libsample/objecttypeholder.h index f0ddd97b2..190664608 100644 --- a/sources/shiboken6/tests/libsample/objecttypeholder.h +++ b/sources/shiboken6/tests/libsample/objecttypeholder.h @@ -11,17 +11,19 @@ class LIBSAMPLE_API ObjectTypeHolder { public: - explicit ObjectTypeHolder(const char* objectName); - explicit ObjectTypeHolder(const ObjectType *object = ObjectType::defaultInstance()); + LIBMINIMAL_DISABLE_COPY_MOVE(ObjectTypeHolder) + + explicit ObjectTypeHolder(const char *objectName); + explicit ObjectTypeHolder(const ObjectType *object) noexcept; virtual ~ObjectTypeHolder(); - const ObjectType* getObjecType() { return m_objectType; } + const ObjectType *getObjectType() const { return m_objectType; } - virtual Str passObjectTypeAsReference(const ObjectType& objectType); + virtual Str passObjectTypeAsReference(const ObjectType &objectType); Str callPassObjectTypeAsReference(); private: const ObjectType *m_objectType; }; -#endif +#endif // OBJECTTYPEHOLDER_H diff --git a/sources/shiboken6/tests/libsample/objecttypelayout.cpp b/sources/shiboken6/tests/libsample/objecttypelayout.cpp index 2fbd20ccf..3fa02917c 100644 --- a/sources/shiboken6/tests/libsample/objecttypelayout.cpp +++ b/sources/shiboken6/tests/libsample/objecttypelayout.cpp @@ -2,17 +2,16 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "objecttypelayout.h" -#include <iostream> -using namespace std; +#include <iostream> -void ObjectTypeLayout::addObject(ObjectType* obj) +void ObjectTypeLayout::addObject(ObjectType *obj) { if (obj->isLayoutType()) { - ObjectTypeLayout* l = reinterpret_cast<ObjectTypeLayout*>(obj); + auto *l = reinterpret_cast<ObjectTypeLayout*>(obj); if (l->parent()) { - cerr << "[WARNING] ObjectTypeLayout::addObject: layout '" << l->objectName().cstring(); - cerr << "' already has a parent." << endl; + std::cerr << "[WARNING] ObjectTypeLayout::addObject: layout '" + << l->objectName().cstring() << "' already has a parent.\n"; return; } @@ -25,12 +24,12 @@ void ObjectTypeLayout::addObject(ObjectType* obj) m_objects.push_back(obj); } -std::list< ObjectType* > ObjectTypeLayout::objects() const +std::list<ObjectType*> ObjectTypeLayout::objects() const { return m_objects; } -void ObjectTypeLayout::reparentChildren(ObjectType* parent) +void ObjectTypeLayout::reparentChildren(ObjectType *parent) { for (auto *o : m_objects) { if (o->isLayoutType()) @@ -39,4 +38,3 @@ void ObjectTypeLayout::reparentChildren(ObjectType* parent) o->setParent(parent); } } - diff --git a/sources/shiboken6/tests/libsample/objecttypelayout.h b/sources/shiboken6/tests/libsample/objecttypelayout.h index 98eb30946..0aa9fad6e 100644 --- a/sources/shiboken6/tests/libsample/objecttypelayout.h +++ b/sources/shiboken6/tests/libsample/objecttypelayout.h @@ -6,6 +6,7 @@ #include "libsamplemacros.h" #include "objecttype.h" + #include <list> class ObjectType; @@ -13,19 +14,19 @@ class ObjectType; class LIBSAMPLE_API ObjectTypeLayout : public ObjectType { public: - void addObject(ObjectType* obj); + void addObject(ObjectType *obj); std::list<ObjectType*> objects() const; bool isLayoutType() override { return true; } - inline static ObjectTypeLayout* create() { return new ObjectTypeLayout(); } + inline static ObjectTypeLayout *create() { return new ObjectTypeLayout(); } + + ObjectType *takeChild(const Str &name) override { return ObjectType::takeChild(name); } - 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); + 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 index 05f229a81..c78387a3e 100644 --- a/sources/shiboken6/tests/libsample/objecttypeoperators.cpp +++ b/sources/shiboken6/tests/libsample/objecttypeoperators.cpp @@ -7,32 +7,32 @@ ObjectTypeOperators::ObjectTypeOperators(const std::string key) : m_key(key) { } -bool ObjectTypeOperators::operator==(const ObjectTypeOperators& other) const +bool ObjectTypeOperators::operator==(const ObjectTypeOperators &other) const { return m_key == other.m_key; } -const ObjectTypeOperators& ObjectTypeOperators::operator<(const ObjectTypeOperators& other) const +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) +bool operator==(const ObjectTypeOperators *obj, const std::string &str) { return obj->key() == str; } -bool operator==(const std::string& str, const ObjectTypeOperators* obj) +bool operator==(const std::string &str, const ObjectTypeOperators *obj) { return str == obj->key(); } -std::string operator+(const ObjectTypeOperators* obj, const std::string& str) +std::string operator+(const ObjectTypeOperators *obj, const std::string &str) { return obj->key() + str; } -std::string operator+(const std::string& str, const ObjectTypeOperators* obj) +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 index b768359a3..6144952ca 100644 --- a/sources/shiboken6/tests/libsample/objecttypeoperators.h +++ b/sources/shiboken6/tests/libsample/objecttypeoperators.h @@ -5,32 +5,32 @@ #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() {} + virtual ~ObjectTypeOperators() = default; - bool operator==(const ObjectTypeOperators& other) const; - const ObjectTypeOperators& operator<(const ObjectTypeOperators& other) const; + bool operator==(const ObjectTypeOperators &other) const; + const ObjectTypeOperators &operator<(const ObjectTypeOperators &other) const; // chaos! - virtual void operator>(const ObjectTypeOperators&) { m_key.append("operator>"); } + virtual void operator>(const ObjectTypeOperators &) { m_key.append("operator>"); } std::string key() const { return m_key; } private: std::string m_key; - - ObjectTypeOperators(ObjectTypeOperators&); - ObjectTypeOperators& operator=(ObjectTypeOperators&); }; -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); +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 index 5717053a7..1b727f88c 100644 --- a/sources/shiboken6/tests/libsample/objectview.cpp +++ b/sources/shiboken6/tests/libsample/objectview.cpp @@ -5,25 +5,20 @@ #include "objectmodel.h" #include "str.h" -Str -ObjectView::displayModelData() +Str ObjectView::displayModelData() { if (!m_model) - return Str("(NULL)"); + return {"(NULL)"}; return Str("Name: %VAR").arg(m_model->objectName()); } -void -ObjectView::modifyModelData(Str& data) +void ObjectView::modifyModelData(Str &data) { if (m_model) m_model->setObjectName(data); } - -ObjectType* -ObjectView::getRawModelData() +ObjectType *ObjectView::getRawModelData() { return m_model->data(); } - diff --git a/sources/shiboken6/tests/libsample/objectview.h b/sources/shiboken6/tests/libsample/objectview.h index 1de474ff2..2567deee5 100644 --- a/sources/shiboken6/tests/libsample/objectview.h +++ b/sources/shiboken6/tests/libsample/objectview.h @@ -13,21 +13,19 @@ class ObjectModel; class LIBSAMPLE_API ObjectView : public ObjectType { public: - ObjectView(ObjectModel *model = nullptr, ObjectType *parent = nullptr) - : ObjectType(parent), m_model(model) - {} + 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; } + inline void setModel(ObjectModel *model) { m_model = model; } + inline ObjectModel *model() const { return m_model; } Str displayModelData(); - void modifyModelData(Str& data); + void modifyModelData(Str &data); - ObjectType* getRawModelData(); + ObjectType *getRawModelData(); private: - ObjectModel* m_model; + ObjectModel *m_model; }; #endif // OBJECTVIEW_H - diff --git a/sources/shiboken6/tests/libsample/oddbool.cpp b/sources/shiboken6/tests/libsample/oddbool.cpp index 06a61f1c2..bc1ee833f 100644 --- a/sources/shiboken6/tests/libsample/oddbool.cpp +++ b/sources/shiboken6/tests/libsample/oddbool.cpp @@ -7,7 +7,7 @@ ComparisonTester::ComparisonTester(int v) : m_value(v) { } -ComparisonTester& ComparisonTester::operator=(int v) +ComparisonTester &ComparisonTester::operator=(int v) { m_value = v; return *this; diff --git a/sources/shiboken6/tests/libsample/oddbool.h b/sources/shiboken6/tests/libsample/oddbool.h index a64a05eb3..dd2d32604 100644 --- a/sources/shiboken6/tests/libsample/oddbool.h +++ b/sources/shiboken6/tests/libsample/oddbool.h @@ -16,7 +16,7 @@ class OddBool { public: - inline explicit OddBool(bool b) : m_value(b) {} + inline explicit OddBool(bool b) noexcept : m_value(b) {} bool value() const { return m_value; } inline OddBool operator!() const { return OddBool(!m_value); } @@ -35,9 +35,11 @@ inline bool operator!=(OddBool b1, OddBool b2) { return (!b1).value() != (!b2).v class OddBoolUser { public: - OddBoolUser() : m_oddbool(OddBool(false)) {} - OddBoolUser(const OddBool& oddBool) : m_oddbool(oddBool) {} - virtual ~OddBoolUser() {} + 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; } @@ -52,7 +54,7 @@ public: return invertedOddBool(); } - static inline OddBool getOddBool(const OddBoolUser& oddBoolUser) + static inline OddBool getOddBool(const OddBoolUser &oddBoolUser) { return oddBoolUser.m_oddbool; } diff --git a/sources/shiboken6/tests/libsample/onlycopy.cpp b/sources/shiboken6/tests/libsample/onlycopy.cpp index 6fa4ad064..981ea88a4 100644 --- a/sources/shiboken6/tests/libsample/onlycopy.cpp +++ b/sources/shiboken6/tests/libsample/onlycopy.cpp @@ -11,45 +11,23 @@ public: int value; }; -OnlyCopy::OnlyCopy(int value) : d(new OnlyCopyPrivate(value)) +OnlyCopy::OnlyCopy(int value) : d(std::make_shared<OnlyCopyPrivate>(value)) { - } -OnlyCopy::OnlyCopy(OnlyCopyPrivate *dIn) : d(dIn) -{ -} - -OnlyCopy::~OnlyCopy() -{ - delete d; -} - -OnlyCopy::OnlyCopy(const OnlyCopy& other) : d(new OnlyCopyPrivate(other.value())) -{ -} - -OnlyCopy& -OnlyCopy::operator=(const OnlyCopy& other) -{ - d->value = other.d->value; - return *this; -} +OnlyCopy::~OnlyCopy() = default; int OnlyCopy::value() const { return d->value; } -OnlyCopy -FriendOfOnlyCopy::createOnlyCopy(int value) +OnlyCopy FriendOfOnlyCopy::createOnlyCopy(int value) { - return OnlyCopy(value); } -std::list<OnlyCopy> -FriendOfOnlyCopy::createListOfOnlyCopy(int quantity) +std::list<OnlyCopy> FriendOfOnlyCopy::createListOfOnlyCopy(int quantity) { std::list<OnlyCopy> list; for (int i = 0; i < quantity; ++i) diff --git a/sources/shiboken6/tests/libsample/onlycopy.h b/sources/shiboken6/tests/libsample/onlycopy.h index e7c411a18..7dc3e0069 100644 --- a/sources/shiboken6/tests/libsample/onlycopy.h +++ b/sources/shiboken6/tests/libsample/onlycopy.h @@ -5,7 +5,9 @@ #define ONLYCOPYCLASS_H #include "libsamplemacros.h" + #include <list> +#include <memory> // These classes simulate a situation found in QWebEngineHistoryItem. @@ -14,18 +16,20 @@ class OnlyCopyPrivate; class LIBSAMPLE_API OnlyCopy { public: - OnlyCopy(const OnlyCopy& other); - OnlyCopy& operator=(const OnlyCopy& other); + 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(); } + static int getValueFromReference(const OnlyCopy &onlyCopy) { return onlyCopy.value(); } + private: - OnlyCopyPrivate *d; - explicit OnlyCopy(int value); - explicit OnlyCopy(OnlyCopyPrivate *d); // rejected due to unknown OnlyCopyPrivate friend class FriendOfOnlyCopy; + + explicit OnlyCopy(int value); + + std::shared_ptr<OnlyCopyPrivate> d; }; class LIBSAMPLE_API FriendOfOnlyCopy @@ -35,4 +39,4 @@ public: static std::list<OnlyCopy> createListOfOnlyCopy(int quantity); }; -#endif +#endif // ONLYCOPYCLASS_H diff --git a/sources/shiboken6/tests/libsample/overload.cpp b/sources/shiboken6/tests/libsample/overload.cpp index c0dfd820a..34da28e03 100644 --- a/sources/shiboken6/tests/libsample/overload.cpp +++ b/sources/shiboken6/tests/libsample/overload.cpp @@ -8,18 +8,196 @@ Overload::FunctionEnum Overload::overloaded() return Function0; } -Overload::FunctionEnum Overload::overloaded(Size* size) +Overload::FunctionEnum Overload::overloaded(Size *) { return Function1; } -Overload::FunctionEnum Overload::overloaded(Point* point, ParamEnum param) +Overload::FunctionEnum Overload::overloaded(Point *, ParamEnum) { return Function2; } -Overload::FunctionEnum Overload::overloaded(const Point& point) +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 index 29a6c575f..b640bf7c7 100644 --- a/sources/shiboken6/tests/libsample/overload.h +++ b/sources/shiboken6/tests/libsample/overload.h @@ -17,6 +17,8 @@ class LIBSAMPLE_API Overload { public: + LIBMINIMAL_DISABLE_COPY_MOVE(Overload) + enum FunctionEnum { Function0, Function1, @@ -32,69 +34,71 @@ public: Param1 }; - Overload() {} - virtual ~Overload() {} + Overload() noexcept = default; + virtual ~Overload() = default; FunctionEnum overloaded(); - FunctionEnum overloaded(Size* size); - FunctionEnum overloaded(Point* point, ParamEnum param); - FunctionEnum overloaded(const Point& point); + FunctionEnum overloaded(Size *size); + FunctionEnum overloaded(Point *point, ParamEnum param); + FunctionEnum overloaded(const Point &point); - inline void differentReturnTypes(ParamEnum param = Param0) {} - inline int differentReturnTypes(ParamEnum param, int val) { return val; } + void differentReturnTypes(ParamEnum param = Param0); + int differentReturnTypes(ParamEnum param, int val); - inline int intOverloads(const Point& p, double d) { return 1; } - inline int intOverloads(int i, int i2) { return 2; } - inline int intOverloads(int i, int removedArg, double d) { return 3; } + int intOverloads(const Point &p, double d); + int intOverloads(int i, int i2); + int intOverloads(int i, int removedArg, double d); - inline FunctionEnum intDoubleOverloads(int a0, int a1) const { return Function0; } - inline FunctionEnum intDoubleOverloads(double a0, double a1) const { return Function1; } + FunctionEnum intDoubleOverloads(int a0, int a1) const; + FunctionEnum intDoubleOverloads(double a0, double a1) const; - void singleOverload(Point* x) {} - Point* singleOverload() {return new Point();} + 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) { return Function0; } - FunctionEnum wrapperIntIntOverloads(const Polygon& arg0, int arg1, int arg2) { return Function1; } + 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) { return Function0; } - FunctionEnum strBufferOverloads(unsigned char* arg0, int arg1) { return Function1; } + 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) { return Function0; } - FunctionEnum drawText(const PointF& a0, const Str& a1) { return Function1; } - FunctionEnum drawText(const Rect& a0, int a1, const Str& a2) { return Function2; } - FunctionEnum drawText(const RectF& a0, int a1, const Str& a2) { return Function3; } - FunctionEnum drawText(const RectF& a0, const Str& a1, const Echo& a2 = Echo()) { return Function4; } - FunctionEnum drawText(int a0, int a1, const Str& a2) { return Function5; } - FunctionEnum drawText(int a0, int a1, int a2, int a3, int a4, const Str& a5) { return Function6; } + 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) { return Function0; } - FunctionEnum drawText2(const PointF& a0, const Str& a1) { return Function1; } - FunctionEnum drawText2(const Rect& a0, int a1, const Str& a2) { return Function2; } - FunctionEnum drawText2(const RectF& a0, int a1, const Str& a2) { return Function3; } - FunctionEnum drawText2(const RectF& a0, const Str& a1, const Echo& a2 = Echo()) { return Function4; } - FunctionEnum drawText2(int a0, int a1, const Str& a2) { return Function5; } - FunctionEnum drawText2(int a0, int a1, int a2, int a3 = 0, int a4 = 0, const Str& a5 = Str()) { return Function6; } + 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) { return Function0; } - FunctionEnum drawText3(int a0, int a1, int a2, int a3, int a4) { return Function1; } + 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) { return Function0; } - FunctionEnum drawText4(int a0, int a1, int a2, int a3, int a4) { return Function1; } + FunctionEnum drawText4(int a0, int a1, int a2); + FunctionEnum drawText4(int a0, int a1, int a2, int a3, int a4); - FunctionEnum acceptSequence() { return Function0; } - FunctionEnum acceptSequence(int a0, int a1) { return Function1; } - FunctionEnum acceptSequence(const Str& a0, ParamEnum a1 = Param0) { return Function2; } - FunctionEnum acceptSequence(const Size& a0) { return Function3; } + 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[]) { return Function4; } - FunctionEnum acceptSequence(void* a0) { return Function5; } + FunctionEnum acceptSequence(const char *const a0[]); + FunctionEnum acceptSequence(void *a0); }; class LIBSAMPLE_API Overload2 : public Overload @@ -115,4 +119,3 @@ private: }; #endif // OVERLOAD_H - diff --git a/sources/shiboken6/tests/libsample/overloadsort.cpp b/sources/shiboken6/tests/libsample/overloadsort.cpp index 9857f6e86..a9b4b0972 100644 --- a/sources/shiboken6/tests/libsample/overloadsort.cpp +++ b/sources/shiboken6/tests/libsample/overloadsort.cpp @@ -3,6 +3,41 @@ #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)); diff --git a/sources/shiboken6/tests/libsample/overloadsort.h b/sources/shiboken6/tests/libsample/overloadsort.h index d0d70b8f3..ee269cc21 100644 --- a/sources/shiboken6/tests/libsample/overloadsort.h +++ b/sources/shiboken6/tests/libsample/overloadsort.h @@ -11,52 +11,37 @@ class ImplicitTarget { public: - ImplicitTarget(){} + ImplicitTarget() = default; }; class ImplicitBase { public: - ImplicitBase(){} - ImplicitBase(const ImplicitTarget &b){} + ImplicitBase() = default; + ImplicitBase(const ImplicitTarget &b); }; -class SortedOverload +inline ImplicitBase::ImplicitBase(const ImplicitTarget &) { -public: - - inline const char *overload(int x) { - return "int"; - } - - inline const char *overload(double x) { - return "double"; - } - - inline const char *overload(ImplicitBase x) { - return "ImplicitBase"; - } - - inline const char *overload(ImplicitTarget x) { - return "ImplicitTarget"; - } +} - inline const char *overload(const std::list<ImplicitBase> &x) { - return "list(ImplicitBase)"; - } - - inline int implicit_overload(const ImplicitBase &x) { - return 1; - } +class LIBSAMPLE_API SortedOverload +{ +public: - inline const char *overloadDeep(int x, ImplicitBase &y) { - return "ImplicitBase"; - } + 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); - inline const char* pyObjOverload(int, int) { return "int,int"; } - inline const char* pyObjOverload(unsigned char*, int) { return "PyObject,int"; } + 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 @@ -67,4 +52,3 @@ public: }; #endif // OVERLOADSORT_H - diff --git a/sources/shiboken6/tests/libsample/pairuser.cpp b/sources/shiboken6/tests/libsample/pairuser.cpp index f1f182c5a..5b7eb4d8c 100644 --- a/sources/shiboken6/tests/libsample/pairuser.cpp +++ b/sources/shiboken6/tests/libsample/pairuser.cpp @@ -1,32 +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 <iostream> #include "pairuser.h" -using namespace std; - -std::pair<int, int> -PairUser::callCreatePair() +std::pair<int, int> PairUser::callCreatePair() { return createPair(); } -std::pair<int, int> -PairUser::createPair() +std::pair<int, int> PairUser::createPair() { - return std::pair<int, int>(10, 20); + return {10, 20}; } -std::pair<Complex, Complex> -PairUser::createComplexPair(Complex cpx0, Complex cpx1) +std::pair<Complex, Complex> PairUser::createComplexPair(Complex cpx0, Complex cpx1) { - return std::pair<Complex, Complex>(cpx0, cpx1); + return {cpx0, cpx1}; } -double -PairUser::sumPair(std::pair<int, double> pair) +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 index 313651c06..ee51d818e 100644 --- a/sources/shiboken6/tests/libsample/pairuser.h +++ b/sources/shiboken6/tests/libsample/pairuser.h @@ -4,16 +4,18 @@ #ifndef PAIRUSER_H #define PAIRUSER_H -#include <utility> +#include "libsamplemacros.h" #include "complex.h" -#include "libsamplemacros.h" +#include <utility> class LIBSAMPLE_API PairUser { public: - PairUser() {} - virtual ~PairUser() {} + LIBMINIMAL_DEFAULT_COPY_MOVE(PairUser) + + PairUser() noexcept = default; + virtual ~PairUser() = default; virtual std::pair<int, int> createPair(); std::pair<int, int> callCreatePair(); @@ -26,5 +28,5 @@ public: private: std::pair<int, int> m_pair; }; -#endif // PAIRUSER_H +#endif // PAIRUSER_H diff --git a/sources/shiboken6/tests/libsample/pen.cpp b/sources/shiboken6/tests/libsample/pen.cpp index 877246506..76473a264 100644 --- a/sources/shiboken6/tests/libsample/pen.cpp +++ b/sources/shiboken6/tests/libsample/pen.cpp @@ -3,11 +3,11 @@ #include "pen.h" -Color::Color(SampleNamespace::InValue arg) : m_null(false) +Color::Color(SampleNamespace::InValue) : m_null(false) { } -Color::Color(unsigned int arg) : m_null(false) +Color::Color(unsigned int) : m_null(false) { } @@ -45,28 +45,30 @@ void Brush::setColor(const Color &newColor) m_color = newColor; } -Pen::Pen() : m_ctor(EmptyCtor) -{ -} +Pen::Pen() = default; -Pen::Pen(SampleNamespace::Option option) : m_ctor(EnumCtor) +Pen::Pen(SampleNamespace::Option) : m_ctor(EnumCtor) { } -Pen::Pen(const Color& color) : m_ctor(ColorCtor) +Pen::Pen(const Color &) : m_ctor(ColorCtor) { } -Pen::Pen(const Pen& pen) : m_ctor(CopyCtor) +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 x1, int y1, int x2, int y2, RenderHints renderHints) +void Pen::drawLine(int, int, int, int, RenderHints) { } diff --git a/sources/shiboken6/tests/libsample/pen.h b/sources/shiboken6/tests/libsample/pen.h index 770623519..6f528f0f9 100644 --- a/sources/shiboken6/tests/libsample/pen.h +++ b/sources/shiboken6/tests/libsample/pen.h @@ -15,6 +15,7 @@ public: Color(unsigned int arg); bool isNull() const; + private: bool m_null = true; }; @@ -48,8 +49,12 @@ public: Pen(); Pen(SampleNamespace::Option option); - Pen(const Color& color); - Pen(const Pen& pen); + 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 = {}); @@ -60,7 +65,7 @@ public: void setRenderHints(RenderHints h); private: - int m_ctor; + int m_ctor = EmptyCtor; RenderHints m_renderHints = None; }; diff --git a/sources/shiboken6/tests/libsample/photon.cpp b/sources/shiboken6/tests/libsample/photon.cpp index f98a7c891..2a7f20e33 100644 --- a/sources/shiboken6/tests/libsample/photon.cpp +++ b/sources/shiboken6/tests/libsample/photon.cpp @@ -5,21 +5,27 @@ namespace Photon { + const ClassType Base::staticType; -int callCalculateForValueDuplicatorPointer(ValueDuplicator* value) + +int callCalculateForValueDuplicatorPointer(ValueDuplicator *value) { return value->calculate(); } -int callCalculateForValueDuplicatorReference(ValueDuplicator& value) + +int callCalculateForValueDuplicatorReference(ValueDuplicator &value) { return value.calculate(); } -int countValueIdentities(const std::list<ValueIdentity>& values) + +int countValueIdentities(const std::list<ValueIdentity> &values) { return values.size(); } -int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> >& values) + +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 index 2fbf87d25..2debe47d1 100644 --- a/sources/shiboken6/tests/libsample/photon.h +++ b/sources/shiboken6/tests/libsample/photon.h @@ -4,9 +4,10 @@ #ifndef PHOTON_H #define PHOTON_H -#include <list> #include "libsamplemacros.h" +#include <list> + // This namespace and classes simulate // situations found in Qt's phonon module. @@ -22,8 +23,11 @@ enum ClassType { class LIBSAMPLE_API Base { public: - explicit Base(int value) : m_value(value) {} - virtual ~Base() {} + 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; } @@ -42,12 +46,14 @@ 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); } + 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 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() { @@ -57,7 +63,8 @@ public: return objs; } - static inline TemplateBase<CLASS_TYPE>* passPointerThrough(TemplateBase<CLASS_TYPE>* obj) { return obj; } + 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; @@ -71,43 +78,31 @@ template class LIBSAMPLE_API TemplateBase<DuplicatorType>; 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); - -// This simulates an internal error (SEGV) caused by 'noexcept' in -// boost::intrusive_ptr before support for 'noexcept' was added. The ENTIRE -// code below is needed to trigger the exception; it isn't seen with just a -// 'noexcept' following a declaration. -// -// NOTE: For reasons that should be fairly obvious, this test unfortunately can -// only be "run" when building in C++11 mode. -#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900) -# define PHOTON_NOEXCEPT noexcept -#else -# define PHOTON_NOEXCEPT -#endif +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() PHOTON_NOEXCEPT : px(nullptr) {} - Pointer(int* p) : px(p) {} + Pointer() noexcept = default; + explicit Pointer(int *p) : px(p) {} - void reset() PHOTON_NOEXCEPT { Pointer().swap(*this); } + void reset() noexcept { Pointer().swap(*this); } - int* get() const PHOTON_NOEXCEPT { return px; } - int& operator*() const { return *px; } + int *get() const noexcept { return px; } + int &operator*() const { return *px; } - void swap(Pointer& rhs) PHOTON_NOEXCEPT + void swap(Pointer &rhs) noexcept { - int* tmp = px; + int *tmp = px; px = rhs.px; rhs.px = tmp; } private: - int* px; + int *px = nullptr; }; } // namespace Photon diff --git a/sources/shiboken6/tests/libsample/point.cpp b/sources/shiboken6/tests/libsample/point.cpp index 397dea3e6..b8630eb1e 100644 --- a/sources/shiboken6/tests/libsample/point.cpp +++ b/sources/shiboken6/tests/libsample/point.cpp @@ -1,21 +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 <iostream> #include "point.h" -using namespace std; +#include <iostream> -Point::Point(int x, int y) : m_x(x), m_y(y) +Point::Point(int x, int y) noexcept : m_x(x), m_y(y) { } -Point::Point(double x, double y) : 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 +void Point::midpoint(const Point &other, Point *midpoint) const { if (!midpoint) return; @@ -23,108 +21,91 @@ Point::midpoint(const Point& other, Point* midpoint) const midpoint->setY((m_y + other.m_y) / 2.0); } -Point* -Point::copy() const +Point *Point::copy() const { - Point* pt = new Point(); + Point *pt = new Point(); pt->m_x = m_x; pt->m_y = m_y; return pt; } -void -Point::show() +void Point::show() const { - cout << "(x: " << m_x << ", y: " << m_y << ")"; + std::cout << "(x: " << m_x << ", y: " << m_y << ")"; } -bool -Point::operator==(const Point& other) +bool Point::operator==(const Point &other) { return m_x == other.m_x && m_y == other.m_y; } -Point -Point::operator+(const Point& other) +Point Point::operator+(const Point &other) { - return Point(m_x + other.m_x, m_y + other.m_y); + return {m_x + other.m_x, m_y + other.m_y}; } -Point -Point::operator-(const Point& other) +Point Point::operator-(const Point &other) { - return Point(m_x - other.m_x, m_y - other.m_y); + return {m_x - other.m_x, m_y - other.m_y}; } -Point& -Point::operator+=(Point &other) +Point &Point::operator+=(Point &other) { m_x += other.m_x; m_y += other.m_y; return *this; } -Point& -Point::operator-=(Point &other) +Point &Point::operator-=(Point &other) { m_x -= other.m_x; m_y -= other.m_y; return *this; } -Point -operator*(const Point& pt, double mult) +Point operator*(const Point &pt, double mult) { return Point(pt.m_x * mult, pt.m_y * mult); } -Point -operator*(const Point& pt, int mult) +Point operator*(const Point &pt, int mult) { - return Point(((int) pt.m_x) * mult, ((int) pt.m_y) * mult); + return {int(pt.m_x) * mult, int(pt.m_y) * mult}; } -Point -operator*(double mult, const Point& pt) +Point operator*(double mult, const Point &pt) { - return Point(pt.m_x * mult, pt.m_y * mult); + return {pt.m_x * mult, pt.m_y * mult}; } -Point -operator*(int mult, const Point& pt) +Point operator*(int mult, const Point &pt) { - return Point(((int) pt.m_x) * mult, ((int) pt.m_y) * mult); + return {int(pt.m_x) * mult, int(pt.m_y) * mult}; } -Point -operator-(const Point& pt) +Point operator-(const Point &pt) { - return Point(-pt.m_x, -pt.m_y); + return {-pt.m_x, -pt.m_y}; } -bool -operator!(const Point& pt) +bool operator!(const Point &pt) { - return (pt.m_x == 0.0 && pt.m_y == 0.0); + return pt.m_x == 0.0 && pt.m_y == 0.0; } -Point -Point::operator/(int operand) +Point Point::operator/(int operand) { - return Point(m_x/operand, m_y/operand); + return {m_x/operand, m_y/operand}; } -Complex -transmutePointIntoComplex(const Point& point) +Complex transmutePointIntoComplex(const Point &point) { Complex cpx(point.x(), point.y()); return cpx; } -Point -transmuteComplexIntoPoint(const Complex& 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 index 717658b09..59e0236d5 100644 --- a/sources/shiboken6/tests/libsample/point.h +++ b/sources/shiboken6/tests/libsample/point.h @@ -4,17 +4,19 @@ #ifndef POINT_H #define POINT_H +#include "libsamplemacros.h" #include "complex.h" -#include <utility> -#include "libsamplemacros.h" +#include <utility> class LIBSAMPLE_API Point { public: - Point(int x = 0, int y = 0); - Point(double x, double y); - ~Point() {} + 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; } @@ -27,48 +29,48 @@ public: // 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; + void midpoint(const Point &other, Point *midpoint) const; - Point* copy() const; + Point *copy() const; - inline const Point& getConstReferenceToSelf() const { return *this; } - inline const Point* getSelf() const { return this; } + 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); + bool operator==(const Point &other); - Point operator+(const Point& other); - Point operator-(const Point& other); + 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); + 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); + Point &operator+=(Point &other); + Point &operator-=(Point &other); - void show(); + 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 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 Complex transmutePointIntoComplex(const Point &point); +LIBSAMPLE_API Point transmuteComplexIntoPoint(const Complex &cpx); -LIBSAMPLE_API Point operator*(const Point& pt, double multiplier); +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 index 36ce32205..26f1cf0a6 100644 --- a/sources/shiboken6/tests/libsample/pointerholder.h +++ b/sources/shiboken6/tests/libsample/pointerholder.h @@ -9,12 +9,15 @@ class PointerHolder { public: - explicit PointerHolder(void* ptr) : m_pointer(ptr) {} - ~PointerHolder() {} - inline void* pointer() const { return m_pointer; } + 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; + void *m_pointer; }; #endif // POINTERHOLDER_H - diff --git a/sources/shiboken6/tests/libsample/pointf.cpp b/sources/shiboken6/tests/libsample/pointf.cpp index f68dd0f41..6b39f73a9 100644 --- a/sources/shiboken6/tests/libsample/pointf.cpp +++ b/sources/shiboken6/tests/libsample/pointf.cpp @@ -1,21 +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 <iostream> #include "pointf.h" -using namespace std; +#include <iostream> -PointF::PointF(const Point& point) : m_x(point.x()), m_y(point.y()) +PointF::PointF(const Point &point) noexcept : m_x(point.x()), m_y(point.y()) { } -PointF::PointF(double x, double y) : m_x(x), m_y(y) +PointF::PointF(double x, double y) noexcept : m_x(x), m_y(y) { } -void -PointF::midpoint(const PointF& other, PointF* midpoint) const +void PointF::midpoint(const PointF &other, PointF *midpoint) const { if (!midpoint) return; @@ -23,79 +21,66 @@ PointF::midpoint(const PointF& other, PointF* midpoint) const midpoint->setY((m_y + other.m_y) / 2.0); } -void -PointF::show() +void PointF::show() const { - cout << "(x: " << m_x << ", y: " << m_y << ")"; + std::cout << "(x: " << m_x << ", y: " << m_y << ")"; } -bool -PointF::operator==(const PointF& other) +bool PointF::operator==(const PointF &other) { return m_x == other.m_x && m_y == other.m_y; } -PointF -PointF::operator+(const PointF& other) +PointF PointF::operator+(const PointF &other) { - return PointF(m_x + other.m_x, m_y + other.m_y); + return {m_x + other.m_x, m_y + other.m_y}; } -PointF -PointF::operator-(const PointF& other) +PointF PointF::operator-(const PointF &other) { - return PointF(m_x - other.m_x, m_y - other.m_y); + return {m_x - other.m_x, m_y - other.m_y}; } -PointF& -PointF::operator+=(PointF &other) +PointF &PointF::operator+=(PointF &other) { m_x += other.m_x; m_y += other.m_y; return *this; } -PointF& -PointF::operator-=(PointF &other) +PointF &PointF::operator-=(PointF &other) { m_x -= other.m_x; m_y -= other.m_y; return *this; } -PointF -operator*(const PointF& pt, double mult) +PointF operator*(const PointF &pt, double mult) { - return PointF(pt.m_x * mult, pt.m_y * mult); + return {pt.m_x * mult, pt.m_y * mult}; } -PointF -operator*(const PointF& pt, int mult) +PointF operator*(const PointF &pt, int mult) { - return PointF(((int) pt.m_x) * mult, ((int) pt.m_y) * mult); + return PointF(int(pt.m_x) * mult, int(pt.m_y) * mult); } -PointF -operator*(double mult, const PointF& pt) +PointF operator*(double mult, const PointF &pt) { - return PointF(pt.m_x * mult, pt.m_y * mult); + return {pt.m_x * mult, pt.m_y * mult}; } -PointF -operator*(int mult, const PointF& pt) +PointF operator*(int mult, const PointF &pt) { - return PointF(((int) pt.m_x) * mult, ((int) pt.m_y) * mult); + return PointF(int(pt.m_x) * mult, int(pt.m_y) * mult); } -PointF -operator-(const PointF& pt) +PointF operator-(const PointF &pt) { - return PointF(-pt.m_x, -pt.m_y); + return {-pt.m_x, -pt.m_y}; } -bool -operator!(const PointF& pt) +bool operator!(const PointF &pt) { - return (pt.m_x == 0.0 && pt.m_y == 0.0); + 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 index 86c8c9d2a..bb50b5c6d 100644 --- a/sources/shiboken6/tests/libsample/pointf.h +++ b/sources/shiboken6/tests/libsample/pointf.h @@ -4,17 +4,19 @@ #ifndef POINTF_H #define POINTF_H +#include "libsamplemacros.h" #include "point.h" -#include <utility> -#include "libsamplemacros.h" +#include <utility> class LIBSAMPLE_API PointF { public: - PointF(const Point& point); - PointF(double x = 0.0, double y = 0.0); - ~PointF() {} + 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; } @@ -25,39 +27,39 @@ public: // 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; + 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); + bool operator==(const PointF &other); - PointF operator+(const PointF& other); - PointF operator-(const PointF& other); + 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); + 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); + PointF &operator+=(PointF &other); + PointF &operator-=(PointF &other); - void show(); + 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 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); +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 index 617ac4f9f..6af597192 100644 --- a/sources/shiboken6/tests/libsample/polygon.cpp +++ b/sources/shiboken6/tests/libsample/polygon.cpp @@ -1,34 +1,26 @@ // 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 "polygon.h" -using namespace std; - -Polygon::Polygon(double x, double y) +Polygon::Polygon(double x, double y) : m_points({Point(x, y)}) { - m_points.push_back(Point(x, y)); } -Polygon::Polygon(Point point) +Polygon::Polygon(Point point) : m_points({point}) { - m_points.push_back(point); } -Polygon::Polygon(PointList points) +Polygon::Polygon(PointList points) : m_points(points) { - m_points = points; } -void -Polygon::addPoint(Point point) +void Polygon::addPoint(Point point) { m_points.push_back(point); } -Polygon -Polygon::doublePolygonScale(Polygon polygon) +Polygon Polygon::doublePolygonScale(Polygon polygon) { Polygon result; for (const auto &point : polygon.points()) @@ -36,15 +28,12 @@ Polygon::doublePolygonScale(Polygon polygon) return result; } -void -Polygon::stealOwnershipFromPython(Point* point) +void Polygon::stealOwnershipFromPython(Point *point) { delete point; } -void -Polygon::stealOwnershipFromPython(Polygon* polygon) +void Polygon::stealOwnershipFromPython(Polygon *polygon) { delete polygon; } - diff --git a/sources/shiboken6/tests/libsample/polygon.h b/sources/shiboken6/tests/libsample/polygon.h index 9a7586d24..2424ddd51 100644 --- a/sources/shiboken6/tests/libsample/polygon.h +++ b/sources/shiboken6/tests/libsample/polygon.h @@ -4,38 +4,36 @@ #ifndef POLYGON_H #define POLYGON_H -#include <list> +#include "libsamplemacros.h" #include "point.h" -#include "libsamplemacros.h" +#include <list> -class LIBSAMPLE_API Polygon +class LIBSAMPLE_API Polygon // should be moveable { public: using PointList = std::list<Point>; - Polygon() {} + Polygon() noexcept = default; Polygon(double x, double y); Polygon(Point point); Polygon(PointList points); - ~Polygon() {} void addPoint(Point point); - inline const PointList& points() const { return m_points; } + 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); + static void stealOwnershipFromPython(Point *point); // This method invalidates the argument to be used in a call to doublePolygonScale(Polygon). - static void stealOwnershipFromPython(Polygon* 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 index 9e9f2a1c6..3b38414f8 100644 --- a/sources/shiboken6/tests/libsample/privatector.h +++ b/sources/shiboken6/tests/libsample/privatector.h @@ -9,22 +9,34 @@ class PrivateCtor { public: - inline static PrivateCtor* instance() + inline static PrivateCtor *instance() { static PrivateCtor self; - self.m_instanciations++; + self.m_instantiations++; return &self; } inline int instanceCalls() { - return m_instanciations; + return m_instantiations; } private: - int m_instanciations; + int m_instantiations = 0; - PrivateCtor() : m_instanciations(0) {} + PrivateCtor() = default; }; -#endif +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 index 84591ccb2..05f18ea53 100644 --- a/sources/shiboken6/tests/libsample/privatedtor.h +++ b/sources/shiboken6/tests/libsample/privatedtor.h @@ -9,27 +9,28 @@ class PrivateDtor { public: - inline static PrivateDtor* instance() + LIBMINIMAL_DISABLE_COPY_MOVE(PrivateDtor) + + inline static PrivateDtor *instance() { static PrivateDtor self; - self.m_instanciations++; + self.m_instantiations++; return &self; } inline int instanceCalls() { - return m_instanciations; + return m_instantiations; } protected: - inline int protectedInstanceCalls() { return m_instanciations; } + inline int protectedInstanceCalls() { return m_instantiations; } private: - int m_instanciations; + int m_instantiations = 0; - PrivateDtor() : m_instanciations(0) {} - PrivateDtor(const PrivateDtor&) {} - ~PrivateDtor() {} + PrivateDtor() noexcept = default; + ~PrivateDtor() = default; }; -#endif +#endif // PRIVATEDTOR_H diff --git a/sources/shiboken6/tests/libsample/protected.cpp b/sources/shiboken6/tests/libsample/protected.cpp index f6cdb3db1..7ab52d22b 100644 --- a/sources/shiboken6/tests/libsample/protected.cpp +++ b/sources/shiboken6/tests/libsample/protected.cpp @@ -5,3 +5,12 @@ 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 index 1efad9044..059cced5d 100644 --- a/sources/shiboken6/tests/libsample/protected.h +++ b/sources/shiboken6/tests/libsample/protected.h @@ -7,26 +7,30 @@ #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() {} + ~ProtectedNonPolymorphic() = default; - inline const char* publicName() { return m_name.c_str(); } + inline const char *publicName() { return m_name.c_str(); } - inline static ProtectedNonPolymorphic* create() { return new ProtectedNonPolymorphic("created"); } + inline static ProtectedNonPolymorphic *create() + { return new ProtectedNonPolymorphic("created"); } protected: - inline const char* protectedName() { return m_name.c_str(); } + 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"; } - inline const char* dataTypeName(void *data = nullptr) const { return "pointer"; } - inline const char* dataTypeName(int data) const { return "integer"; } + 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; @@ -35,15 +39,18 @@ private: class LIBSAMPLE_API ProtectedPolymorphic { public: + LIBMINIMAL_DEFAULT_COPY_MOVE(ProtectedPolymorphic) + explicit ProtectedPolymorphic(const char *name) : m_name(name) {} - virtual ~ProtectedPolymorphic() {} + 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(); } + 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(); } + virtual const char *protectedName() { return m_name.c_str(); } private: std::string m_name; @@ -52,22 +59,29 @@ private: class LIBSAMPLE_API ProtectedPolymorphicDaughter : public ProtectedPolymorphic { public: - explicit ProtectedPolymorphicDaughter(const char *name) : ProtectedPolymorphic(name) {} - inline static ProtectedPolymorphicDaughter* create() { return new ProtectedPolymorphicDaughter("created"); } + 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"); } + explicit ProtectedPolymorphicGrandDaughter(const char *name) : + ProtectedPolymorphicDaughter(name) {} + inline static ProtectedPolymorphicGrandDaughter *create() + { return new ProtectedPolymorphicGrandDaughter("created"); } }; class LIBSAMPLE_API ProtectedVirtualDestructor { public: - ProtectedVirtualDestructor() {} - inline static ProtectedVirtualDestructor* create() { return new ProtectedVirtualDestructor(); } + 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: @@ -79,8 +93,10 @@ private: class LIBSAMPLE_API ProtectedEnumClass { public: - ProtectedEnumClass() {} - virtual ~ProtectedEnumClass() {} + LIBMINIMAL_DISABLE_COPY_MOVE(ProtectedEnumClass) + + ProtectedEnumClass() noexcept = default; + virtual ~ProtectedEnumClass() = default; enum PublicEnum { PublicItem0, PublicItem1 @@ -90,36 +106,33 @@ protected: ProtectedItem0, ProtectedItem1 }; - ProtectedEnum callProtectedEnumMethod(ProtectedEnum in) { return protectedEnumMethod(in); } - inline PublicEnum callPublicEnumMethod(PublicEnum in) { return publicEnumMethod(in); } + 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() - : protectedValueTypeProperty(Point(0, 0)), - protectedProperty(0), - protectedEnumProperty(Event::NO_EVENT), - protectedValueTypePointerProperty(nullptr), - protectedObjectTypeProperty(nullptr) - {} + ProtectedProperty() = default; + protected: // This is deliberately the first member to test wrapper registration // for value type members sharing the same memory address. - Point protectedValueTypeProperty; - int protectedProperty; + Point protectedValueTypeProperty{0, 0}; + int protectedProperty = 0; std::list<int> protectedContainerProperty; - Event::EventType protectedEnumProperty; - Point* protectedValueTypePointerProperty; - ObjectType* protectedObjectTypeProperty; + Event::EventType protectedEnumProperty = Event::NO_EVENT; + Point *protectedValueTypePointerProperty = nullptr; + ObjectType *protectedObjectTypeProperty = nullptr; }; -LIBSAMPLE_API inline ProtectedProperty* createProtectedProperty() { +LIBSAMPLE_API inline ProtectedProperty *createProtectedProperty() +{ return new ProtectedProperty; } diff --git a/sources/shiboken6/tests/libsample/rect.h b/sources/shiboken6/tests/libsample/rect.h index ca3b1912d..53296d26c 100644 --- a/sources/shiboken6/tests/libsample/rect.h +++ b/sources/shiboken6/tests/libsample/rect.h @@ -9,53 +9,46 @@ class LIBSAMPLE_API Rect { public: - Rect() - { - m_left = m_top = 0; - m_right = m_bottom = -1; - } - Rect(int left, int top, int right, int bottom) + 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() {} + ~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; - int m_top; - int m_right; - int m_bottom; + int m_left = 0; + int m_top = 0; + int m_right = -1; + int m_bottom = -1; }; class LIBSAMPLE_API RectF { public: - RectF() - { - m_left = m_top = 0; - m_right = m_bottom = -1; - } - RectF(int left, int top, int right, int bottom) + 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) - { - m_left = other.left(); - m_top = other.top(); - m_right = other.right(); - m_bottom = other.bottom(); - } - ~RectF() {} + 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; - double m_top; - double m_right; - double m_bottom; + 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 index d3c1f882c..29dcfc054 100644 --- a/sources/shiboken6/tests/libsample/reference.cpp +++ b/sources/shiboken6/tests/libsample/reference.cpp @@ -1,53 +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 <iostream> #include "reference.h" -using namespace std; +#include <iostream> + +void Reference::show() const +{ + std::cout << "Reference.objId: " << m_objId << ", address: " << this; +} -void -Reference::show() const +Reference &Reference::returnMySecondArg(int, Reference &ref) { - cout << "Reference.objId: " << m_objId << ", address: " << this; + return ref; } -int -Reference::usesReferenceVirtual(Reference& r, int inc) +int Reference::usesReferenceVirtual(Reference &r, int inc) { return r.m_objId + inc; } -int -Reference::usesConstReferenceVirtual(const Reference& r, int inc) +int Reference::usesConstReferenceVirtual(const Reference &r, int inc) { return r.m_objId + inc; } -int -Reference::callUsesReferenceVirtual(Reference& r, int inc) +int Reference::callUsesReferenceVirtual(Reference &r, int inc) { return usesReferenceVirtual(r, inc); } -int -Reference::callUsesConstReferenceVirtual(const Reference& r, int inc) +int Reference::callUsesConstReferenceVirtual(const Reference &r, int inc) { return usesConstReferenceVirtual(r, inc); } -void -Reference::alterReferenceIdVirtual(Reference& r) +void Reference::alterReferenceIdVirtual(Reference &r) { r.setObjId(r.objId() * Reference::multiplier()); } -void -Reference::callAlterReferenceIdVirtual(Reference& r) +void Reference::callAlterReferenceIdVirtual(Reference &r) { alterReferenceIdVirtual(r); } -ObjTypeReference::~ObjTypeReference() +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 index d4b7ce2cf..52818d9ea 100644 --- a/sources/shiboken6/tests/libsample/reference.h +++ b/sources/shiboken6/tests/libsample/reference.h @@ -9,34 +9,37 @@ class LIBSAMPLE_API Reference { public: - explicit Reference(int objId = -1) + LIBMINIMAL_DEFAULT_COPY_MOVE(Reference) + + explicit Reference(int objId = -1) noexcept : m_objId(objId) {} - virtual ~Reference() {} + virtual ~Reference() = default; - inline int objId() { return m_objId; } + 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; } + 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); + 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); + int callUsesReferenceVirtual(Reference &r, int inc); + int callUsesConstReferenceVirtual(const Reference &r, int inc); - virtual void alterReferenceIdVirtual(Reference& r); - void callAlterReferenceIdVirtual(Reference& r); + 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) { return ref; } + 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; }; @@ -44,13 +47,16 @@ private: class LIBSAMPLE_API ObjTypeReference { public: - ObjTypeReference() {} - ObjTypeReference(const ObjTypeReference&) {} + 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) { return ref; } - virtual ObjTypeReference& justAPureVirtualFunc(ObjTypeReference& ref) = 0; + + 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 index 08b28fae5..669f2ebf0 100644 --- a/sources/shiboken6/tests/libsample/removednamespaces.h +++ b/sources/shiboken6/tests/libsample/removednamespaces.h @@ -46,4 +46,3 @@ namespace RemovedNamespace3 } // namespace UnremovedNamespace #endif // REMOVEDNAMESPACE_H - diff --git a/sources/shiboken6/tests/libsample/sample.cpp b/sources/shiboken6/tests/libsample/sample.cpp index 7437a341b..5b5f8588b 100644 --- a/sources/shiboken6/tests/libsample/sample.cpp +++ b/sources/shiboken6/tests/libsample/sample.cpp @@ -15,7 +15,7 @@ int sample::value() const return m_value; } -bool operator==(const sample&s1, const sample&s2) +bool operator==(const sample &s1, const sample &s2) { return s1.value() == s2.value(); } diff --git a/sources/shiboken6/tests/libsample/sample.h b/sources/shiboken6/tests/libsample/sample.h index 756b4687e..27909571a 100644 --- a/sources/shiboken6/tests/libsample/sample.h +++ b/sources/shiboken6/tests/libsample/sample.h @@ -20,9 +20,9 @@ namespace sample }; // shiboken must not generate richcompare for namespace sample - LIBSAMPLE_API bool operator==(const sample&s1, const sample&s2); + LIBSAMPLE_API bool operator==(const sample &s1, const sample &s2); const int INT_CONSTANT = 42; } -#endif +#endif // SAMPLE_H diff --git a/sources/shiboken6/tests/libsample/samplenamespace.cpp b/sources/shiboken6/tests/libsample/samplenamespace.cpp index bb38e66c9..eae5af2d2 100644 --- a/sources/shiboken6/tests/libsample/samplenamespace.cpp +++ b/sources/shiboken6/tests/libsample/samplenamespace.cpp @@ -1,12 +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 <iostream> -#include <cstdlib> -#include <time.h> #include "samplenamespace.h" -using namespace std; +#include <iostream> +#include <cstdlib> +#include <ctime> namespace SampleNamespace { @@ -18,91 +17,81 @@ SomeClass::PublicScopedEnum SomeClass::protectedMethodReturningPublicScopedEnum( return PublicScopedEnum::v1; } -OutValue -enumInEnumOut(InValue in) +OutValue enumInEnumOut(InValue in) { - OutValue retval; + auto retval = OutValue(-1); switch(in) { - case ZeroIn: - retval = ZeroOut; - break; - case OneIn: - retval = OneOut; - break; - case TwoIn: - retval = TwoOut; - break; - default: - retval = (OutValue) -1; + case ZeroIn: + retval = ZeroOut; + break; + case OneIn: + retval = OneOut; + break; + case TwoIn: + retval = TwoOut; + break; + default: + break; } return retval; } -Option -enumArgumentWithDefaultValue(Option opt) +Option enumArgumentWithDefaultValue(Option opt) { return opt; } -int -getNumber(Option opt) +int getNumber(Option opt) { int retval; switch(opt) { - case RandomNumber: - retval = rand() % 100; - break; - case UnixTime: - retval = (int) time(nullptr); - break; - default: - retval = 0; + 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* data, unsigned int size, const char* format) +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) +int enumItemAsDefaultValueToIntArgument(int value) { return value; } -void -forceDecisorSideA(ObjectType* object) +void forceDecisorSideA(ObjectType *) { } -void -forceDecisorSideA(const Point& pt, const Str& text, ObjectType* object) +void forceDecisorSideA(const Point &, const Str &, ObjectType *) { } -void -forceDecisorSideB(int a, ObjectType* object) +void forceDecisorSideB(int, ObjectType *) { } -void -forceDecisorSideB(int a, const Point& pt, const Str& text, ObjectType* object) +void forceDecisorSideB(int, const Point &, const Str &, ObjectType *) { } -double -passReferenceToValueType(const Point& point, double multiplier) +double passReferenceToValueType(const Point &point, double multiplier) { return (point.x() + point.y()) * multiplier; } -int -passReferenceToObjectType(const ObjectType& obj, int multiplier) +int passReferenceToObjectType(const ObjectType &obj, int multiplier) { return obj.objectName().size() * multiplier; } diff --git a/sources/shiboken6/tests/libsample/samplenamespace.h b/sources/shiboken6/tests/libsample/samplenamespace.h index 711f98c6c..99a0787ee 100644 --- a/sources/shiboken6/tests/libsample/samplenamespace.h +++ b/sources/shiboken6/tests/libsample/samplenamespace.h @@ -4,12 +4,13 @@ #ifndef SAMPLENAMESPACE_H #define SAMPLENAMESPACE_H -#include <list> #include "libsamplemacros.h" #include "str.h" #include "point.h" #include "objecttype.h" +#include <list> + // Anonymous global enum enum { AnonymousGlobalEnum_Value0, @@ -19,6 +20,25 @@ enum { 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, @@ -55,7 +75,8 @@ 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 void doSomethingWithArray(const unsigned char *data, unsigned int size, + const char *format = nullptr); LIBSAMPLE_API int enumItemAsDefaultValueToIntArgument(int value = ZeroIn); @@ -70,7 +91,10 @@ public: class OkThisIsRecursiveEnough { public: - virtual ~OkThisIsRecursiveEnough() {} + LIBMINIMAL_DISABLE_COPY_MOVE(OkThisIsRecursiveEnough) + + OkThisIsRecursiveEnough() noexcept = default; + virtual ~OkThisIsRecursiveEnough() = default; enum NiceEnum { NiceValue1, NiceValue2 }; @@ -79,8 +103,9 @@ public: NiceClassValue1, NiceClassValue2 }; - inline int someMethod(SomeInnerClass*) { return 0; } - virtual OkThisIsRecursiveEnough* someVirtualMethod(OkThisIsRecursiveEnough* arg) { return arg; } + inline int someMethod(SomeInnerClass *) { return 0; } + virtual OkThisIsRecursiveEnough *someVirtualMethod(OkThisIsRecursiveEnough *arg) + { return arg; } }; protected: enum ProtectedEnum { @@ -100,7 +125,8 @@ protected: PublicScopedEnum protectedMethodReturningPublicScopedEnum() const; }; -LIBSAMPLE_API inline int enumAsInt(SomeClass::PublicScopedEnum value) { return static_cast<int>(value); } +LIBSAMPLE_API inline int enumAsInt(SomeClass::PublicScopedEnum value) +{ return static_cast<int>(value); } class DerivedFromNamespace : public SomeClass::SomeInnerClass::OkThisIsRecursiveEnough { @@ -109,29 +135,30 @@ public: // only to cause namespace confusion // enum SampleNamespace { // }; - virtual OkThisIsRecursiveEnough* someVirtualMethod(OkThisIsRecursiveEnough* arg) { return arg; } + 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 = 0); +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); +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); +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); +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.h b/sources/shiboken6/tests/libsample/sbkdate.h index d102f62b8..5e1dd0b84 100644 --- a/sources/shiboken6/tests/libsample/sbkdate.h +++ b/sources/shiboken6/tests/libsample/sbkdate.h @@ -9,7 +9,7 @@ class LIBSAMPLE_API SbkDate { public: - SbkDate(int d, int m, int y); + explicit SbkDate(int d, int m, int y); int day() const; int month() const; @@ -22,4 +22,3 @@ private: }; #endif // SBKDATE_H - diff --git a/sources/shiboken6/tests/libsample/simplefile.cpp b/sources/shiboken6/tests/libsample/simplefile.cpp index e0e42e268..e51b14088 100644 --- a/sources/shiboken6/tests/libsample/simplefile.cpp +++ b/sources/shiboken6/tests/libsample/simplefile.cpp @@ -1,83 +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 <stdlib.h> -#include <string.h> -#include <fstream> #include "simplefile.h" -class SimpleFile_p +#include <cstdlib> +#include <cstdio> +#include <string> +#include <filesystem> + +class SimpleFilePrivate { public: - SimpleFile_p(const char* filename) : m_descriptor(nullptr), m_size(0) - { - m_filename = strdup(filename); - } + LIBMINIMAL_DISABLE_COPY_MOVE(SimpleFilePrivate) - ~SimpleFile_p() - { - free(m_filename); - } + SimpleFilePrivate(const char *filename) : m_filename(filename) {} + ~SimpleFilePrivate() = default; - char* m_filename; - FILE* m_descriptor; - long m_size; + std::string m_filename; + FILE *m_descriptor = nullptr; + long m_size = 0; }; -SimpleFile::SimpleFile(const char* filename) +SimpleFile::SimpleFile(const char *filename) : + p(std::make_unique<SimpleFilePrivate>(filename)) { - p = new SimpleFile_p(filename); } SimpleFile::~SimpleFile() { close(); - delete p; } -const char* SimpleFile::filename() +const char *SimpleFile::filename() { - return p->m_filename; + return p->m_filename.c_str(); } -long SimpleFile::size() +long SimpleFile::size() const { return p->m_size; } -bool -SimpleFile::open() +bool SimpleFile::open() { - if ((p->m_descriptor = fopen(p->m_filename, "rb")) == nullptr) + auto *descriptor = std::fopen(p->m_filename.c_str(), "rb"); + if (descriptor == nullptr) return false; - fseek(p->m_descriptor, 0, SEEK_END); - p->m_size = ftell(p->m_descriptor); - rewind(p->m_descriptor); + 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() +void SimpleFile::close() { - if (p->m_descriptor) { - fclose(p->m_descriptor); + if (p->m_descriptor != nullptr) { + std::fclose(p->m_descriptor); p->m_descriptor = nullptr; } } -bool -SimpleFile::exists() const +bool SimpleFile::exists() const { - std::ifstream ifile(p->m_filename); - return !ifile.fail(); + return std::filesystem::exists(std::filesystem::path(p->m_filename)); } -bool -SimpleFile::exists(const char* filename) +bool SimpleFile::exists(const char *filename) { - std::ifstream ifile(filename); - return !ifile.fail(); + return std::filesystem::exists(std::filesystem::path(filename)); } - diff --git a/sources/shiboken6/tests/libsample/simplefile.h b/sources/shiboken6/tests/libsample/simplefile.h index 765b46095..e4612c944 100644 --- a/sources/shiboken6/tests/libsample/simplefile.h +++ b/sources/shiboken6/tests/libsample/simplefile.h @@ -5,27 +5,30 @@ #define SIMPLEFILE_H #include "libsamplemacros.h" -#include <stdio.h> -class SimpleFile_p; +#include <memory> + +class SimpleFilePrivate; class LIBSAMPLE_API SimpleFile { public: - explicit SimpleFile(const char* filename); + LIBMINIMAL_DISABLE_COPY(SimpleFile) + LIBMINIMAL_DEFAULT_MOVE(SimpleFile) + + explicit SimpleFile(const char *filename); ~SimpleFile(); - const char* filename(); - long size(); + const char *filename(); + long size() const; bool open(); void close(); bool exists() const; - static bool exists(const char* filename); + static bool exists(const char *filename); private: - SimpleFile_p *p; + std::unique_ptr<SimpleFilePrivate> p; }; #endif // SIMPLEFILE_H - diff --git a/sources/shiboken6/tests/libsample/size.cpp b/sources/shiboken6/tests/libsample/size.cpp index 5edb8a77b..0291d6e86 100644 --- a/sources/shiboken6/tests/libsample/size.cpp +++ b/sources/shiboken6/tests/libsample/size.cpp @@ -1,14 +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 <iostream> #include "size.h" -using namespace std; +#include <iostream> -void -Size::show() const +void Size::show() const { - cout << "(width: " << m_width << ", height: " << m_height << ")"; + std::cout << "(width: " << m_width << ", height: " << m_height << ")"; } - diff --git a/sources/shiboken6/tests/libsample/size.h b/sources/shiboken6/tests/libsample/size.h index ac57065af..2d194e96b 100644 --- a/sources/shiboken6/tests/libsample/size.h +++ b/sources/shiboken6/tests/libsample/size.h @@ -9,23 +9,26 @@ class LIBSAMPLE_API Size { public: - Size(double width = 0.0, double height = 0.0) : m_width(width), m_height(height) {} - ~Size() {} + LIBMINIMAL_DEFAULT_COPY_MOVE(Size) - inline double width() { return m_width; } + 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() { return m_height; } + 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) + inline bool operator<(const Size &other) { return calculateArea() < other.calculateArea(); } - inline bool operator>(const Size& other) + 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 @@ -37,7 +40,7 @@ public: return a > b; } - inline bool operator<=(const Size& other) + inline bool operator<=(const Size &other) { // See comments for operator>() double a = calculateArea(); @@ -45,7 +48,7 @@ public: return a <= b; } - inline bool operator>=(const Size& other) + inline bool operator>=(const Size &other) { return calculateArea() >= other.calculateArea(); } @@ -56,28 +59,28 @@ public: inline bool operator>=(double area) { return calculateArea() >= area; } // Arithmetic Operators - inline Size& operator+=(const Size& s) + inline Size &operator+=(const Size &s) { m_width += s.m_width; m_height += s.m_height; return *this; } - inline Size& operator-=(const Size& s) + inline Size &operator-=(const Size &s) { m_width -= s.m_width; m_height -= s.m_height; return *this; } - inline Size& operator*=(double mult) + inline Size &operator*=(double mult) { m_width *= mult; m_height *= mult; return *this; } - inline Size& operator/=(double div) + inline Size &operator/=(double div) { m_width /= div; m_height /= div; @@ -89,11 +92,11 @@ public: // External operators friend inline bool operator==(const Size&, const Size&); friend inline bool operator!=(const Size&, const Size&); - friend inline const Size operator+(const Size&, const Size&); - friend inline const Size operator-(const Size&, const Size&); - friend inline const Size operator*(const Size&, double); - friend inline const Size operator*(double, const Size&); - friend inline const Size operator/(const Size&, double); + friend inline 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&); @@ -108,70 +111,71 @@ private: }; // Comparison Operators -inline bool operator!=(const Size& s1, const Size& s2) +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) +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) +inline bool operator<(double area, const Size &s) { return area < s.calculateArea(); } -inline bool operator>(double area, const Size& s) +inline bool operator>(double area, const Size &s) { return area > s.calculateArea(); } -inline bool operator<=(double area, const Size& s) +inline bool operator<=(double area, const Size &s) { return area <= s.calculateArea(); } -inline bool operator>=(double area, const Size& s) +inline bool operator>=(double area, const Size &s) { return area >= s.calculateArea(); } // Arithmetic Operators -inline const Size operator+(const Size& s1, const Size& s2) +inline Size operator+(const Size &s1, const Size &s2) { return Size(s1.m_width + s2.m_width, s1.m_height + s2.m_height); } -inline const Size operator-(const Size& s1, const Size& s2) +inline Size operator-(const Size &s1, const Size &s2) { return Size(s1.m_width - s2.m_width, s1.m_height - s2.m_height); } -inline const Size operator*(const Size& s, double mult) +inline Size operator*(const Size &s, double mult) { return Size(s.m_width * mult, s.m_height * mult); } -inline const Size operator*(double mult, const Size& s) +inline Size operator*(double mult, const Size &s) { return Size(s.m_width * mult, s.m_height * mult); } -inline const Size operator/(const Size& s, double div) +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: - SizeF(real width, real height) : m_width(width), m_height(height) {} - real width() { return m_width; } - real height() { return m_height; } + 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; @@ -179,4 +183,3 @@ private: }; #endif // SIZE_H - diff --git a/sources/shiboken6/tests/libsample/sometime.cpp b/sources/shiboken6/tests/libsample/sometime.cpp index 7f9bc24c3..ad9a0d81c 100644 --- a/sources/shiboken6/tests/libsample/sometime.cpp +++ b/sources/shiboken6/tests/libsample/sometime.cpp @@ -2,10 +2,10 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "sometime.h" -#include <stdio.h> -void -Time::setTime() +#include <cstdio> + +void Time::setTime() { m_hour = 0; m_minute = 0; @@ -14,8 +14,7 @@ Time::setTime() m_is_null = true; } -void -Time::setTime(int h, int m, int s, int ms) +void Time::setTime(int h, int m, int s, int ms) { m_hour = h; m_minute = m; @@ -24,15 +23,12 @@ Time::setTime(int h, int m, int s, int ms) m_is_null = false; } - -Time::NumArgs -Time::somethingCompletelyDifferent() +Time::NumArgs Time::somethingCompletelyDifferent() { return ZeroArgs; } -Time::NumArgs -Time::somethingCompletelyDifferent(int h, int m, ImplicitConv ic, ObjectType* type) +Time::NumArgs Time::somethingCompletelyDifferent(int, int, ImplicitConv ic, ObjectType *type) { if (type) return FourArgs; @@ -41,18 +37,17 @@ Time::somethingCompletelyDifferent(int h, int m, ImplicitConv ic, ObjectType* ty return ThreeArgs; } -Str -Time::toString() const +Str Time::toString() const { if (m_is_null) return Str(); char buffer[13]; - sprintf(buffer, "%02d:%02d:%02d.%03d", m_hour, m_minute, m_second, m_msec); + 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 +bool Time::operator==(const Time &other) const { return m_hour == other.m_hour && m_minute == other.m_minute @@ -61,8 +56,7 @@ Time::operator==(const Time& other) const && m_is_null == other.m_is_null; } -bool -Time::operator!=(const Time& other) const +bool Time::operator!=(const Time &other) const { return !operator==(other); } @@ -71,4 +65,3 @@ Time::operator Str() const { return Time::toString(); } - diff --git a/sources/shiboken6/tests/libsample/sometime.h b/sources/shiboken6/tests/libsample/sometime.h index 0e3442db0..575d4b136 100644 --- a/sources/shiboken6/tests/libsample/sometime.h +++ b/sources/shiboken6/tests/libsample/sometime.h @@ -12,6 +12,8 @@ class LIBSAMPLE_API Time { public: + LIBMINIMAL_DEFAULT_COPY_MOVE(Time) + enum NumArgs { ZeroArgs, TwoArgs, @@ -19,14 +21,12 @@ public: FourArgs }; - Time() - : m_hour(0), m_minute(0), m_second(0), m_msec(0), m_is_null(true) - {} - Time(int h, int m, int s = 0, int ms = 0) - : m_hour(h), m_minute(m), m_second(s), m_msec(ms), m_is_null(false) + 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() {} + ~Time() = default; inline bool isNull() const { return m_is_null; } @@ -48,20 +48,19 @@ public: ObjectType *type = nullptr); Str toString() const; - bool operator==(const Time& other) const; - bool operator!=(const Time& other) 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; - int m_minute; - int m_second; - int m_msec; + int m_hour = 0; + int m_minute = 0; + int m_second = 0; + int m_msec = 0; - bool m_is_null; + 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 index f8d1b726f..742c0bb01 100644 --- a/sources/shiboken6/tests/libsample/str.cpp +++ b/sources/shiboken6/tests/libsample/str.cpp @@ -2,91 +2,73 @@ // 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> -using namespace std; - -Str::Str(const Str& s) -{ - init(s.cstring()); -} - Str::Str(char c) { char str[2] = { c, 0 }; init(str); } -Str::Str(const char* cstr) +Str::Str(const char *cstr) { init(cstr); } -void -Str::init(const char* cstr) +void Str::init(const char *cstr) { if (cstr) m_str = cstr; } -Str::~Str() -{ -} - -Str -Str::arg(const Str& s) const +Str Str::arg(const Str &s) const { size_t idx = m_str.find_first_of("%VAR"); - if (idx == std::string::npos) { + if (idx == std::string::npos) return *this; - } else { - std::string result = m_str; - result.replace(idx, 4, s.m_str); - return result.c_str(); - } + + std::string result = m_str; + result.replace(idx, 4, s.m_str); + return result.c_str(); } -Str& -Str::append(const Str& s) +Str &Str::append(const Str &s) { m_str += s.m_str; return *this; } -Str& -Str::prepend(const Str& s) +Str &Str::prepend(const Str &s) { m_str = s.m_str + m_str; return *this; } -const char* -Str::cstring() const +const char *Str::cstring() const { return m_str.c_str(); } -int -Str::toInt(bool* ok, int base) const +int Str::toInt(bool *ok, int base) const { - bool my_ok; int result = 0; - istringstream conv(m_str); + 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; + case 8: + conv >> std::oct >> result; + break; + case 10: + conv >> std::dec >> result; + break; + case 16: + conv >> std::hex >> result; + break; } - my_ok = istringstream::eofbit & conv.rdstate(); + const bool my_ok = std::istringstream::eofbit & conv.rdstate(); if (!my_ok) result = 0; if (ok) @@ -94,20 +76,17 @@ Str::toInt(bool* ok, int base) const return result; } -void -Str::show() const +void Str::show() const { - printf("%s", cstring()); + std::printf("%s", cstring()); } -char -Str::get_char(int pos) const +char Str::get_char(int pos) const { return m_str[pos]; } -bool -Str::set_char(int pos, char ch) +bool Str::set_char(int pos, char ch) { m_str[pos] = ch; return true; @@ -115,42 +94,42 @@ Str::set_char(int pos, char ch) Str Str::operator+(int number) const { - ostringstream in; + std::ostringstream in; in << m_str << number; return in.str().c_str(); } -bool Str::operator==(const Str& other) const +bool Str::operator==(const Str &other) const { return m_str == other.m_str; } -Str operator+(int number, const Str& str) +Str operator+(int number, const Str &str) { - ostringstream in; + std::ostringstream in; in << number << str.m_str; return in.str().c_str(); } -bool Str::operator<(const Str& other) const +bool Str::operator<(const Str &other) const { return m_str < other.m_str; } -unsigned int strHash(const Str& str) +unsigned int strHash(const Str &str) { unsigned int result = 0; for (char c : str.m_str) - result = 5u * result + unsigned(c); + result = 5U * result + unsigned(c); return result; } -void changePStr(PStr* pstr, const char* suffix) +void changePStr(PStr *pstr, const char *suffix) { pstr->append(suffix); } -void duplicatePStr(PStr* pstr) +void duplicatePStr(PStr *pstr) { if (!pstr) return; diff --git a/sources/shiboken6/tests/libsample/str.h b/sources/shiboken6/tests/libsample/str.h index 0b75348c7..6b3386cef 100644 --- a/sources/shiboken6/tests/libsample/str.h +++ b/sources/shiboken6/tests/libsample/str.h @@ -3,24 +3,23 @@ #ifndef STR_H #define STR_H -#include <string> #include "libsamplemacros.h" +#include <string> + class LIBSAMPLE_API Str { public: - Str(const Str& s); Str(char c); - Str(const char* cstr = ""); - ~Str(); + Str(const char *cstr = ""); - Str arg(const Str& s) const; + Str arg(const Str &s) const; - Str& append(const Str& s); - Str& prepend(const Str& s); + Str &append(const Str &s); + Str &prepend(const Str &s); - const char* cstring() const; + const char *cstring() const; char get_char(int pos) const; bool set_char(int pos, char ch); @@ -28,26 +27,26 @@ public: void show() const; - inline int size() const { return m_str.size(); } + 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; + bool operator==(const Str &other) const; + bool operator<(const Str &other) const; private: - void init(const char* cstr); + 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); + 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); +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 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 index 845b83a0d..5840a0516 100644 --- a/sources/shiboken6/tests/libsample/strlist.cpp +++ b/sources/shiboken6/tests/libsample/strlist.cpp @@ -5,15 +5,13 @@ #include <algorithm> -bool -StrList::operator==(const std::list<Str>& other) const +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 StrList::join(const Str &sep) const { Str result; const auto i1 = begin(); diff --git a/sources/shiboken6/tests/libsample/strlist.h b/sources/shiboken6/tests/libsample/strlist.h index 52b7e5951..01865a5b4 100644 --- a/sources/shiboken6/tests/libsample/strlist.h +++ b/sources/shiboken6/tests/libsample/strlist.h @@ -4,10 +4,10 @@ #ifndef STRLIST_H #define STRLIST_H -#include <list> +#include "libsamplemacros.h" #include "str.h" -#include "libsamplemacros.h" +#include <list> class LIBSAMPLE_API StrList : public std::list<Str> { @@ -19,20 +19,29 @@ public: ListOfStrCtor }; - inline StrList() : m_ctorUsed(NoParamsCtor) {} - inline explicit StrList(const Str& str) : m_ctorUsed(StrCtor) { push_back(str); } - inline StrList(const StrList& lst) : std::list<Str>(lst), m_ctorUsed(CopyCtor) {} - inline StrList(const std::list<Str>& lst) : std::list<Str>(lst), m_ctorUsed(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; - inline void append(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); } - 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; } - CtorEnum constructorUsed() { return m_ctorUsed; } private: - CtorEnum m_ctorUsed; + CtorEnum m_ctorUsed = NoParamsCtor; }; using PStrList = StrList; diff --git a/sources/shiboken6/tests/libsample/templateptr.cpp b/sources/shiboken6/tests/libsample/templateptr.cpp index 44be79cfc..a73f78417 100644 --- a/sources/shiboken6/tests/libsample/templateptr.cpp +++ b/sources/shiboken6/tests/libsample/templateptr.cpp @@ -3,6 +3,6 @@ #include "templateptr.h" -void TemplatePtr::dummy(std::list<std::pair<BlackBox *, BlackBox *> > & items) +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 index e8145b90d..bf230c363 100644 --- a/sources/shiboken6/tests/libsample/templateptr.h +++ b/sources/shiboken6/tests/libsample/templateptr.h @@ -4,15 +4,16 @@ #ifndef TEMPLATEPTR_H #define TEMPLATEPTR_H -#include <utility> -#include <list> #include "libsamplemacros.h" #include "blackbox.h" +#include <utility> +#include <list> + class LIBSAMPLE_API TemplatePtr { public: - void dummy(std::list<std::pair<BlackBox *, BlackBox *> > & items); + void dummy(std::list<std::pair<BlackBox *, BlackBox *> > &items); }; -#endif +#endif // TEMPLATEPTR_H diff --git a/sources/shiboken6/tests/libsample/transform.cpp b/sources/shiboken6/tests/libsample/transform.cpp index d23cb6179..5ccf5d1ed 100644 --- a/sources/shiboken6/tests/libsample/transform.cpp +++ b/sources/shiboken6/tests/libsample/transform.cpp @@ -4,37 +4,25 @@ #include "transform.h" -#ifdef _WIN32 -#include <math.h> -#include <float.h> -static inline bool isfinite(double a) { return _finite(a); } -#else #include <cmath> -#endif -using namespace std; - -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) +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 (isfinite(w) && fabs(w) > 1e-10) - { + if (std::isfinite(w) && fabs(w) > 1e-10) { if (okay) *okay = true; - return Point(x / w, y / w); - } - else - { - if (okay) - *okay = false; - return Point(); + 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 index a39445c40..34ebf40d3 100644 --- a/sources/shiboken6/tests/libsample/transform.h +++ b/sources/shiboken6/tests/libsample/transform.h @@ -9,12 +9,10 @@ #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); +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/valueandvirtual.h b/sources/shiboken6/tests/libsample/valueandvirtual.h index d5a9be6b5..799e11e40 100644 --- a/sources/shiboken6/tests/libsample/valueandvirtual.h +++ b/sources/shiboken6/tests/libsample/valueandvirtual.h @@ -4,19 +4,22 @@ #ifndef VALUEANDVIRTUAL_H #define VALUEANDVIRTUAL_H +#include "libsamplemacros.h" + class ValueAndVirtual { public: - ValueAndVirtual(int id) : m_id(id) {} - ValueAndVirtual(const ValueAndVirtual &other) { m_id = other.m_id; } + 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() { return m_id; } - virtual ~ValueAndVirtual() {}; + 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 index 6c7b4a004..515564664 100644 --- a/sources/shiboken6/tests/libsample/virtualmethods.cpp +++ b/sources/shiboken6/tests/libsample/virtualmethods.cpp @@ -5,14 +5,12 @@ int VirtualDtor::dtor_called = 0; -double -VirtualMethods::virtualMethod0(Point pt, int val, Complex cpx, bool b) +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) +bool VirtualMethods::createStr(const char *text, Str *&ret) { if (!text) { ret = nullptr; @@ -23,8 +21,7 @@ VirtualMethods::createStr(const char* text, Str*& ret) return true; } -void -VirtualMethods::getMargins(int* left, int* top, int* right, int* bottom) const +void VirtualMethods::getMargins(int *left, int *top, int *right, int *bottom) const { *left = m_left; *top = m_top; @@ -32,6 +29,11 @@ VirtualMethods::getMargins(int* left, int* top, int* right, int* bottom) const *bottom = m_bottom; } +int VirtualMethods::recursionOnModifiedVirtual(Str) const +{ + return 0; +} + const Str & VirtualMethods::returnConstRef() const { static const Str result; diff --git a/sources/shiboken6/tests/libsample/virtualmethods.h b/sources/shiboken6/tests/libsample/virtualmethods.h index c6ff560fc..b7172ad0d 100644 --- a/sources/shiboken6/tests/libsample/virtualmethods.h +++ b/sources/shiboken6/tests/libsample/virtualmethods.h @@ -17,11 +17,10 @@ class LIBSAMPLE_API VirtualMethods { public: - VirtualMethods(Str name = "VirtualMethods") : m_name(name) - { - m_left = m_top = m_right = m_bottom = 0; - } - virtual ~VirtualMethods() {} + 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) @@ -61,12 +60,14 @@ public: 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); } + 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; } + 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) { @@ -75,16 +76,16 @@ public: 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 + 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 { return 0; } + virtual int recursionOnModifiedVirtual(Str arg) const; int callRecursionOnModifiedVirtual(Str arg) const { return recursionOnModifiedVirtual(arg); } - virtual const Str & returnConstRef() const; + virtual const Str &returnConstRef() const; virtual int stringViewLength(std::string_view in) const; @@ -94,10 +95,10 @@ protected: private: Str m_name; - int m_left; - int m_top; - int m_right; - int m_bottom; + int m_left = 0; + int m_top = 0; + int m_right = 0; + int m_bottom = 0; }; class LIBSAMPLE_API VirtualDaughter : public VirtualMethods @@ -128,10 +129,12 @@ public: class LIBSAMPLE_API VirtualDtor { public: - VirtualDtor() {} + LIBMINIMAL_DEFAULT_COPY_MOVE(VirtualDtor) + + VirtualDtor() noexcept = default; virtual ~VirtualDtor() { dtor_called++; } - static VirtualDtor* create() { return new VirtualDtor(); } + static VirtualDtor *create() { return new VirtualDtor(); } static int dtorCalled() { return dtor_called; } static void resetDtorCounter() { dtor_called = 0; } @@ -140,4 +143,3 @@ private: }; #endif // VIRTUALMETHODS_H - diff --git a/sources/shiboken6/tests/libsample/voidholder.h b/sources/shiboken6/tests/libsample/voidholder.h index b5e59ba3d..3f0f4d973 100644 --- a/sources/shiboken6/tests/libsample/voidholder.h +++ b/sources/shiboken6/tests/libsample/voidholder.h @@ -9,21 +9,24 @@ class VoidHolder { public: - explicit VoidHolder(void *ptr = nullptr) : m_ptr(ptr) {} - ~VoidHolder() {} - inline void* voidPointer() { return m_ptr; } - inline static void* gimmeMeSomeVoidPointer() + 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(); + static void *pointerToSomething = new VoidHolder(); return pointerToSomething; } void *takeVoidPointer(void *item) { return item; } + private: - void* m_ptr; + void *m_ptr; }; #endif // VOIDHOLDER_H - |