X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=tests%2Fauto%2Fqml%2Fqqmlecmascript%2Ftesttypes.h;h=a4615c5f520a383d34bfd8312ba0b64796c74ff2;hb=a6277bb84d208279abb600f9eae801b3aacecc4c;hp=90eda77feee9dd2a1e2a5649255ffde4d3634f7f;hpb=029e510256a1a6ea8f30db75fa0745cad01353cb;p=profile%2Fivi%2Fqtdeclarative.git

diff --git a/tests/auto/qml/qqmlecmascript/testtypes.h b/tests/auto/qml/qqmlecmascript/testtypes.h
index 90eda77..a4615c5 100644
--- a/tests/auto/qml/qqmlecmascript/testtypes.h
+++ b/tests/auto/qml/qqmlecmascript/testtypes.h
@@ -86,11 +86,22 @@ private:
     int m_value2;
 };
 
+class MyEnumContainer : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(RelatedEnum)
+
+public:
+    enum RelatedEnum { RelatedInvalid = -1, RelatedValue = 42, MultiplyDefined = 666 };
+};
+
 class MyQmlObject : public QObject
 {
     Q_OBJECT
     Q_ENUMS(MyEnum)
     Q_ENUMS(MyEnum2)
+    Q_ENUMS(MyEnum3)
+    Q_ENUMS(MyEnumContainer::RelatedEnum)
     Q_PROPERTY(int deleteOnSet READ deleteOnSet WRITE setDeleteOnSet)
     Q_PROPERTY(bool trueProperty READ trueProperty CONSTANT)
     Q_PROPERTY(bool falseProperty READ falseProperty CONSTANT)
@@ -104,12 +115,19 @@ class MyQmlObject : public QObject
     Q_PROPERTY(QRegExp regExp READ regExp WRITE setRegExp)
     Q_PROPERTY(int nonscriptable READ nonscriptable WRITE setNonscriptable SCRIPTABLE false)
     Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty NOTIFY intChanged)
+    Q_PROPERTY(QJSValue qjsvalue READ qjsvalue WRITE setQJSValue NOTIFY qjsvalueChanged)
+    Q_PROPERTY(QJSValue qjsvalueWithReset READ qjsvalue WRITE setQJSValue RESET resetQJSValue NOTIFY qjsvalueChanged)
+    Q_PROPERTY(MyEnum enumProperty READ enumProperty WRITE setEnumProperty)
+    Q_PROPERTY(MyEnumContainer::RelatedEnum relatedEnumProperty READ relatedEnumProperty WRITE setRelatedEnumProperty)
+    Q_PROPERTY(MyEnumContainer::RelatedEnum unrelatedEnumProperty READ unrelatedEnumProperty WRITE setUnrelatedEnumProperty)
+    Q_PROPERTY(MyEnum qtEnumProperty READ qtEnumProperty WRITE setQtEnumProperty)
 
 public:
     MyQmlObject(): myinvokableObject(0), m_methodCalled(false), m_methodIntCalled(false), m_object(0), m_value(0), m_resetProperty(13), m_intProperty(0), m_buttons(0) {}
 
     enum MyEnum { EnumValue1 = 0, EnumValue2 = 1 };
-    enum MyEnum2 { EnumValue3 = 2, EnumValue4 = 3 };
+    enum MyEnum2 { EnumValue3 = 2, EnumValue4 = 3, EnumValue5 = -1 };
+    enum MyEnum3 { MultiplyDefined = 333 };
 
     bool trueProperty() const { return true; }
     bool falseProperty() const { return false; }
@@ -175,13 +193,53 @@ public:
     struct MyType {
         int value;
     };
+    struct MyOtherType {
+        int value;
+    };
     QVariant variant() const { return m_variant; }
     QJSValue qjsvalue() const { return m_qjsvalue; }
+    void setQJSValue(const QJSValue &value) { m_qjsvalue = value; emit qjsvalueChanged(); }
+    void resetQJSValue() { m_qjsvalue = QJSValue(QLatin1String("Reset!")); emit qjsvalueChanged(); }
+
     Qt::MouseButtons buttons() const { return m_buttons; }
 
     int intProperty() const { return m_intProperty; }
     void setIntProperty(int i) { m_intProperty = i; emit intChanged(); }
     
