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

**

** 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$

**

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

#include <QtTest/QtTest>

#if defined(Q_WS_MAC) && !defined (QT_MAC_USE_COCOA)

#include <private/qt_mac_p.h>

#undef verify // yes, lets reserve the word "verify"

#include <QApplication>

#include <QDebug>

#include <QTimer>

#include <QString>

#include <QFile>

#include <QVariant>

#include <QPushButton>

#include <QToolBar>

#include <QSlider>

#include <QListWidget>

#include <QTableWidget>

#include <QScrollArea>

#include <QLabel>

#include <QScrollBar>

#include <QTextEdit>

#include <QAccessibleInterface>

#include <QAccessible>

#include <QPluginLoader>

#include <private/qaccessible_mac_p.h>

#include <quiloader.h>

#include <sys/types.h> // for getpid()

#include <unistd.h>

Q_DECLARE_METATYPE(AXUIElementRef);

typedef QCFType<CFArrayRef> QCFArrayRef;

class tst_qaccessibility_mac : public QObject

{

Q_OBJECT

public slots:

    void printInfo();

    void testForm();

    void testButtons();

    void testLineEdit();

    void testLabel();

    void testGroups();

    void testTabWidget();

    void testTabBar();

    void testComboBox();

    void testDeleteWidget();

    void testDeleteWidgets();

    void testMultipleWindows();

    void testHiddenWidgets();

    void testActions();

    void testChangeState();

    void testSlider();

    void testScrollArea();

    void testListView();

    void testTableView();

    void testScrollBar();

    void testSplitter();

    void testTextEdit();

    void testItemViewsWithoutModel();

private slots:

    void testQAElement();

    void testQAInterface();

    // ui tests load an .ui file.

    void uitests_data();

    void uitests();

    void tests_data();

    void tests();

private:

    void runTest(const QString &testSlot);

};

/*

    VERIFYs that there is no error and prints an error message if there is.

*/

void testError(AXError error, const QString &text)

{

    if (error)

        qDebug() << "Error" << error << text;

    QVERIFY(error == 0);

}

/*

    Prints an CFArray holding CFStrings.

*/

void printCFStringArray(CFArrayRef array, const QString &title)

{

    const int numElements = CFArrayGetCount(array);

    qDebug() << "num" << title << " " <<  numElements;

    for (int i = 0; i < numElements; ++i) {

       CFStringRef str = (CFStringRef)CFArrayGetValueAtIndex(array, i);

       qDebug() << QCFString::toQString(str);

    }

}

QStringList toQStringList(const CFArrayRef array)

{

    const int numElements = CFArrayGetCount(array);

    QStringList qtStrings;

    for (int i = 0; i < numElements; ++i) {

        CFStringRef str = (CFStringRef)CFArrayGetValueAtIndex(array, i);

        qtStrings.append(QCFString::toQString(str));

    }

    return qtStrings;

}

QVariant AXValueToQVariant(AXValueRef value)

{

    QVariant var;

    const AXValueType type = AXValueGetType(value);

    switch (type) {

        case kAXValueCGPointType : {

            CGPoint point;

            if (AXValueGetValue(value, type, &point))

                var = QPointF(point.x, point.y);

        } break;

        case kAXValueCGSizeType : {

            CGSize size;

            if (AXValueGetValue(value, type, &size))

                var = QSizeF(size.width, size.height);

        } break;

        case kAXValueCGRectType :  {

            CGRect rect;

            if (AXValueGetValue(value, type, &rect))

                var = QRectF(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);

        } break;

        case kAXValueCFRangeType :

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

        case kAXValueAXErrorType :

#endif

        case kAXValueIllegalType :

        default:

        qDebug() << "Illegal/Unsuported AXValue:" << type;

        break;

    };

    return var;

}

/*

    Converts a CFTypeRef to a QVariant, for certain selected types. Prints

    an error message and returns QVariant() if the type is not supported.

*/

QVariant CFTypeToQVariant(CFTypeRef value)

