/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <QtScript/qscriptengine.h>

#include <QtScript/qscriptclass.h>

#include <QtScript/qscriptclasspropertyiterator.h>

#include <QtScript/qscriptstring.h>

#include <QtScript/qscriptvalueiterator.h>

Q_DECLARE_METATYPE(QScriptContext*)

Q_DECLARE_METATYPE(QScriptValueList)

Q_DECLARE_METATYPE(QScriptValue)

//TESTED_CLASS=

//TESTED_FILES=script/qscriptclass.h script/qscriptclass.cpp script/qscriptclasspropertyiterator.h script/qscriptclasspropertyiterator.cpp

class tst_QScriptClass : public QObject

{

    Q_OBJECT

public:

    tst_QScriptClass();

    virtual ~tst_QScriptClass();

private slots:

    void newInstance();

    void getAndSetProperty();

    void enumerate();

    void extension();

};

tst_QScriptClass::tst_QScriptClass()

{

}

tst_QScriptClass::~tst_QScriptClass()

{

}

class TestClass : public QScriptClass

{

public:

    struct CustomProperty {

        QueryFlags qflags;

        uint id;

        QScriptValue::PropertyFlags pflags;

        QScriptValue value;

        CustomProperty(QueryFlags qf, uint i, QScriptValue::PropertyFlags pf,

                       const QScriptValue &val)

            : qflags(qf), id(i), pflags(pf), value(val) { }

    };

    enum CallableMode {

        NotCallable,

        CallableReturnsSum,

        CallableReturnsArgument,

        CallableReturnsInvalidVariant

    };

    TestClass(QScriptEngine *engine);

    ~TestClass();

    void addCustomProperty(const QScriptString &name, QueryFlags qflags,

                           uint id, QScriptValue::PropertyFlags pflags,

                           const QScriptValue &value);

    void removeCustomProperty(const QScriptString &name);

    QueryFlags queryProperty(const QScriptValue &object,

                             const QScriptString &name,

                             QueryFlags flags, uint *id);

    QScriptValue property(const QScriptValue &object,

                          const QScriptString &name, uint id);

    void setProperty(QScriptValue &object, const QScriptString &name,

                     uint id, const QScriptValue &value);

    QScriptValue::PropertyFlags propertyFlags(

        const QScriptValue &object, const QScriptString &name, uint id);

    QScriptClassPropertyIterator *newIterator(const QScriptValue &object);

    QScriptValue prototype() const;

    QString name() const;

    bool supportsExtension(Extension extension) const;

    QVariant extension(Extension extension,

                       const QVariant &argument = QVariant());

    QScriptValue lastQueryPropertyObject() const;

    QScriptString lastQueryPropertyName() const;

    QueryFlags lastQueryPropertyFlags() const;

    QScriptValue lastPropertyObject() const;

    QScriptString lastPropertyName() const;

    uint lastPropertyId() const;

    QScriptValue lastSetPropertyObject() const;

    QScriptString lastSetPropertyName() const;

    uint lastSetPropertyId() const;

    QScriptValue lastSetPropertyValue() const;

    QScriptValue lastPropertyFlagsObject() const;

    QScriptString lastPropertyFlagsName() const;

    uint lastPropertyFlagsId() const;

    QScriptClass::Extension lastExtensionType() const;

    QVariant lastExtensionArgument() const;

    void clearReceivedArgs();

    void setIterationEnabled(bool enable);

    bool isIterationEnabled() const;

    void setCallableMode(CallableMode mode);

    CallableMode callableMode() const;

    void setHasInstance(bool hasInstance);

    bool hasInstance() const;

private:

    CustomProperty *findCustomProperty(const QScriptString &name);

    QHash<QScriptString, CustomProperty*> customProperties;

    QScriptValue m_lastQueryPropertyObject;

    QScriptString m_lastQueryPropertyName;

    QScriptClass::QueryFlags m_lastQueryPropertyFlags;

    QScriptValue m_lastPropertyObject;

    QScriptString m_lastPropertyName;

    uint m_lastPropertyId;

    QScriptValue m_lastSetPropertyObject;

    QScriptString m_lastSetPropertyName;

    uint m_lastSetPropertyId;

    QScriptValue m_lastSetPropertyValue;

    QScriptValue m_lastPropertyFlagsObject;

    QScriptString m_lastPropertyFlagsName;

    uint m_lastPropertyFlagsId;

    QScriptClass::Extension m_lastExtensionType;

