Merge master into api_changes

Conflicts:
	src/qml/qml/qqmlboundsignal.cpp
	src/qml/qml/qqmlpropertycache.cpp

Change-Id: I5193a193fa301c0b518291645bf626a5fa07118f

4 files changed, 211 insertions, 3 deletions

diff --git a/tests/auto/qml/qqmllanguage/data/globalEnums.qml b/tests/auto/qml/qqmllanguage/data/globalEnums.qml
new file mode 100644
index 0000000000..fa248d544d
--- /dev/null
+++ b/tests/auto/qml/qqmllanguage/data/globalEnums.qml
@@ -0,0 +1,55 @@
+import QtQuick 2.0
+import Test 1.0
+
+Item {
+    MyEnum1Class {
+        id: enum1Class
+        objectName: "enum1Class"
+    }
+
+    MyEnumDerivedClass {
+        id: enumDerivedClass
+        objectName: "enumDerivedClass"
+
+        onValueAChanged: {
+            aValue = newValue;
+        }
+
+        onValueBChanged: {
+            bValue = newValue;
+        }
+
+        onValueCChanged: {
+            cValue = newValue;
+        }
+
+        onValueDChanged: {
+            dValue = newValue;
+        }
+
+        onValueEChanged: {
+            eValue = newValue;
+        }
+
+        onValueE2Changed: {
+            e2Value = newValue;
+        }
+
+        property int aValue: 0
+        property int bValue: 0
+        property int cValue: 0
+        property int dValue: 0
+        property int eValue: 0
+        property int e2Value: 0
+    }
+
+    function setEnumValues() {
+        enum1Class.setValue(MyEnum1Class.A_13);
+        enumDerivedClass.setValueA(MyEnum1Class.A_11);
+        enumDerivedClass.setValueB(MyEnum2Class.B_37);
+        enumDerivedClass.setValueC(Qt.RichText);
+        enumDerivedClass.setValueD(Qt.ElideMiddle);
+        enumDerivedClass.setValueE(MyEnum2Class.E_14);
+        enumDerivedClass.setValueE2(MyEnum2Class.E_76);
+    }
+}
diff --git a/tests/auto/qml/qqmllanguage/testtypes.cpp b/tests/auto/qml/qqmllanguage/testtypes.cpp
index 3c7a7c2058..5e9423761c 100644
--- a/tests/auto/qml/qqmllanguage/testtypes.cpp
+++ b/tests/auto/qml/qqmllanguage/testtypes.cpp
@@ -77,6 +77,10 @@ void registerTypes()
 
     qmlRegisterType<MyVersion2Class>("Test.VersionOrder", 2,0, "MyQmlObject");
     qmlRegisterType<MyQmlObject>("Test.VersionOrder", 1,0, "MyQmlObject");
+
+    qmlRegisterType<MyEnum1Class>("Test",1,0,"MyEnum1Class");
+    qmlRegisterType<MyEnum2Class>("Test",1,0,"MyEnum2Class");
+    qmlRegisterType<MyEnumDerivedClass>("Test",1,0,"MyEnumDerivedClass");
 }
 
 QVariant myCustomVariantTypeConverter(const QString &data)
@@ -85,4 +89,3 @@ QVariant myCustomVariantTypeConverter(const QString &data)
     rv.a = data.toInt();
     return QVariant::fromValue(rv);
 }
-
diff --git a/tests/auto/qml/qqmllanguage/testtypes.h b/tests/auto/qml/qqmllanguage/testtypes.h
index e7294f090c..7b3265efb4 100644
--- a/tests/auto/qml/qqmllanguage/testtypes.h
+++ b/tests/auto/qml/qqmllanguage/testtypes.h
@@ -811,14 +811,103 @@ class MyVersion2Class : public QObject
     Q_OBJECT
 };
 
+class MyEnum1Class : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(EnumA)
+
+public:
+    MyEnum1Class() : value(A_Invalid) {}
+
+    enum EnumA
+    {
+        A_Invalid = -1,
+
+        A_11 = 11,
+        A_13 = 13
+    };
+
+    Q_INVOKABLE void setValue(EnumA v) { value = v; }
+
+    EnumA getValue() { return value; }
+
+private:
+    EnumA value;
+};
+
+class MyEnum2Class : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(EnumB)
+    Q_ENUMS(EnumE)
+
+public:
+    MyEnum2Class() : valueA(MyEnum1Class::A_Invalid), valueB(B_Invalid), valueC(Qt::PlainText),
+                     valueD(Qt::ElideLeft), valueE(E_Invalid), valueE2(E_Invalid) {}
+
+    enum EnumB
+    {
+        B_Invalid = -1,
+
+        B_29 = 29,
+        B_31 = 31,
+        B_37 = 37
+    };
+
+    enum EnumE
+    {
+        E_Invalid = -1,
+
+        E_14 = 14,
+        E_76 = 76
+    };
+
+    MyEnum1Class::EnumA getValueA() { return valueA; }
+    EnumB getValueB() { return valueB; }
+    Qt::TextFormat getValueC() { return valueC; }
+    Qt::TextElideMode getValueD() { return valueD; }
+    EnumE getValueE() { return valueE; }
+    EnumE getValueE2() { return valueE2; }
+
+    Q_INVOKABLE void setValueA(MyEnum1Class::EnumA v) { valueA = v; emit valueAChanged(v); }
+    Q_INVOKABLE void setValueB(EnumB v) { valueB = v; emit valueBChanged(v); }
+    Q_INVOKABLE void setValueC(Qt::TextFormat v) { valueC = v; emit valueCChanged(v); }     //registered
+    Q_INVOKABLE void setValueD(Qt::TextElideMode v) { valueD = v; emit valueDChanged(v); }  //unregistered
+    Q_INVOKABLE void setValueE(EnumE v) { valueE = v; emit valueEChanged(v); }
+    Q_INVOKABLE void setValueE2(MyEnum2Class::EnumE v) { valueE2 = v; emit valueE2Changed(v); }
+
+signals:
+    void valueAChanged(MyEnum1Class::EnumA newValue);
+    void valueBChanged(MyEnum2Class::EnumB newValue);
+    void valueCChanged(Qt::TextFormat newValue);
+    void valueDChanged(Qt::TextElideMode newValue);
+    void valueEChanged(EnumE newValue);
+    void valueE2Changed(MyEnum2Class::EnumE newValue);
+
+private:
+    MyEnum1Class::EnumA valueA;
+    EnumB valueB;
+    Qt::TextFormat valueC;
+    Qt::TextElideMode valueD;
+    EnumE valueE;
+    EnumE valueE2;
+};
+
+class MyEnumDerivedClass : public MyEnum2Class
+{
+    Q_OBJECT
+};
+
+Q_DECLARE_METATYPE(MyEnum2Class::EnumB)
+Q_DECLARE_METATYPE(MyEnum1Class::EnumA)
+Q_DECLARE_METATYPE(Qt::TextFormat)
+
 QML_DECLARE_TYPE(MyRevisionedBaseClassRegistered)
 QML_DECLARE_TYPE(MyRevisionedBaseClassUnregistered)
 QML_DECLARE_TYPE(MyRevisionedClass)
 QML_DECLARE_TYPE(MyRevisionedSubclass)
 QML_DECLARE_TYPE(MySubclass)
 