+    Q_INVOKABLE MyEnum2 getEnumValue() const { return EnumValue4; }
+
+    MyEnum enumPropertyValue;
+    MyEnum enumProperty() const {
+        return enumPropertyValue;
+    }
+    void setEnumProperty(MyEnum v) {
+        enumPropertyValue = v;
+    }
+
+    MyEnumContainer::RelatedEnum relatedEnumPropertyValue;
+    MyEnumContainer::RelatedEnum relatedEnumProperty() const {
+        return relatedEnumPropertyValue;
+    }
+    void setRelatedEnumProperty(MyEnumContainer::RelatedEnum v) {
+        relatedEnumPropertyValue = v;
+    }
+
+    MyEnumContainer::RelatedEnum unrelatedEnumPropertyValue;
+    MyEnumContainer::RelatedEnum unrelatedEnumProperty() const {
+        return unrelatedEnumPropertyValue;
+    }
+    void setUnrelatedEnumProperty(MyEnumContainer::RelatedEnum v) {
+        unrelatedEnumPropertyValue = v;
+    }
+
+    MyEnum qtEnumPropertyValue;
+    MyEnum qtEnumProperty() const {
+        return qtEnumPropertyValue;
+    }
+    void setQtEnumProperty(MyEnum v) {
+        qtEnumPropertyValue = v;
+    }
+
 signals:
     void basicSignal();
     void argumentSignal(int a, QString b, qreal c, MyEnum2 d, Qt::MouseButtons e);
@@ -192,10 +250,12 @@ signals:
     void anotherBasicSignal();
     void thirdBasicSignal();
     void signalWithUnknownType(const MyQmlObject::MyType &arg);
+    void signalWithCompletelyUnknownType(const MyQmlObject::MyOtherType &arg);
     void signalWithVariant(const QVariant &arg);
     void signalWithQJSValue(const QJSValue &arg);
     void signalWithGlobalName(int parseInt);
     void intChanged();
+    void qjsvalueChanged();
 
 public slots:
     void deleteMe() { delete this; }
@@ -346,6 +406,7 @@ class MyTypeObject : public QObject
 {
     Q_OBJECT
     Q_ENUMS(MyEnum)
+    Q_ENUMS(MyEnumContainer::RelatedEnum)
     Q_FLAGS(MyFlags)
 
     Q_PROPERTY(QString id READ id WRITE setId)
@@ -353,6 +414,7 @@ class MyTypeObject : public QObject
     Q_PROPERTY(QQmlComponent *componentProperty READ componentProperty WRITE setComponentProperty)
     Q_PROPERTY(MyFlags flagProperty READ flagProperty WRITE setFlagProperty)
     Q_PROPERTY(MyEnum enumProperty READ enumProperty WRITE setEnumProperty)
+    Q_PROPERTY(MyEnumContainer::RelatedEnum relatedEnumProperty READ relatedEnumProperty WRITE setRelatedEnumProperty)
     Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty)
     Q_PROPERTY(uint uintProperty READ uintProperty WRITE setUintProperty)
     Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty)
@@ -425,6 +487,14 @@ public:
         enumPropertyValue = v;
     }
 
+    MyEnumContainer::RelatedEnum relatedEnumPropertyValue;
+    MyEnumContainer::RelatedEnum relatedEnumProperty() const {
+        return relatedEnumPropertyValue;
+    }
+    void setRelatedEnumProperty(MyEnumContainer::RelatedEnum v) {
+        relatedEnumPropertyValue = v;
+    }
+
     QString stringPropertyValue;
     QString stringProperty() const {
        return stringPropertyValue;
@@ -637,6 +707,11 @@ public:
     Q_INVOKABLE inline void method_overload();
 };
 
+struct NonRegisteredType
+{
+
+};
+
 class MyInvokableObject : public MyInvokableBaseObject
 {
     Q_OBJECT
@@ -689,6 +764,8 @@ public:
     Q_INVOKABLE void method_overload(const QJsonArray &a) { invoke(26); m_actuals << QVariant::fromValue(a); }
     Q_INVOKABLE void method_overload(const QJsonValue &a) { invoke(27); m_actuals << QVariant::fromValue(a); }
 
+    Q_INVOKABLE void method_unknown(NonRegisteredType) { invoke(28); }
+
 private:
     friend class MyInvokableBaseObject;
     void invoke(int idx) { if (m_invoked != -1) m_invokedError = true; m_invoked = idx;}
@@ -1033,6 +1110,21 @@ public:
     int qobjectTestWritableFinalProperty() const { return m_testWritableFinalProperty; }
     void setQObjectTestWritableFinalProperty(int tp) { m_testWritableFinalProperty = tp; emit qobjectTestWritableFinalPropertyChanged(); }
 
+    Q_INVOKABLE bool trackedObjectHasJsOwnership() {
+        QObject * object = m_trackedObject;
+
+        if (!object)
+            return false;
+
+        QQmlData *ddata = QQmlData::get(object, false);
+        if (!ddata)
+            return false;
+        else
+            return ddata->indestructible?false:true;
+    }
+
+    Q_INVOKABLE void deleteQObject(QObject *obj) { delete obj; }
+
 signals:
     void qobjectTestPropertyChanged(int testProperty);
     void qobjectTestWritablePropertyChanged(int testWritableProperty);
@@ -1046,6 +1138,40 @@ private:
     QObject *m_trackedObject;
 };
 
