add tests for QFlags behavior in QtScript

It's currently not even documented, but this test defines the
current level of support.

1 files changed, 56 insertions, 1 deletions

diff --git a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
index 73e4fb636c..341516374f 100644
--- a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
+++ b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
@@ -112,6 +112,7 @@ class MyQObject : public QObject
     Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut)
     Q_PROPERTY(CustomType propWithCustomType READ propWithCustomType WRITE setPropWithCustomType)
     Q_PROPERTY(Policy enumProperty READ enumProperty WRITE setEnumProperty)
+    Q_PROPERTY(Ability flagsProperty READ flagsProperty WRITE setFlagsProperty)
     Q_ENUMS(Policy Strategy)
     Q_FLAGS(Ability)
 
@@ -150,6 +151,7 @@ public:
           m_writeOnlyValue(789),
           m_readOnlyValue(987),
           m_enumValue(BarPolicy),
+          m_flagsValue(FooAbility),
           m_qtFunctionInvoked(-1)
         { }
 
@@ -216,6 +218,11 @@ public:
     void setEnumProperty(Policy policy)
         { m_enumValue = policy; }
 
+    Ability flagsProperty() const
+        { return m_flagsValue; }
+    void setFlagsProperty(Ability ability)
+        { m_flagsValue = ability; }
+
     int qtFunctionInvoked() const
         { return m_qtFunctionInvoked; }
 
@@ -316,6 +323,10 @@ public:
         { m_qtFunctionInvoked = 56; return arg; }
     Q_INVOKABLE QObject* myInvokableReturningMyQObjectAsQObject()
         { m_qtFunctionInvoked = 57; return this; }
+    Q_INVOKABLE Ability myInvokableWithFlagsArg(Ability arg)
+        { m_qtFunctionInvoked = 58; m_actuals << int(arg); return arg; }
+    Q_INVOKABLE MyQObject::Ability myInvokableWithQualifiedFlagsArg(MyQObject::Ability arg)
+        { m_qtFunctionInvoked = 59; m_actuals << int(arg); return arg; }
 
     Q_INVOKABLE QObjectList findObjects() const
     {  return findChildren<QObject *>();  }
@@ -433,6 +444,7 @@ protected:
     QKeySequence m_shortcut;
     CustomType m_customType;
     Policy m_enumValue;
+    Ability m_flagsValue;
     int m_qtFunctionInvoked;
     QVariantList m_actuals;
     QByteArray m_connectedSignal;
@@ -826,7 +838,7 @@ void tst_QScriptExtQObject::getSetStaticProperty()
     {
         QScriptValue val = m_engine->evaluate("myObject.enumProperty");
         QVERIFY(val.isNumber());
-        QCOMPARE(val.toInt32(), (int)MyQObject::BarPolicy);
+        QCOMPARE(val.toInt32(), int(MyQObject::BarPolicy));
     }
     m_engine->evaluate("myObject.enumProperty = 2");
     QCOMPARE(m_myObject->enumProperty(), MyQObject::BazPolicy);
@@ -846,6 +858,25 @@ void tst_QScriptExtQObject::getSetStaticProperty()
     m_engine->evaluate("myObject.enumProperty = 'nada'");
     QCOMPARE(m_myObject->enumProperty(), (MyQObject::Policy)-1);
 