-
-
 void registerTypes();
 
 #endif // TESTTYPES_H
diff --git a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
index 266cd2a52d..837a9d2604 100644
--- a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
+++ b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
@@ -46,6 +46,7 @@
 #include <QtCore/qdebug.h>
 #include <QtCore/qfileinfo.h>
 #include <QtCore/qdir.h>
+#include <QSignalSpy>
 
 #include <private/qqmlproperty_p.h>
 #include <private/qqmlmetatype_p.h>
@@ -176,6 +177,8 @@ private slots:
     void crash1();
     void crash2();
 
+    void globalEnums();
+
 private:
     QQmlEngine engine;
     void testType(const QString& qml, const QString& type, const QString& error);
@@ -2285,6 +2288,64 @@ void tst_qqmllanguage::remoteLoadCrash()
     delete o;
 }
 
+// QTBUG-20639
+void tst_qqmllanguage::globalEnums()
+{
+    qRegisterMetaType<MyEnum1Class::EnumA>();
+    qRegisterMetaType<MyEnum2Class::EnumB>();
+    qRegisterMetaType<Qt::TextFormat>();
+
+    QQmlComponent component(&engine, TEST_FILE("globalEnums.qml"));
+
+    QObject *o = component.create();
+    QVERIFY(o != 0);
+
+    MyEnum1Class *enum1Class = o->findChild<MyEnum1Class *>(QString::fromLatin1("enum1Class"));
+    QVERIFY(enum1Class != 0);
+    QVERIFY(enum1Class->getValue() == -1);
+
+    MyEnumDerivedClass *enum2Class = o->findChild<MyEnumDerivedClass *>(QString::fromLatin1("enumDerivedClass"));
+    QVERIFY(enum2Class != 0);
+    QVERIFY(enum2Class->getValueA() == -1);
+    QVERIFY(enum2Class->getValueB() == -1);
+    QVERIFY(enum2Class->getValueC() == 0);
+    QVERIFY(enum2Class->getValueD() == 0);
+    QVERIFY(enum2Class->getValueE() == -1);
+    QVERIFY(enum2Class->getValueE2() == -1);
+
+    QVERIFY(enum2Class->property("aValue") == 0);
+    QVERIFY(enum2Class->property("bValue") == 0);
+    QVERIFY(enum2Class->property("cValue") == 0);
+    QVERIFY(enum2Class->property("dValue") == 0);
+    QVERIFY(enum2Class->property("eValue") == 0);
+    QVERIFY(enum2Class->property("e2Value") == 0);
+
+    QSignalSpy signalA(enum2Class, SIGNAL(valueAChanged(MyEnum1Class::EnumA)));
+    QSignalSpy signalB(enum2Class, SIGNAL(valueBChanged(MyEnum2Class::EnumB)));
+
+    QMetaObject::invokeMethod(o, "setEnumValues");
+
+    QVERIFY(enum1Class->getValue() == MyEnum1Class::A_13);
+    QVERIFY(enum2Class->getValueA() == MyEnum1Class::A_11);
+    QVERIFY(enum2Class->getValueB() == MyEnum2Class::B_37);
+    QVERIFY(enum2Class->getValueC() == Qt::RichText);
+    QVERIFY(enum2Class->getValueD() == Qt::ElideMiddle);
+    QVERIFY(enum2Class->getValueE() == MyEnum2Class::E_14);
+    QVERIFY(enum2Class->getValueE2() == MyEnum2Class::E_76);
+
+    QVERIFY(signalA.count() == 1);
+    QVERIFY(signalB.count() == 1);
+
+    QVERIFY(enum2Class->property("aValue") == MyEnum1Class::A_11);
+    QVERIFY(enum2Class->property("bValue") == 37);
+    QVERIFY(enum2Class->property("cValue") == 1);
+    QVERIFY(enum2Class->property("dValue") == 2);
+    QVERIFY(enum2Class->property("eValue") == 14);
+    QVERIFY(enum2Class->property("e2Value") == 76);
+
+    delete o;
+}
+
 QTEST_MAIN(tst_qqmllanguage)
 
 #include "tst_qqmllanguage.moc"