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

**

** Copyright (C) 2010 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$

**

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

#ifdef QT3_SUPPORT

#include <Qt3Support/Qt3Support>

#endif

#include <QtTest/QtTest>

#ifndef Q_OS_WINCE

#include "../../shared/util.h"

#include <QtGui>

#include <math.h>

#include "QtTest/qtestaccessible.h"

#if defined(Q_OS_WINCE)

extern "C" bool SystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni);

#define SPI_GETPLATFORMTYPE 257

inline bool IsValidCEPlatform() {

    wchar_t tszPlatform[64];

    if (SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(tszPlatform) / sizeof(*tszPlatform), tszPlatform, 0)) {

        QString platform = QString::fromWCharArray(tszPlatform);

        if ((platform == QLatin1String("PocketPC")) || (platform == QLatin1String("Smartphone")))

            return false;

    }

    return true;

}

#endif

static inline bool verifyChild(QWidget *child, QAccessibleInterface *interface,

                               int index, const QRect &domain)

{

    if (!child) {

        qWarning("tst_QAccessibility::verifyChild: null pointer to child.");

        return false;

    }

    if (!interface) {

        qWarning("tst_QAccessibility::verifyChild: null pointer to interface.");

        return false;

    }

    // QAccessibleInterface::childAt():

    // Calculate global child position and check that the interface

    // returns the correct index for that position.

    QPoint globalChildPos = child->mapToGlobal(QPoint(0, 0));

    int indexFromChildAt = interface->childAt(globalChildPos.x(), globalChildPos.y());

    if (indexFromChildAt != index) {

        qWarning("tst_QAccessibility::verifyChild (childAt()):");

        qWarning() << "Expected:" << index;

        qWarning() << "Actual:  " << indexFromChildAt;

        return false;

    }

    // QAccessibleInterface::rect():

    // Calculate global child geometry and check that the interface

    // returns a QRect which is equal to the calculated QRect.

    const QRect expectedGlobalRect = QRect(globalChildPos, child->size());

    const QRect rectFromInterface = interface->rect(index);

    if (expectedGlobalRect != rectFromInterface) {

        qWarning("tst_QAccessibility::verifyChild (rect()):");

        qWarning() << "Expected:" << expectedGlobalRect;

        qWarning() << "Actual:  " << rectFromInterface;

        return false;

    }

    // Verify that the child is within its domain.

    if (!domain.contains(rectFromInterface)) {

        qWarning("tst_QAccessibility::verifyChild: Child is not within its domain.");

        return false;

    }

    // Verify that we get a valid QAccessibleInterface for the child.

    QAccessibleInterface *childInterface = QAccessible::queryAccessibleInterface(child);

    if (!childInterface) {

        qWarning("tst_QAccessibility::verifyChild: Failed to retrieve interface for child.");

        return false;

    }

    // QAccessibleInterface::indexOfChild():

    // Verify that indexOfChild() returns an index equal to the index passed by,

    // or -1 if child is "Self" (index == 0).

    int indexFromIndexOfChild = interface->indexOfChild(childInterface);

    delete childInterface;

    int expectedIndex = index == 0 ? -1 : index;

    if (indexFromIndexOfChild != expectedIndex) {

        qWarning("tst_QAccessibility::verifyChild (indexOfChild()):");

        qWarning() << "Expected:" << expectedIndex;

        qWarning() << "Actual:  " << indexFromIndexOfChild;

        return false;

    }

    // Navigate to child, compare its object and role with the interface from queryAccessibleInterface(child).

    {

        QAccessibleInterface *navigatedChildInterface = 0;

        const int status = interface->navigate(QAccessible::Child, index, &navigatedChildInterface);

        // We are navigating to a separate widget/interface, so status should be 0.

        if (status != 0)

            return false;

        if (navigatedChildInterface == 0)

            return false;

        delete navigatedChildInterface;

    }

    return true;

}

static inline int indexOfChild(QAccessibleInterface *parentInterface, QWidget *childWidget)

