Add initial support for std::unique_ptr pointer

Known limitations:
- No rich comparison is generated
- Value conversions caused by passing pointers to derived
  classes do not work.

[ChangeLog][shiboken6] Support for std::unique_ptr pointer has been
added.

Task-number: PYSIDE-454
Change-Id: I5ddf3156bb383598f91bb97d169d1e134918a161
Reviewed-by: Christian Tismer <tismer@stackless.com>

4 files changed, 165 insertions, 0 deletions

diff --git a/sources/shiboken6/tests/libsmart/CMakeLists.txt b/sources/shiboken6/tests/libsmart/CMakeLists.txt
index 52a85e2a1..1a3a989da 100644
--- a/sources/shiboken6/tests/libsmart/CMakeLists.txt
+++ b/sources/shiboken6/tests/libsmart/CMakeLists.txt
@@ -4,6 +4,7 @@ set(libsmart_SRC
 smart.cpp
 stdsharedptrtestbench.cpp
 stdoptionaltestbench.cpp
+stduniqueptrtestbench.cpp
 )
 
 add_library(libsmart SHARED ${libsmart_SRC})
diff --git a/sources/shiboken6/tests/libsmart/smart.h b/sources/shiboken6/tests/libsmart/smart.h
index 0683559d1..9819ef43d 100644
--- a/sources/shiboken6/tests/libsmart/smart.h
+++ b/sources/shiboken6/tests/libsmart/smart.h
@@ -10,5 +10,6 @@
 #include "smart_registry.h"
 #include "stdsharedptrtestbench.h"
 #include "stdoptionaltestbench.h"
+#include "stduniqueptrtestbench.h"
 
 #endif // SMART_H