+    // flags property
+    QCOMPARE(m_myObject->flagsProperty(), MyQObject::FooAbility);
+    {
+        QScriptValue val = m_engine->evaluate("myObject.flagsProperty");
+        QVERIFY(val.isNumber());
+        QCOMPARE(val.toInt32(), int(MyQObject::FooAbility));
+    }
+    m_engine->evaluate("myObject.flagsProperty = 0x80");
+    QCOMPARE(m_myObject->flagsProperty(), MyQObject::BarAbility);
+    m_engine->evaluate("myObject.flagsProperty = 0x81");
+    QCOMPARE(m_myObject->flagsProperty(), MyQObject::Ability(MyQObject::FooAbility | MyQObject::BarAbility));
+    m_engine->evaluate("myObject.flagsProperty = 123"); // bogus values are accepted
+    QCOMPARE(int(m_myObject->flagsProperty()), 123);
+    m_engine->evaluate("myObject.flagsProperty = 'BazAbility'");
+    QCOMPARE(m_myObject->flagsProperty(),  MyQObject::BazAbility);
+    m_engine->evaluate("myObject.flagsProperty = 'ScoobyDoo'");
+    // ### ouch! Shouldn't QMetaProperty::write() rather not change the value...?
+    QCOMPARE(m_myObject->flagsProperty(), (MyQObject::Ability)-1);
+
     // auto-dereferencing of pointers
     {
         QBrush b = QColor(0xCA, 0xFE, 0xBA, 0xBE);
@@ -2017,6 +2048,7 @@ void tst_QScriptExtQObject::classEnums()
     QScriptValue myClass = m_engine->newQMetaObject(m_myObject->metaObject(), m_engine->undefinedValue());
     m_engine->globalObject().setProperty("MyQObject", myClass);
 
+    QVERIFY(m_engine->evaluate("MyQObject.FooPolicy").isNumber()); // no strong typing
     QCOMPARE(static_cast<MyQObject::Policy>(m_engine->evaluate("MyQObject.FooPolicy").toInt32()),
              MyQObject::FooPolicy);
     QCOMPARE(static_cast<MyQObject::Policy>(m_engine->evaluate("MyQObject.BarPolicy").toInt32()),
@@ -2031,6 +2063,7 @@ void tst_QScriptExtQObject::classEnums()
     QCOMPARE(static_cast<MyQObject::Strategy>(m_engine->evaluate("MyQObject.BazStrategy").toInt32()),
              MyQObject::BazStrategy);
 
+    QVERIFY(m_engine->evaluate("MyQObject.NoAbility").isNumber()); // no strong typing
     QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.NoAbility").toInt32()),
              MyQObject::NoAbility);
     QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.FooAbility").toInt32()),
@@ -2042,6 +2075,9 @@ void tst_QScriptExtQObject::classEnums()
     QCOMPARE(MyQObject::Ability(m_engine->evaluate("MyQObject.AllAbility").toInt32()),
              MyQObject::AllAbility);
 
+    // Constructors for flags are not provided
+    QVERIFY(m_engine->evaluate("MyQObject.Ability").isUndefined());
+
     QScriptValue::PropertyFlags expectedEnumFlags = QScriptValue::ReadOnly | QScriptValue::Undeletable;
     QCOMPARE(myClass.propertyFlags("FooPolicy"), expectedEnumFlags);
     QCOMPARE(myClass.propertyFlags("BarPolicy"), expectedEnumFlags);
@@ -2094,6 +2130,25 @@ void tst_QScriptExtQObject::classEnums()
         QCOMPARE(ret.isNumber(), true);
     }
 
+    m_myObject->resetQtFunctionInvoked();
+    {
+        QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithFlagsArg(MyQObject.FooAbility)");
+        QCOMPARE(m_myObject->qtFunctionInvoked(), 58);
+        QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);
+        QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), int(MyQObject::FooAbility));
+        QCOMPARE(ret.isNumber(), true);
+        QCOMPARE(ret.toInt32(), int(MyQObject::FooAbility));
+    }
+    m_myObject->resetQtFunctionInvoked();
+    {
+        QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithQualifiedFlagsArg(MyQObject.BarAbility)");
+        QCOMPARE(m_myObject->qtFunctionInvoked(), 59);
+        QCOMPARE(m_myObject->qtFunctionActuals().size(), 1);
+        QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), int(MyQObject::BarAbility));
+        QCOMPARE(ret.isNumber(), true);
+        QCOMPARE(ret.toInt32(), int(MyQObject::BarAbility));
+    }
+
     // enum properties are not deletable or writable
     QVERIFY(!m_engine->evaluate("delete MyQObject.BazPolicy").toBool());
     myClass.setProperty("BazPolicy", QScriptValue());