+class testQObjectApiTwo : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int twoTestProperty READ twoTestProperty WRITE setTwoTestProperty NOTIFY twoTestPropertyChanged)
+
+public:
+    testQObjectApiTwo(QObject *parent = 0) : QObject(parent), m_ttp(42) {}
+    ~testQObjectApiTwo() {}
+
+    void setTwoTestProperty(int v) { m_ttp = v; emit twoTestPropertyChanged(); }
+    int twoTestProperty() const { return m_ttp; }
+
+signals:
+    void twoTestPropertyChanged();
+
+private:
+    int m_ttp;
+};
+
+class testImportOrderApi : public QObject
+{
+    Q_OBJECT
+
+public:
+    testImportOrderApi(int value, QObject *parent = 0) : QObject(parent), m_value(value) {}
+
+    Q_PROPERTY(int value READ value)
+
+    int value() const { return m_value; }
+
+private:
+    int m_value;
+};
+
 class CircularReferenceObject : public QObject,
                                 public QV8GCCallback::Node
 {
@@ -1137,11 +1263,9 @@ public:
         m_referenced.MakeWeak(static_cast<void*>(this), wrcallback);
     }
 
-    static void wrcallback(v8::Persistent<v8::Value> handle, void *params)
+    static void wrcallback(v8::Persistent<v8::Value> handle, void *)
     {
-        CircularReferenceHandle *crh = static_cast<CircularReferenceHandle*>(params);
         qPersistentDispose(handle);
-        crh->m_referenced.Clear();
     }
 
     static void gccallback(QV8GCCallback::Node *n)
@@ -1233,6 +1357,7 @@ class MySequenceConversionObject : public QObject
     Q_PROPERTY (QStringList qstringListProperty READ qstringListProperty WRITE setQStringListProperty NOTIFY qstringListPropertyChanged)
 
     Q_PROPERTY (QList<QPoint> pointListProperty READ pointListProperty WRITE setPointListProperty NOTIFY pointListPropertyChanged)
+    Q_PROPERTY (QList<NonRegisteredType> typeListProperty READ typeListProperty WRITE setTypeListProperty NOTIFY typeListPropertyChanged)
     Q_PROPERTY (QList<QVariant> variantListProperty READ variantListProperty WRITE setVariantListProperty NOTIFY variantListPropertyChanged)
 
     Q_PROPERTY (qint32 maxIndex READ maxIndex CONSTANT)
@@ -1287,6 +1412,8 @@ public:
     void setQStringListProperty(const QStringList &list) { m_qstringList = list; emit qstringListPropertyChanged(); }
     QList<QPoint> pointListProperty() const { return m_pointList; }
     void setPointListProperty(const QList<QPoint> &list) { m_pointList = list; emit pointListPropertyChanged(); }
+    QList<NonRegisteredType> typeListProperty() const { return m_typeList; }
+    void setTypeListProperty(const QList<NonRegisteredType> &list) { m_typeList = list; emit typeListPropertyChanged(); }
     QList<QVariant> variantListProperty() const { return m_variantList; }
     void setVariantListProperty(const QList<QVariant> &list) { m_variantList = list; emit variantListPropertyChanged(); }
 
@@ -1297,6 +1424,7 @@ public:
     Q_INVOKABLE QList<QString> generateStringSequence() const { QList<QString> retn; retn << "one" << "two" << "three"; return retn; }
     Q_INVOKABLE QList<QUrl> generateUrlSequence() const { QList<QUrl> retn; retn << QUrl("http://www.example1.com") << QUrl("http://www.example2.com") << QUrl("http://www.example3.com"); return retn; }
     Q_INVOKABLE QStringList generateQStringSequence() const { QStringList retn; retn << "one" << "two" << "three"; return retn; }