{

    if (!parentInterface || !childWidget)

        return -1;

    QAccessibleInterface *childInterface = QAccessibleInterface::queryAccessibleInterface(childWidget);

    if (!childInterface)

        return -1;

    int index = parentInterface->indexOfChild(childInterface);

    delete childInterface;

    return index;

}

#define EXPECT(cond) \

    do { \

        if (!errorAt && !(cond)) { \

            errorAt = __LINE__; \

            qWarning("level: %d, middle: %d, role: %d (%s)", treelevel, middle, iface->role(0), #cond); \

        } \

    } while (0)

static int verifyHierarchy(QAccessibleInterface *iface)

{

    int errorAt = 0;

    int entry = 0;

    static int treelevel = 0;   // for error diagnostics

    QAccessibleInterface *middleChild, *if2, *if3;

    middleChild = 0;

    ++treelevel;

    int middle = iface->childCount()/2 + 1;

    if (iface->childCount() >= 2) {

        entry = iface->navigate(QAccessible::Child, middle, &middleChild);

    }

    for (int i = 0; i < iface->childCount() && !errorAt; ++i) {

        entry = iface->navigate(QAccessible::Child, i + 1, &if2);

        if (entry == 0) {

            // navigate Ancestor...

            QAccessibleInterface *parent = 0;

            entry = if2->navigate(QAccessible::Ancestor, 1, &parent);

            EXPECT(entry == 0 && iface->object() == parent->object());

            delete parent;

            // navigate Sibling...

            if (middleChild) {

                entry = if2->navigate(QAccessible::Sibling, middle, &if3);

                EXPECT(entry == 0 && if3->object() == middleChild->object());

                delete if3;

                EXPECT(iface->indexOfChild(middleChild) == middle);

            }

            // verify children...

            if (!errorAt)

                errorAt = verifyHierarchy(if2);

            delete if2;

        } else {

            // leaf nodes

        }

    }

    delete middleChild;

    --treelevel;

    return errorAt;

}

//TESTED_FILES=

class tst_QAccessibility : public QObject

{

    Q_OBJECT

public:

    tst_QAccessibility();

    virtual ~tst_QAccessibility();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void eventTest();

    void customWidget();

    void deletedWidget();

    void childCount();

    void childAt(); // also indexOfChild

    void relationTo();

    void navigateGeometric();

    void navigateHierarchy();

    void navigateSlider();

    void navigateCovered();

    void navigateControllers();

    void navigateLabels();

    void text();

    void setText();

    void hideShowTest();

    void userActionCount();

    void actionText();

    void doAction();

    void buttonTest();

    void sliderTest();

    void scrollBarTest();

    void tabTest();

    void menuTest();

    void spinBoxTest();

    void doubleSpinBoxTest();

    void textEditTest();

    void textBrowserTest();

    void listViewTest();

    void mdiAreaTest();

    void mdiSubWindowTest();

    void lineEditTest();

    void workspaceTest();

    void dialogButtonBoxTest();

    void dialTest();

    void rubberBandTest();

    void abstractScrollAreaTest();

    void scrollAreaTest();

    void tableWidgetTest();

    void tableViewTest();

    void calendarWidgetTest();

    void dockWidgetTest();

    void pushButtonTest();

    void comboBoxTest();

    void accessibleName();

    void treeWidgetTest();

    void labelTest();

    void accelerators();

private:

    QWidget *createGUI();

};

const double Q_PI = 3.14159265358979323846;

QString eventName(const int ev)

{

    switch(ev) {

    case 0x0001: return "SoundPlayed";

    case 0x0002: return "Alert";

    case 0x0003: return "ForegroundChanged";

    case 0x0004: return "MenuStart";

    case 0x0005: return "MenuEnd";

    case 0x0006: return "PopupMenuStart";

    case 0x0007: return "PopupMenuEnd";

    case 0x000C: return "ContextHelpStart";

    case 0x000D: return "ContextHelpEnd";

    case 0x000E: return "DragDropStart";

    case 0x000F: return "DragDropEnd";

    case 0x0010: return "DialogStart";

    case 0x0011: return "DialogEnd";

    case 0x0012: return "ScrollingStart";

    case 0x0013: return "ScrollingEnd";

    case 0x0018: return "MenuCommand";

    case 0x8000: return "ObjectCreated";

    case 0x8001: return "ObjectDestroyed";

    case 0x8002: return "ObjectShow";

    case 0x8003: return "ObjectHide";

    case 0x8004: return "ObjectReorder";

    case 0x8005: return "Focus";

    case 0x8006: return "Selection";

    case 0x8007: return "SelectionAdd";

    case 0x8008: return "SelectionRemove";

    case 0x8009: return "SelectionWithin";

    case 0x800A: return "StateChanged";

    case 0x800B: return "LocationChanged";

    case 0x800C: return "NameChanged";

    case 0x800D: return "DescriptionChanged";

    case 0x800E: return "ValueChanged";

    case 0x800F: return "ParentChanged";

    case 0x80A0: return "HelpChanged";

    case 0x80B0: return "DefaultActionChanged";

    case 0x80C0: return "AcceleratorChanged";

    default: return "Unknown Event";

    }

}

static QString stateNames(int state)

{

    QString stateString;

    if (state == 0x00000000) stateString += " Normal";

    if (state & 0x00000001) stateString += " Unavailable";

    if (state & 0x00000002) stateString += " Selected";

    if (state & 0x00000004) stateString += " Focused";

    if (state & 0x00000008) stateString += " Pressed";

    if (state & 0x00000010) stateString += " Checked";

    if (state & 0x00000020) stateString += " Mixed";

    if (state & 0x00000040) stateString += " ReadOnly";

    if (state & 0x00000080) stateString += " HotTracked";

    if (state & 0x00000100) stateString += " DefaultButton";

    if (state & 0x00000200) stateString += " Expanded";

    if (state & 0x00000400) stateString += " Collapsed";

    if (state & 0x00000800) stateString += " Busy";

    if (state & 0x00001000) stateString += " Floating";

    if (state & 0x00002000) stateString += " Marqueed";

    if (state & 0x00004000) stateString += " Animated";

    if (state & 0x00008000) stateString += " Invisible";

    if (state & 0x00010000) stateString += " Offscreen";

    if (state & 0x00020000) stateString += " Sizeable";

    if (state & 0x00040000) stateString += " Moveable";

    if (state & 0x00080000) stateString += " SelfVoicing";

    if (state & 0x00100000) stateString += " Focusable";

    if (state & 0x00200000) stateString += " Selectable";

    if (state & 0x00400000) stateString += " Linked";

    if (state & 0x00800000) stateString += " Traversed";

    if (state & 0x01000000) stateString += " MultiSelectable";

    if (state & 0x02000000) stateString += " ExtSelectable";

    if (state & 0x04000000) stateString += " AlertLow";

    if (state & 0x08000000) stateString += " AlertMedium";

    if (state & 0x10000000) stateString += " AlertHigh";

    if (state & 0x20000000) stateString += " Protected";

    if (state & 0x3fffffff) stateString += " Valid";

    if (stateString.isEmpty())

        stateString = "Unknown state " + QString::number(state);

    return stateString;

}

QAccessible::State state(QWidget * const widget)

{

    QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(widget);

    Q_ASSERT(iface);

    QAccessible::State state = iface->state(0);

    delete iface;

    return state;

}

void printState(QWidget * const widget)

{

    qDebug() << "State for" << widget->metaObject()->className() << stateNames(state(widget));

}

void printState(QAccessibleInterface * const iface, const int child = 0)

{

    qDebug() << "State for" << iface->object()->metaObject()->className() << "child" << child

             <<  iface->text(QAccessible::Name, child) << stateNames(iface->state(child));

}

class QtTestAccessibleWidget: public QWidget

{

    Q_OBJECT

public:

    QtTestAccessibleWidget(QWidget *parent, const char *name): QWidget(parent)

    {

        setObjectName(name);

        QPalette pal;

        pal.setColor(backgroundRole(), Qt::black);//black is beautiful

        setPalette(pal);

        setFixedSize(5, 5);

    }

};

#ifdef QTEST_ACCESSIBILITY

class QtTestAccessibleWidgetIface: public QAccessibleWidget

{

public:

    QtTestAccessibleWidgetIface(QtTestAccessibleWidget *w): QAccessibleWidget(w) {}

    QString text(Text t, int control) const

    {

        if (t == Help)

            return QString::fromLatin1("Help yourself");

        return QAccessibleWidget::text(t, control);

    }

    static QAccessibleInterface *ifaceFactory(const QString &key, QObject *o)

    {

        if (key == "QtTestAccessibleWidget")

            return new QtTestAccessibleWidgetIface(static_cast<QtTestAccessibleWidget*>(o));

        return 0;

    }

};

#endif

tst_QAccessibility::tst_QAccessibility()

{

}

tst_QAccessibility::~tst_QAccessibility()

{

}

void tst_QAccessibility::initTestCase()

{

#ifdef QTEST_ACCESSIBILITY

    QTestAccessibility::initialize();

    QAccessible::installFactory(QtTestAccessibleWidgetIface::ifaceFactory);

#endif

}

void tst_QAccessibility::cleanupTestCase()

{

#ifdef QTEST_ACCESSIBILITY

    QTestAccessibility::cleanup();

#endif

}

void tst_QAccessibility::init()

{

    QTestAccessibility::clearEvents();

}

void tst_QAccessibility::cleanup()

{

#ifdef QTEST_ACCESSIBILITY

    const EventList list = QTestAccessibility::events();

    if (!list.isEmpty()) {

        qWarning("%d accessibility event(s) were not handled in testfunction '%s':", list.count(),

                 QString(QTest::currentTestFunction()).toAscii().constData());

        for (int i = 0; i < list.count(); ++i)

            qWarning(" %d: Object: %p Event: '%s' (%d) Child: %d", i + 1, list.at(i).object,

                     eventName(list.at(i).event).toAscii().constData(), list.at(i).event, list.at(i).child);

    }

    QTestAccessibility::clearEvents();

#else

    QSKIP("Test needs accessibility support.", SkipAll);

#endif

}

void tst_QAccessibility::eventTest()

{

#ifdef QTEST_ACCESSIBILITY

    QPushButton* button = new QPushButton(0);

    button->setObjectName(QString("Olaf"));

    button->show();

    QVERIFY_EVENT(button, 0, QAccessible::ObjectShow);

    button->setFocus(Qt::MouseFocusReason);

    QTestAccessibility::clearEvents();

    QTest::mouseClick(button, Qt::LeftButton, 0, QPoint(button->width()-7,button->height()-5));

    QVERIFY_EVENT(button, 0, QAccessible::StateChanged);

    QVERIFY_EVENT(button, 0, QAccessible::StateChanged);

    button->hide();

    QVERIFY_EVENT(button, 0, QAccessible::ObjectHide);

    delete button;

#else

    QSKIP("Test needs accessibility support.", SkipAll);

#endif

}

void tst_QAccessibility::customWidget()

{

#ifdef QTEST_ACCESSIBILITY

    QtTestAccessibleWidget* widget = new QtTestAccessibleWidget(0, "Heinz");

    QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(widget);

    QVERIFY(iface != 0);

    QVERIFY(iface->isValid());

    QCOMPARE(iface->object(), (QObject*)widget);

    QCOMPARE(iface->object()->objectName(), QString("Heinz"));

    QCOMPARE(iface->text(QAccessible::Help, 0), QString("Help yourself"));

    delete iface;

    delete widget;

#else

    QSKIP("Test needs accessibility support.", SkipAll);

#endif

}

void tst_QAccessibility::deletedWidget()

{

#ifdef QTEST_ACCESSIBILITY

    QtTestAccessibleWidget *widget = new QtTestAccessibleWidget(0, "Ralf");

    QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(widget);

    QVERIFY(iface != 0);

    QVERIFY(iface->isValid());

    QCOMPARE(iface->object(), (QObject*)widget);

    delete widget;

    widget = 0;

    QVERIFY(!iface->isValid());

    delete iface;

#else

    QSKIP("Test needs accessibility support.", SkipAll);

#endif

}

QWidget *tst_QAccessibility::createGUI()