External conversion operators are now part of a class' implicit conversions.

AbstractMetaClass::implicitConversions() returns externally declared
conversion operators in addition to its own implicit constructors.

The implicit conversion tests where extended with the new case.

1 files changed, 32 insertions, 0 deletions

diff --git a/tests/testimplicitconversions.cpp b/tests/testimplicitconversions.cpp
index 350ec8b6a..fd927db0b 100644
--- a/tests/testimplicitconversions.cpp
+++ b/tests/testimplicitconversions.cpp
@@ -116,6 +116,38 @@ void TestImplicitConversions::testWithAddedCtor()
     QCOMPARE(implicitConvs.count(), 2);
 }
 
+void TestImplicitConversions::testWithExternalConversionOperator()
+{
+    const char* cppCode ="\
+    class A {};\
+    struct B {\
+        operator A() const;\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\">\
+        <value-type name=\"A\"/>\
+        <value-type name=\"B\"/>\
+        </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    QCOMPARE(implicitConvs.count(), 1);
+    AbstractMetaFunctionList externalConvOps = classA->externalConversionOperators();
+    QCOMPARE(externalConvOps.count(), 1);
+
+    const AbstractMetaFunction* convOp = 0;
+    foreach(const AbstractMetaFunction* func, classB->functions()) {
+        if (func->isConversionOperator())
+            convOp = func;
+    }
+    QVERIFY(convOp);
+    QCOMPARE(implicitConvs.first(), convOp);
+}
+
 QTEST_APPLESS_MAIN(TestImplicitConversions)
 
 #include "testimplicitconversions.moc"