diff --git a/sources/shiboken6/tests/libsmart/stduniqueptrtestbench.cpp b/sources/shiboken6/tests/libsmart/stduniqueptrtestbench.cpp
new file mode 100644
index 000000000..e1056412c
--- /dev/null
+++ b/sources/shiboken6/tests/libsmart/stduniqueptrtestbench.cpp
@@ -0,0 +1,117 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "stduniqueptrtestbench.h"
+#include "smart_integer.h"
+
+#include <iostream>
+
+std::ostream &operator<<(std::ostream &str, const std::unique_ptr<Integer> &p)
+{
+    str << "unique_ptr<Integer>(";
+    if (p.get())
+        str << p->value();
+    else
+        str << "nullptr";
+    str << ')';
+    return str;
+}
+
+std::ostream &operator<<(std::ostream &str, const std::unique_ptr<int> &p)
+{
+    str << "unique_ptr<int>(";
+    if (p.get())
+        str << *p;
+    else
+        str << "nullptr";
+    str << ')';
+    return str;
+}
+
+StdUniquePtrTestBench::StdUniquePtrTestBench() = default;
+StdUniquePtrTestBench::~StdUniquePtrTestBench() = default;
+
+std::unique_ptr<Integer> StdUniquePtrTestBench::createInteger(int v)
+{
+    auto result = std::make_unique<Integer>();
+    result->setValue(v);
+    return result;
+}
+
+std::unique_ptr<Integer> StdUniquePtrTestBench::createNullInteger()
+{
+    return {};
+}
+
+void StdUniquePtrTestBench::printInteger(const std::unique_ptr<Integer> &p)
+{
+    std::cerr << __FUNCTION__ << ' ' << p << '\n';
+}
+
+void StdUniquePtrTestBench::takeInteger(std::unique_ptr<Integer> p)
+{
+    std::cerr << __FUNCTION__ << ' ' << p << '\n';
+}
+
+std::unique_ptr<int> StdUniquePtrTestBench::createInt(int v)
+{
+    return std::make_unique<int>(v);
+}
+
+std::unique_ptr<int> StdUniquePtrTestBench::createNullInt()
+{
+    return {};
+}
+
+void StdUniquePtrTestBench::printInt(const std::unique_ptr<int> &p)
+{
+    std::cerr << __FUNCTION__ << ' ' << p << '\n';
+}
+
+void StdUniquePtrTestBench::takeInt(std::unique_ptr<int> p)
+{
+    std::cerr << __FUNCTION__ << ' ' << p << '\n';
+}
+
+StdUniquePtrVirtualMethodTester::StdUniquePtrVirtualMethodTester() = default;
+
+StdUniquePtrVirtualMethodTester::~StdUniquePtrVirtualMethodTester() = default;
+
+bool StdUniquePtrVirtualMethodTester::testModifyIntegerByRef(int value, int expectedValue)
+{
+     auto p = std::make_unique<Integer>();
+     p->setValue(value);
+     const int actualValue = doModifyIntegerByRef(p);
+     return p.get() != nullptr && actualValue == expectedValue;
+}
+
+bool StdUniquePtrVirtualMethodTester::testModifyIntegerValue(int value, int expectedValue)
+{
+    auto p = std::make_unique<Integer>();
+    p->setValue(value);
+    const int actualValue = doModifyIntegerByValue(std::move(p));
+    return p.get() == nullptr && actualValue == expectedValue;
+}
+
+bool StdUniquePtrVirtualMethodTester::testCreateInteger(int value, int expectedValue)
+{
+    auto p = doCreateInteger(value);
+    return p.get() != nullptr && p->value() == expectedValue;
+}
+
+std::unique_ptr<Integer> StdUniquePtrVirtualMethodTester::doCreateInteger(int v)
+{
+    auto result = std::make_unique<Integer>();
+    result->setValue(v);
+    return result;
+}
+
+int StdUniquePtrVirtualMethodTester::doModifyIntegerByRef(const std::unique_ptr<Integer> &p)
+{
+    return p->value() + 1;
+}
+
+int StdUniquePtrVirtualMethodTester::doModifyIntegerByValue(std::unique_ptr<Integer> p)
+{
+    return p->value() + 1;
+}
diff --git a/sources/shiboken6/tests/libsmart/stduniqueptrtestbench.h b/sources/shiboken6/tests/libsmart/stduniqueptrtestbench.h
new file mode 100644
index 000000000..8d3db740a
--- /dev/null
+++ b/sources/shiboken6/tests/libsmart/stduniqueptrtestbench.h
@@ -0,0 +1,46 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef STDUNIQUEPTRTESTBENCH_H
+#define STDUNIQUEPTRTESTBENCH_H
+
+#include "libsmartmacros.h"
+
+#include <memory>
+
+class Integer;
+
+class LIB_SMART_API StdUniquePtrTestBench
+{
+public:
+    StdUniquePtrTestBench();
+    ~StdUniquePtrTestBench();
+
+    static std::unique_ptr<Integer> createInteger(int v = 42);
+    static std::unique_ptr<Integer> createNullInteger();
+    static void printInteger(const std::unique_ptr<Integer> &p);
+    static void takeInteger(std::unique_ptr<Integer> p); // Call with std::move()
+
+    static std::unique_ptr<int> createInt(int v = 42);
+    static std::unique_ptr<int> createNullInt();
+    static void printInt(const std::unique_ptr<int> &p);
+    static void takeInt(std::unique_ptr<int> p); // Call with std::move()
+};
+
+class LIB_SMART_API StdUniquePtrVirtualMethodTester
+{
+public:
+    StdUniquePtrVirtualMethodTester();
+    virtual ~StdUniquePtrVirtualMethodTester();
+
+    bool testModifyIntegerByRef(int value, int expectedValue);
+    bool testModifyIntegerValue(int value, int expectedValue);
+    bool testCreateInteger(int value, int expectedValue);
+
+protected:
+    virtual std::unique_ptr<Integer> doCreateInteger(int v);
+    virtual int doModifyIntegerByRef(const std::unique_ptr<Integer> &p);
+    virtual int doModifyIntegerByValue(std::unique_ptr<Integer> p);
+};
+
+#endif // STDUNIQUEPTRTESTBENCH_H