    QVariant m_lastExtensionArgument;

    QScriptValue m_prototype;

    bool m_iterationEnabled;

    CallableMode m_callableMode;

    bool m_hasInstance;

};

class TestClassPropertyIterator : public QScriptClassPropertyIterator

{

public:

    TestClassPropertyIterator(const QHash<QScriptString, TestClass::CustomProperty*> &props,

                      const QScriptValue &object);

    ~TestClassPropertyIterator();

    bool hasNext() const;

    void next();

    bool hasPrevious() const;

    void previous();

    void toFront();

    void toBack();

    QScriptString name() const;

    uint id() const;

    QScriptValue::PropertyFlags flags() const;

private:

    int m_index;

    int m_last;

    QHash<QScriptString, TestClass::CustomProperty*> m_props;

};

TestClass::TestClass(QScriptEngine *engine)

    : QScriptClass(engine), m_iterationEnabled(true),

      m_callableMode(NotCallable), m_hasInstance(false)

{

    m_prototype = engine->newObject();

    clearReceivedArgs();

}

TestClass::~TestClass()

{

    qDeleteAll(customProperties);

}

TestClass::CustomProperty* TestClass::findCustomProperty(const QScriptString &name)

{

    QHash<QScriptString, CustomProperty*>::const_iterator it;

    it = customProperties.constFind(name);

    if (it == customProperties.constEnd())

        return 0;

    return it.value();

}

void TestClass::addCustomProperty(const QScriptString &name, QueryFlags qflags,

                                  uint id, QScriptValue::PropertyFlags pflags,

                                  const QScriptValue &value)

{

    customProperties.insert(name, new CustomProperty(qflags, id, pflags, value));

}

void TestClass::removeCustomProperty(const QScriptString &name)

{

    CustomProperty *prop = customProperties.take(name);

    if (prop)

        delete prop;

}

QScriptClass::QueryFlags TestClass::queryProperty(const QScriptValue &object,

                                    const QScriptString &name,

                                    QueryFlags flags, uint *id)

{

    m_lastQueryPropertyObject = object;

    m_lastQueryPropertyName = name;

    m_lastQueryPropertyFlags = flags;

    CustomProperty *prop = findCustomProperty(name);

    if (!prop)

        return 0;

    *id = prop->id;

    return prop->qflags & flags;

}

QScriptValue TestClass::property(const QScriptValue &object,

                                 const QScriptString &name, uint id)

{

    m_lastPropertyObject = object;

    m_lastPropertyName = name;

    m_lastPropertyId = id;

    CustomProperty *prop = findCustomProperty(name);

    if (!prop)

        return QScriptValue();

    return prop->value;

}

void TestClass::setProperty(QScriptValue &object, const QScriptString &name,

                            uint id, const QScriptValue &value)

{

    m_lastSetPropertyObject = object;

    m_lastSetPropertyName = name;

    m_lastSetPropertyId = id;

    m_lastSetPropertyValue = value;

    CustomProperty *prop = findCustomProperty(name);

    if (!prop)

        return;

    prop->value = value;

}

QScriptValue::PropertyFlags TestClass::propertyFlags(

    const QScriptValue &object, const QScriptString &name, uint id)

{

    m_lastPropertyFlagsObject = object;

    m_lastPropertyFlagsName = name;

    m_lastPropertyFlagsId = id;

    CustomProperty *prop = findCustomProperty(name);

    if (!prop)

        return 0;

    return prop->pflags;

}

QScriptClassPropertyIterator *TestClass::newIterator(const QScriptValue &object)

{

    if (!m_iterationEnabled)

        return 0;

    return new TestClassPropertyIterator(customProperties, object);

}

QScriptValue TestClass::prototype() const

{

    return m_prototype;

}

QString TestClass::name() const

{

    return QLatin1String("TestClass");

}

bool TestClass::supportsExtension(Extension extension) const

{

    if (extension == Callable)

        return (m_callableMode != NotCallable);

    if (extension == HasInstance)

        return m_hasInstance;

    return false;

}

QVariant TestClass::extension(Extension extension,

                              const QVariant &argument)