{

    QVariant var;

    if (value == 0)

        return var;

    const uint typeID = CFGetTypeID(value);

    if (typeID == CFStringGetTypeID()) {

        var.setValue(QCFString::toQString((CFStringRef)value));

    } else if (typeID == CFBooleanGetTypeID()) {

        var.setValue((bool)CFBooleanGetValue((CFBooleanRef)value));

    } else if (typeID == AXUIElementGetTypeID()) {

        var.setValue((AXUIElementRef)value);

    } else if (typeID == AXValueGetTypeID()) {

        var = AXValueToQVariant((AXValueRef)value);

    } else if (typeID == CFNumberGetTypeID()) {

        CFNumberRef number = (CFNumberRef)value;

        if (CFNumberGetType(number) != kCFNumberSInt32Type)

            qDebug() << "unsupported number type" << CFNumberGetType(number);

        int theNumber;

        CFNumberGetValue(number, kCFNumberSInt32Type, &theNumber);

        var.setValue(theNumber);

    } else if (typeID == CFArrayGetTypeID()) {

        CFArrayRef cfarray = static_cast<CFArrayRef>(value);

        QVariantList list;

        CFIndex size = CFArrayGetCount(cfarray);

        for (CFIndex i = 0; i < size; ++i)

            list << CFTypeToQVariant(CFArrayGetValueAtIndex(cfarray, i));

        var.setValue(list);

    } else {

        QCFString str = CFCopyTypeIDDescription(typeID);

        qDebug() << "Unknown CFType: " << typeID << (QString)str;

    }

    return var;

}

/*

    Tests if a given attribute is supported by an element. Expects either

    no error or error -25205 (Not supported). Causes a test failure

    on other error values.

*/

bool supportsAttribute(AXUIElementRef element, CFStringRef attribute)

{

    CFArrayRef array;

    AXError err = AXUIElementCopyAttributeNames(element, &array);

    if (err) {

        testError(err, QLatin1String("unexpected error when testing for supported attribute") + QCFString::toQString(attribute));

        return false;

    }

    CFRange range;

    range.location = 0;

    range.length = CFArrayGetCount(array);

    return CFArrayContainsValue(array, range, attribute);

}

/*

    Returns the accessibility attribute specified with attribute in a QVariant

*/

QVariant attribute(AXUIElementRef element, CFStringRef attribute)

{

    CFTypeRef value = 0;

    AXError err = AXUIElementCopyAttributeValue(element, attribute, &value);

    testError(err, QString("Error getting element attribute ") + QCFString::toQString(attribute));

    if (err)

        return QVariant();

    return CFTypeToQVariant(value);

}

/*

    Returns the title for an element.

*/

QString title(AXUIElementRef element)

{

    return attribute(element, kAXTitleAttribute).toString();

}

/*

    Returns the role for an element.

*/

QString role(AXUIElementRef element)

{

    return attribute(element, kAXRoleAttribute).toString();

}

/*

    Returns the subrole for an element.

*/

QString subrole(AXUIElementRef element)

{

    return attribute(element, kAXSubroleAttribute).toString();

}

/*

    Returns the role description for an element.

*/

QString roleDescription(AXUIElementRef element)

{

    return attribute(element, kAXRoleDescriptionAttribute).toString();

}

/*

    Returns the enabled attribute for an element.

*/

bool enabled(AXUIElementRef element)

{

    return attribute(element, kAXEnabledAttribute).toBool();

}

/*

    Returns the value attribute for an element as an QVariant.

*/

QVariant value(AXUIElementRef element)

{

    return attribute(element, kAXValueAttribute);

}

QVariant value(QAElement element)

{

    return value(element.element());

}

/*

    Returns the description attribute for an element as an QVariant.

*/

QVariant description(AXUIElementRef element)

{

    return attribute(element, kAXDescriptionAttribute);

}

/*

    Returns the value attribute for an element as an bool.

*/

bool boolValue(AXUIElementRef element)

{

    return attribute(element, kAXValueAttribute).toBool();

}

/*

    Returns the parent for an element

*/

AXUIElementRef parent(AXUIElementRef element)

{

    return attribute(element, kAXParentAttribute).value<AXUIElementRef>();

}

/*

    Returns the (top-level) window(not a sheet or a drawer) for an element

*/

AXUIElementRef window(AXUIElementRef element)

{

    return attribute(element, kAXWindowAttribute).value<AXUIElementRef>();

}

/*

    Returns the (top-level) UI element(can also be a sheet or drawer) for an element

*/

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

AXUIElementRef topLevelUIElement(AXUIElementRef element)

{

    return attribute(element, kAXTopLevelUIElementAttribute).value<AXUIElementRef>();

}

#endif

/*

    Returns thie size of the element.

*/

QSizeF size(AXUIElementRef element)

{

    return attribute(element, kAXSizeAttribute).value<QSizeF>();

}

/*

    Returns the position of the element.

*/

QPointF position(AXUIElementRef element)

{

    return attribute(element, kAXPositionAttribute).value<QPointF>();

}

/*

    Returns the rect of the element.

*/

QRectF rect(AXUIElementRef element)

{

    return QRectF(position(element), size(element));

}

bool above(AXUIElementRef a, AXUIElementRef b)

