1 files changed, 98 insertions, 0 deletions
diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
index 4c2930234..89d050a21 100644
--- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
@@ -29,7 +29,9 @@
 #include "testresolvetype.h"
 #include <QtTest/QTest>
 #include "testutil.h"
+#include <abstractmetafunction.h>
 #include <abstractmetalang.h>
+#include <abstractmetatype.h>
 #include <typesystem.h>
 
 void TestResolveType::testResolveReturnTypeFromParentScope()
@@ -63,5 +65,101 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
     QVERIFY(meth);
 }
 
+// Helper classes and functions for testing default value fixing.
+// Put the AbstractMetaBuilder into test fixture struct to avoid having
+// to re-parse for each data row.
+
+struct DefaultValuesFixture
+{
+    QSharedPointer<AbstractMetaBuilder> builder;
+
+    AbstractMetaType intType;
+    AbstractMetaType stringType;
+    AbstractMetaType classType;
+    const AbstractMetaClass *klass{};
+};
+
+Q_DECLARE_METATYPE(DefaultValuesFixture)
+Q_DECLARE_METATYPE(AbstractMetaType)
+
+static int populateDefaultValuesFixture(DefaultValuesFixture *fixture)
+{
+    static const char cppCode[] =R"(
+#include <string>
+namespace Namespace {
+class Test
+{
+public:
+    explicit Test(int x = INT_FIELD_1);
+    explicit Test(const std::string &t = std::string(CHAR_FIELD_1));
+
+    static const int INT_FIELD_1 = 42;
+    static const char *CHAR_FIELD_1;
+};
+} // Namespace
+)";
+    static const char xmlCode[] = R"(
+<typesystem package="Foo">
+    <namespace-type name='Namespace'>
+        <value-type name='Test'/>
+    </namespace-type>
+</typesystem>
+)";
+
+    fixture->builder.reset(TestUtil::parse(cppCode, xmlCode, false));
+    if (fixture->builder.isNull())
+        return -1;
+
+    for (const auto &klass : fixture->builder->classes()) {
+        if (klass->name() == u"Test") {
+            fixture->klass = klass;
+            break;
+        }
+    }
+    if (!fixture->klass)
+        return -2;
+
+    fixture->classType = AbstractMetaType(fixture->klass->typeEntry());
+    fixture->classType.decideUsagePattern();
+
+    for (const auto &f : fixture->klass->findFunctions(u"Test"_qs)) {
+        if (f->arguments().size() != 1)
+            return -3;
+        const auto type = f->arguments().constFirst().type();
+        if (type.name() == u"int")
+            fixture->intType = type;
+        else
+            fixture->stringType = type;
+    }
+    return 0;
+}
+
+void TestResolveType::testFixDefaultArguments_data()
+{
+    DefaultValuesFixture fixture;
+    const int setupOk = populateDefaultValuesFixture(&fixture);
+
+    QTest::addColumn<DefaultValuesFixture>("fixture");
+    QTest::addColumn<int>("setupOk"); // To verify setup
+    QTest::addColumn<AbstractMetaType>("metaType"); // Type and parameters for fixup
+    QTest::addColumn<QString>("input");
+    QTest::addColumn<QString>("expected");
+
+    QTest::newRow("int") << fixture << setupOk
+        << fixture.intType << "1" << "1";
+}
+
+void TestResolveType::testFixDefaultArguments()
+{
+    QFETCH(DefaultValuesFixture, fixture);
+    QFETCH(int, setupOk);
+    QFETCH(AbstractMetaType, metaType);
+    QFETCH(QString, input);
+    QFETCH(QString, expected);
+    QCOMPARE(setupOk, 0);
+    const QString actual = fixture.builder->fixDefaultValue(input, metaType, fixture.klass);
+    QCOMPARE(actual, expected);
+}
+
 QTEST_APPLESS_MAIN(TestResolveType)