1 files changed, 145 insertions, 0 deletions
diff --git a/sources/shiboken6/tests/libsample/modifications.h b/sources/shiboken6/tests/libsample/modifications.h
new file mode 100644
index 000000000..5bd1bac47
--- /dev/null
+++ b/sources/shiboken6/tests/libsample/modifications.h
@@ -0,0 +1,145 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef MODIFICATIONS_H
+#define MODIFICATIONS_H
+
+#include "libsamplemacros.h"
+#include "point.h"
+#include "oddbool.h"
+
+#include <utility>
+
+class ObjectType;
+
+class LIBSAMPLE_API Modifications
+{
+public:
+    LIBMINIMAL_DISABLE_COPY_MOVE(Modifications)
+
+    Modifications();
+    virtual ~Modifications();
+
+    enum OverloadedModFunc {
+        OverloadedNone,
+        Overloaded_ibid,
+        Overloaded_ibib,
+        Overloaded_ibiP,
+        Overloaded_ibii,
+        Overloaded_ibPP
+    };
+
+    enum TestEnum {
+        TestEnumValue1,
+        TestEnumValue2
+    };
+
+    // those overloaded methods should be heavily modified
+    // to push the overload decisor to its limits
+    OverloadedModFunc overloaded(int a0, bool b0, int c0, double d0);
+    OverloadedModFunc overloaded(int a1, bool b1, int c1, bool d1);
+    OverloadedModFunc overloaded(int a2, bool b2, int c2, Point d2);
+    OverloadedModFunc overloaded(int a3, bool b3, int c3 = 123, int d3 = 456);
+    OverloadedModFunc overloaded(int a4, bool b4, Point c4, Point d4);
+
+    void argRemoval0(int a0, bool a1, int a2 = 123, int a3 = 456);
+    void argRemoval0(int a0, bool a1, int a2, bool a3);
+
+    void argRemoval1(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4),
+                     int a4 = 333);
+    void argRemoval1(int a0, bool a1, int a2, bool a3);
+
+    void argRemoval2(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4),
+                     int a4 = 333);
+
+    void argRemoval3(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4),
+                     int a4 = 333);
+
+    void argRemoval4(int a0, Point a1, bool a2, Point a3 = Point(3, 4), int a4 = 333);
+
+    void argRemoval5(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4),
+                     int a4 = 333);
+    void argRemoval5(int a0, bool a1, int a2, bool a3);
+
+    // 'ok' must be removed and the return value will be changed
+    // to a tuple (PyObject*) containing the expected result plus
+    // the 'ok' value as a Python boolean
+    std::pair<double, double> pointToPair(Point pt, bool *ok);
+
+    // same as 'pointToPair' except that this time 'ok' is the first argument
+    double multiplyPointCoordsPlusValue(bool *ok, Point pt, double value);
+
+    // completely remove 'plus' from the Python side
+    int doublePlus(int value, int plus = 0);
+
+    // the default value for both arguments must be changed in Python
+    int power(int base = 1, int exponent = 0);
+
+    // in Python set argument default value to 10
+    int timesTen(int number);
+
+    // in Python remove the argument default value
+    int increment(int number = 0);
+
+    // don't export this method to Python
+    void exclusiveCppStuff();
+
+    // change the name of this regular method
+    int cppMultiply(int a, int b);
+
+    // change the name of this virtual method
+    virtual const char *className();
+
+    Point sumPointArray(int arraySize, const Point pointArray[]);
+
+    // Replace 'const void*' by 'ByteArray&'.
+    int getSize(const void *data, int size);
+
+    // Mark the argument with a <no-null-pointer/> tag;
+    // the test implementation must expect point never to be null.
+    int sumPointCoordinates(const Point *point);
+
+    // Modify the return value of a virtual method.
+    virtual double differenceOfPointCoordinates(const Point *pt, bool *ok);
+    double callDifferenceOfPointCoordinates(const Point *pt, bool *ok)
+    { return differenceOfPointCoordinates(pt, ok); }
+
+    // Sets an ObjectType in the argument and returns true.
+    bool nonConversionRuleForArgumentWithDefaultValue(ObjectType **object = nullptr);
+    ObjectType *getObject() const { return m_object; }
+
+    // Inject code with a %CONVERTTOPYTHON that receives an user's primitive type.
+    static inline OddBool passOddBool(OddBool ob) { return ob; }
+
+    void setEnumValue(TestEnum e = TestEnumValue1);
+    TestEnum enumValue() const;
+    TestEnum defaultEnumValue() const;
+
+    bool wasGetAttroCalled() const;
+    void notifyGetAttroCalled();
+
+    bool wasSetAttroCalled() const;
+    void notifySetAttroCalled();
+
+private:
+    ObjectType *m_object;
+    TestEnum m_enumValue = TestEnumValue1;
+    bool m_getAttroCalled = false;
+    bool m_setAttroCalled = false;
+};
+
+class LIBSAMPLE_API AbstractModifications : public Modifications
+{
+public:
+    LIBMINIMAL_DISABLE_COPY_MOVE(AbstractModifications)
+
+    AbstractModifications() noexcept = default;
+    ~AbstractModifications() override = default;
+
+    inline bool invert(bool value) { return !value; }
+
+    // completely remove this method in Python
+    virtual void pointlessPureVirtualMethod() = 0;
+};
+
+#endif // MODIFICATIONS_H