{

    return (position(a).y() + size(a).height() <= position(b).y());

}

bool contains(AXUIElementRef a, AXUIElementRef b)

{

    return rect(a).contains(rect(b));

}

QList<AXUIElementRef> tabs(AXUIElementRef element)

{

    CFTypeRef value;

    AXError err = AXUIElementCopyAttributeValue(element, kAXTabsAttribute, &value);

    if (err)

        return QList<AXUIElementRef>();

    CFArrayRef array = (CFArrayRef)value;

    QList<AXUIElementRef> elements;

    const int count = CFArrayGetCount(array);

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

        elements.append((AXUIElementRef)CFArrayGetValueAtIndex(array, i));

    return elements;

}

QList<AXUIElementRef> elementListAttribute(AXUIElementRef element, CFStringRef attributeName)

{

    QList<AXUIElementRef> elementList;

    QVariantList variants = attribute(element, attributeName).value<QVariantList>();

    foreach(QVariant variant, variants)

        elementList.append(variant.value<AXUIElementRef>());

    return elementList;

}

AXUIElementRef elementAttribute(AXUIElementRef element, CFStringRef attributeName)

{

    return attribute(element, attributeName).value<AXUIElementRef>();

}

QString stringAttribute(AXUIElementRef element, CFStringRef attributeName)

{

    return attribute(element, attributeName).value<QString>();

}

/*

    Returns the UIElement at the given position.

*/

AXUIElementRef childAtPoint(QPointF position)

{

    AXUIElementRef element = 0;

    const AXError err = AXUIElementCopyElementAtPosition(AXUIElementCreateApplication(getpid()), position.x(), position.y(), &element);

    if (err) {

        qDebug() << "Error getting element at " << position;

        return 0;

    }

    return element;

}

/*

    Returns a QStringList containing the names of the actions the ui element supports

*/

QStringList actionNames(AXUIElementRef element)

{

    CFArrayRef cfStrings;

    const AXError err = AXUIElementCopyActionNames(element, &cfStrings);

    testError(err, "Unable to get action names");

    return toQStringList(cfStrings);

}

bool supportsAction(const AXUIElementRef element, const QString &actionName)

{

    const QStringList actions = actionNames(element);

    return actions.contains(actionName);

}

bool performAction(const AXUIElementRef element, const QString &actionName)

{

    const AXError err = AXUIElementPerformAction(element, QCFString(actionName));

    return (err == 0);

}

/*

    Om 10.4 and up, verifyes the AXRoleDescription attribute for an element,

    on 10.3 and below this test always passes.

    The reason for this is that the HICopyAccessibilityRoleDescription call

    used to implement this functionality was introduced in 10.4.

*/

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

    #define VERIFY_ROLE_DESCRIPTION(ELEMENT,  TEXT) \

            QCOMPARE(roleDescription(ELEMENT), QString(TEXT))

#else

    #define VERIFY_ROLE_DESCRIPTION(ELEMENT,  TEXT) QVERIFY(true)

#endif

CFArrayRef childrenArray(AXUIElementRef element)

{

    CFTypeRef value = 0;

    AXError err = AXUIElementCopyAttributeValue(element, kAXChildrenAttribute, &value);

    if (!err && CFGetTypeID(value) == CFArrayGetTypeID()) {

        return (CFArrayRef)value;

    }

    return CFArrayCreate(0,0,0,0);

}

/*

    Gest the child count from an element.

*/

int numChildren(AXUIElementRef element)

{

    return CFArrayGetCount(childrenArray(element));

}

/*

    Gets the child with index childIndex from element. Returns 0 if not found.

*/

AXUIElementRef child(AXUIElementRef element, int childIndex)

{

    CFArrayRef children = childrenArray(element);

    if (childIndex >= CFArrayGetCount(children))

        return 0;

    const void *data  = CFArrayGetValueAtIndex(children, childIndex);

    return (AXUIElementRef)data;

}

/*

    Gets the child titled childTitle from element. Returns 0 if not found.

*/

AXUIElementRef childByTitle(AXUIElementRef element, const QString &childTitle)

{

    CFArrayRef children  = childrenArray(element);

    const int numChildren = CFArrayGetCount(children);

    for (int i = 0; i < numChildren; ++i) {

        const AXUIElementRef childElement = (AXUIElementRef)CFArrayGetValueAtIndex(children, i);

        // Test for support for title attribute before getting it to avoid test fail.

        if (supportsAttribute(childElement, kAXTitleAttribute) && title(childElement) == childTitle)

            return childElement;

    }

    return 0;

}

/*

    Gets the child with the given value from element. Returns 0 if not found.

*/