+    Q_INVOKABLE bool parameterEqualsGeneratedIntSequence(const QList<int>& param) const { return (param == generateIntSequence()); }
 
     // "reference resource" underlying qobject deletion test:
     Q_INVOKABLE MySequenceConversionObject *generateTestObject() const { return new MySequenceConversionObject; }
@@ -1311,6 +1439,7 @@ signals:
     void urlListPropertyChanged();
     void qstringListPropertyChanged();
     void pointListPropertyChanged();
+    void typeListPropertyChanged();
     void variantListPropertyChanged();
 
 private:
@@ -1322,7 +1451,8 @@ private:
     QList<QUrl> m_urlList;
     QStringList m_qstringList;
 
-    QList<QPoint> m_pointList; // not a supported sequence type
+    QList<QPoint> m_pointList;
+    QList<NonRegisteredType> m_typeList; // not a supported sequence type
     QList<QVariant> m_variantList; // not a supported sequence type, but QVariantList support is hardcoded.
 };
 
@@ -1383,6 +1513,136 @@ private:
     QString m_timespec;
 };
 
+class MyWorkerObject : public QObject
+{
+    Q_OBJECT
+
+public Q_SLOTS:
+    void doIt();
+
+Q_SIGNALS:
+    void done(const QString &result);
+};
+
+class MyUnregisteredEnumTypeObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(MyEnum enumProperty READ enumProperty WRITE setEnumProperty)
+
+public:
+    MyUnregisteredEnumTypeObject() : QObject(), m_ev(FirstValue) {}
+    ~MyUnregisteredEnumTypeObject() {}
+
+    enum MyEnum {
+        FirstValue = 1,
+        SecondValue = 2
+    };
+
+    MyEnum enumProperty() const { return m_ev; }
+    void setEnumProperty(MyEnum v) { m_ev = v; }
+
+private:
+    MyEnum m_ev;
+};
+
+class FallbackBindingsObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY (int test READ test NOTIFY testChanged)
+public:
+    FallbackBindingsObject(QObject* parent = 0)
+        : QObject(parent), m_test(100)
+    {
+    }
+
+    int test() const { return m_test; }
+
+Q_SIGNALS:
+    void testChanged();
+
+private:
+    int m_test;
+};
+
+class FallbackBindingsDerived : public FallbackBindingsObject
+{
+    Q_OBJECT
+    Q_PROPERTY (QString test READ test NOTIFY testChanged)
+public:
+    FallbackBindingsDerived(QObject* parent = 0)
+        : FallbackBindingsObject(parent), m_test("hello")
+    {
+    }
+
+    QString test() const { return m_test; }
+
+Q_SIGNALS:
+    void testChanged();
+
+private:
+    QString m_test;
+};
+
+class FallbackBindingsAttachedObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY (int test READ test NOTIFY testChanged)
+public:
+    FallbackBindingsAttachedObject(QObject *parent) : QObject(parent), m_test(100) {}
+
+    int test() const { return m_test; }
+
+Q_SIGNALS:
+    void testChanged();
+
+private:
+    int m_test;
+};
+
+class FallbackBindingsAttachedDerived : public FallbackBindingsAttachedObject
+{
+    Q_OBJECT
+    Q_PROPERTY (QString test READ test NOTIFY testChanged)
+public:
+    FallbackBindingsAttachedDerived(QObject* parent = 0)
+        : FallbackBindingsAttachedObject(parent), m_test("hello")
+    {
+    }
+
+    QString test() const { return m_test; }
+
+Q_SIGNALS:
+    void testChanged();
+
+private:
+    QString m_test;
+};
+
+class FallbackBindingsTypeObject : public QObject
+{
+    Q_OBJECT
+public:
+    FallbackBindingsTypeObject() : QObject() {}
+
+    static FallbackBindingsAttachedObject *qmlAttachedProperties(QObject *o) {
+        return new FallbackBindingsAttachedObject(o);
+    }
+};
+
+class FallbackBindingsTypeDerived : public QObject
+{
+    Q_OBJECT
+public:
+    FallbackBindingsTypeDerived() : QObject() {}
+
+    static FallbackBindingsAttachedObject *qmlAttachedProperties(QObject *o) {
+        return new FallbackBindingsAttachedDerived(o);
+    }
+};
+
+QML_DECLARE_TYPEINFO(FallbackBindingsTypeObject, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPEINFO(FallbackBindingsTypeDerived, QML_HAS_ATTACHED_PROPERTIES)
+
 void registerTypes();
 
 #endif // TESTTYPES_H