{

    m_lastExtensionType = extension;

    m_lastExtensionArgument = argument;

    if (extension == Callable) {

        Q_ASSERT(m_callableMode != NotCallable);

        QScriptContext *ctx = qvariant_cast<QScriptContext*>(argument);

        if (m_callableMode == CallableReturnsSum) {

            qsreal sum = 0;

            for (int i = 0; i < ctx->argumentCount(); ++i)

                sum += ctx->argument(i).toNumber();

            QScriptValueIterator it(ctx->thisObject());

            while (it.hasNext()) {

                it.next();

                sum += it.value().toNumber();

            }

            return sum;

        } else if (m_callableMode == CallableReturnsArgument) {

            return qVariantFromValue(ctx->argument(0));

        } else if (m_callableMode == CallableReturnsInvalidVariant) {

            return QVariant();

        }

    } else if (extension == HasInstance) {

        Q_ASSERT(m_hasInstance);

        QScriptValueList args = qvariant_cast<QScriptValueList>(argument);

        QScriptValue obj = args.at(0);

        QScriptValue value = args.at(1);

        return value.property("foo").equals(obj.property("foo"));

    }

    return QVariant();

}

QScriptValue TestClass::lastQueryPropertyObject() const

{

    return m_lastQueryPropertyObject;

}

QScriptString TestClass::lastQueryPropertyName() const

{

    return m_lastQueryPropertyName;

}

QScriptClass::QueryFlags TestClass::lastQueryPropertyFlags() const

{

    return m_lastQueryPropertyFlags;

}

QScriptValue TestClass::lastPropertyObject() const

{

    return m_lastPropertyObject;

}

QScriptString TestClass::lastPropertyName() const

{

    return m_lastPropertyName;

}

uint TestClass::lastPropertyId() const

{

    return m_lastPropertyId;

}

QScriptValue TestClass::lastSetPropertyObject() const

{

    return m_lastSetPropertyObject;

}

QScriptString TestClass::lastSetPropertyName() const

{

    return m_lastSetPropertyName;

}

uint TestClass::lastSetPropertyId() const

{

    return m_lastSetPropertyId;

}

QScriptValue TestClass::lastSetPropertyValue() const

{

    return m_lastSetPropertyValue;

}

QScriptValue TestClass::lastPropertyFlagsObject() const

{

    return m_lastPropertyFlagsObject;

}

QScriptString TestClass::lastPropertyFlagsName() const

{

    return m_lastPropertyFlagsName;

}

uint TestClass::lastPropertyFlagsId() const

{

    return m_lastPropertyFlagsId;

}

QScriptClass::Extension TestClass::lastExtensionType() const

{

    return m_lastExtensionType;

}

QVariant TestClass::lastExtensionArgument() const

{

    return m_lastExtensionArgument;

}

void TestClass::clearReceivedArgs()

{

    m_lastQueryPropertyObject = QScriptValue();

    m_lastQueryPropertyName = QScriptString();

    m_lastQueryPropertyFlags = 0;

    m_lastPropertyObject = QScriptValue();

    m_lastPropertyName = QScriptString();

    m_lastPropertyId = uint(-1);

    m_lastSetPropertyObject = QScriptValue();

    m_lastSetPropertyName = QScriptString();

    m_lastSetPropertyId = uint(-1);

    m_lastSetPropertyValue = QScriptValue();

    m_lastPropertyFlagsObject = QScriptValue();

    m_lastPropertyFlagsName = QScriptString();

    m_lastPropertyFlagsId = uint(-1);

    m_lastExtensionType = static_cast<QScriptClass::Extension>(-1);

    m_lastExtensionArgument = QVariant();

}

void TestClass::setIterationEnabled(bool enable)

{

    m_iterationEnabled = enable;

}

bool TestClass::isIterationEnabled() const

{

    return m_iterationEnabled;

}

void TestClass::setCallableMode(CallableMode mode)

{

    m_callableMode = mode;

}

TestClass::CallableMode TestClass::callableMode() const

{

    return m_callableMode;

}

void TestClass::setHasInstance(bool hasInstance)

{

    m_hasInstance = hasInstance;

}

bool TestClass::hasInstance() const

{

    return m_hasInstance;

}

TestClassPropertyIterator::TestClassPropertyIterator(const QHash<QScriptString, TestClass::CustomProperty*> &props,

                                     const QScriptValue &object)

    : QScriptClassPropertyIterator(object)

{

    m_props = props;

    toFront();

}

TestClassPropertyIterator::~TestClassPropertyIterator()

{

}

bool TestClassPropertyIterator::hasNext() const

{

    return m_index < m_props.size();

}

void TestClassPropertyIterator::next()

{

    m_last = m_index;

    ++m_index;

}

bool TestClassPropertyIterator::hasPrevious() const

{

    return m_index > 0;

}