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

**

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

#include <qapplication.h>

#include <qtextedit.h>

#include <qpushbutton.h>

#include <qmainwindow.h>

#include <qstatusbar.h>

#include <qboxlayout.h>

#include <qdebug.h>

#include <qstring.h>

#include <qshortcut.h>

class AccelForm;

QT_BEGIN_NAMESPACE

class QMainWindow;

class QTextEdit;

QT_END_NAMESPACE

//TESTED_CLASS=

//TESTED_FILES=

class tst_QShortcut : public QObject

{

    Q_OBJECT

public:

    tst_QShortcut();

    virtual ~tst_QShortcut();

    enum Action {

        SetupAccel,

        TestAccel,

        ClearAll

    } currentAction;

    enum Widget {

        NoWidget,

        TriggerSlot1,

        TriggerSlot2,

        TriggerSlot3,

        TriggerSlot4,

        TriggerSlot5,

        TriggerSlot6,

        TriggerSlot7

    };

    enum Result {

        NoResult,

        Slot1Triggered,

        Slot2Triggered,

        Slot3Triggered,

        Slot4Triggered,

        Slot5Triggered,

        Slot6Triggered,

        Slot7Triggered,

        Ambiguous

    } currentResult;

public slots:

    void slotTrig1() { currentResult = Slot1Triggered; }

    void slotTrig2() { currentResult = Slot2Triggered; }

    void slotTrig3() { currentResult = Slot3Triggered; }

    void slotTrig4() { currentResult = Slot4Triggered; }

    void slotTrig5() { currentResult = Slot5Triggered; }

    void slotTrig6() { currentResult = Slot6Triggered; }

    void slotTrig7() { currentResult = Slot7Triggered; }

    void ambigSlot1() { currentResult = Ambiguous; ambigResult = Slot1Triggered; }

    void ambigSlot2() { currentResult = Ambiguous; ambigResult = Slot2Triggered; }

    void ambigSlot3() { currentResult = Ambiguous; ambigResult = Slot3Triggered; }

    void ambigSlot4() { currentResult = Ambiguous; ambigResult = Slot4Triggered; }

    void ambigSlot5() { currentResult = Ambiguous; ambigResult = Slot5Triggered; }

    void ambigSlot6() { currentResult = Ambiguous; ambigResult = Slot6Triggered; }

    void ambigSlot7() { currentResult = Ambiguous; ambigResult = Slot7Triggered; }

    void statusMessage( const QString& message ) { sbText = message; }

    void shortcutDestroyed(QObject* obj);

public slots:

    void initTestCase();

    void cleanupTestCase();

private slots:

    void number_data();

    void number();

    void text_data();

    void text();

    void disabledItems();

    void ambiguousItems();

    void ambiguousRotation();

    void keypressConsumption();

    void unicodeCompare();

    void context();

protected:

    static Qt::KeyboardModifiers toButtons( int key );

    void defElements();

    void clearAllShortcuts();

    QShortcut *setupShortcut(int testWidget, const QKeySequence &ks);

    QShortcut *setupShortcut(int testWidget, const QString &txt, int k1 = 0, int k2 = 0, int k3 = 0, int k4 = 0);

    QShortcut *setupShortcut(QWidget *parent, const char *name, int testWidget, const QString &txt, int k1 = 0, int k2 = 0, int k3 = 0, int k4 = 0);

    QShortcut *setupShortcut(QWidget *parent, const char *name, int testWidget, const QKeySequence &ks, Qt::ShortcutContext context = Qt::WindowShortcut);

    void sendKeyEvents(QWidget *w, int k1, QChar c1 = 0, int k2 = 0, QChar c2 = 0, int k3 = 0, QChar c3 = 0, int k4 = 0, QChar c4 = 0);

    void sendKeyEvents(int k1, QChar c1 = 0, int k2 = 0, QChar c2 = 0, int k3 = 0, QChar c3 = 0, int k4 = 0, QChar c4 = 0);

    void testElement();

    QMainWindow *mainW;

    QList<QShortcut*> shortcuts;

    QTextEdit *edit;

    QString sbText;

    Result ambigResult;

};

QT_BEGIN_NAMESPACE

template<> struct QMetaTypeId<tst_QShortcut::Widget>

{ enum { Defined = 1 }; static inline int qt_metatype_id() { return QMetaType::Int; } };

template<> struct QMetaTypeId<tst_QShortcut::Result>

{ enum { Defined = 1 }; static inline int qt_metatype_id() { return QMetaType::Int; } };

template<> struct QMetaTypeId<tst_QShortcut::Action>

{ enum { Defined = 1 }; static inline int qt_metatype_id() { return QMetaType::Int; } };

QT_END_NAMESPACE

class TestEdit : public QTextEdit

{

    Q_OBJECT

public:

    TestEdit(QWidget *parent, const char *name)

	: QTextEdit(parent)

    {

        setObjectName(name);

    }

protected:

    bool event(QEvent *e) {

        // Make testedit allow any Ctrl+Key as shortcut

        if (e->type() == QEvent::ShortcutOverride) {

            QKeyEvent *ke = static_cast<QKeyEvent*>(e);

            if (ke->modifiers() == Qt::ControlModifier

                && ke->key() > Qt::Key_Any

                && ke->key() < Qt::Key_ydiaeresis) {

                ke->ignore();

                return true;

            }

        }

        // If keypress not processed as normal, check for

        // Ctrl+Key event, and input custom string for

        // result comparison.

        if (e->type() == QEvent::KeyPress) {

            QKeyEvent *ke = static_cast<QKeyEvent*>(e);

            if (ke->modifiers() && ke->key() > Qt::Key_Any

                && ke->key() < Qt::Key_ydiaeresis) {

                if (ke->modifiers() == Qt::ControlModifier)

                    insertPlainText(QString("<Ctrl+%1>").arg(char(ke->key())));

                else if (ke->modifiers() == Qt::AltModifier)

                    insertPlainText(QString("<Alt+%1>").arg(char(ke->key())));

                else if (ke->modifiers() == Qt::ShiftModifier)

                    insertPlainText(QString("<Shift+%1>").arg(char(ke->key())));

                return true;

            }

        }

        return QTextEdit::event(e);

    }

};

tst_QShortcut::tst_QShortcut(): mainW( 0 )

{

}

tst_QShortcut::~tst_QShortcut()

{

    clearAllShortcuts();

}

void tst_QShortcut::initTestCase()

{

    currentResult = NoResult;

    mainW = new QMainWindow(0);

    mainW->setWindowFlags(Qt::X11BypassWindowManagerHint);

    edit  = new TestEdit(mainW, "test_edit");

    mainW->setFixedSize( 100, 100 );

    mainW->setCentralWidget( edit );

    mainW->show();

    mainW->activateWindow();

#ifdef Q_WS_X11

    qt_x11_wait_for_window_manager(mainW);

#endif

    QTest::qWait(100);

    connect( mainW->statusBar(), SIGNAL(messageChanged(const QString&)),

	     this, SLOT(statusMessage(const QString&)) );

}

void tst_QShortcut::cleanupTestCase()

{

    delete mainW;

}

Qt::KeyboardModifiers tst_QShortcut::toButtons( int key )

{

    Qt::KeyboardModifiers result = Qt::NoModifier;

    if ( key & Qt::SHIFT )

	result |= Qt::ShiftModifier;

    if ( key & Qt::CTRL )

	result |= Qt::ControlModifier;

   if ( key & Qt::META )

	result |= Qt::MetaModifier;

   if ( key & Qt::ALT )

	result |= Qt::AltModifier;

    return result;

}

void tst_QShortcut::defElements()

{

    QTest::addColumn<int>("action");

    QTest::addColumn<int>("testWidget");

    QTest::addColumn<QString>("txt");

    QTest::addColumn<int>("k1");

    QTest::addColumn<int>("c1");

    QTest::addColumn<int>("k2");

    QTest::addColumn<int>("c2");

    QTest::addColumn<int>("k3");

    QTest::addColumn<int>("c3");

    QTest::addColumn<int>("k4");

    QTest::addColumn<int>("c4");

    QTest::addColumn<int>("result");

}

void tst_QShortcut::number()

{

    // We expect a failure on these tests, until QtTestKeyboard is

    // fixed to do real platform dependent keyboard simulations

    if (QTest::currentDataTag() == QString("N006a:Shift+Tab - [BackTab]")

        || QTest::currentDataTag() == QString("N006b:Shift+Tab - [Shift+BackTab]"))

        QEXPECT_FAIL("", "FLAW IN QTESTKEYBOARD: Keyboard events not passed through "

                        "platform dependent key handling code", Continue);

    testElement();

}

void tst_QShortcut::text()

{

    testElement();

}

// ------------------------------------------------------------------

// Number Elements --------------------------------------------------

// ------------------------------------------------------------------

void tst_QShortcut::number_data()

{

    defElements();

    // Clear all

    QTest::newRow("N00 - clear") << ClearAll <<0<<QString("")<<0<<0<<0<<0<<0<<0<<0<<0<<0;

    //===========================================

    // [Shift + key] on non-shift shortcuts testing

    //===========================================

    /* Testing Single Sequences

       Shift + Qt::Key_M    on  Qt::Key_M

               Qt::Key_M    on  Qt::Key_M

       Shift + Qt::Key_Plus on  Qt::Key_Pluss

               Qt::Key_Plus on  Qt::Key_Pluss

    */

    QTest::newRow("N001 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("N001:Shift + M - [M]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_M) << int('M') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N001:M - [M]")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N001 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("N001:Shift++ [+]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N001:+ [+]")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N001 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

       Shift + Qt::Key_M    on  Shift + Qt::Key_M

               Qt::Key_M    on  Shift + Qt::Key_M

       Shift + Qt::Key_Plus on  Shift + Qt::Key_Pluss

               Qt::Key_Plus on  Shift + Qt::Key_Pluss

    */

    QTest::newRow("N002 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::SHIFT + Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N002:Shift+M - [Shift+M]")  << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_M) << int('M') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N002:M - [Shift+M]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N002 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::SHIFT + Qt::Key_Plus) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N002:Shift++ [Shift++]")    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N002:+ [Shift++]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N002 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

       Shift + Qt::Key_F1   on  Qt::Key_F1

               Qt::Key_F1   on  Qt::Key_F1

    */

    QTest::newRow("N003 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("N003:Shift+F1 - [F1]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N003:F1 - [F1]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N003 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

       Shift + Qt::Key_F1   on  Shift + Qt::Key_F1

               Qt::Key_F1   on  Shift + Qt::Key_F1

    */

    QTest::newRow("N004 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::SHIFT + Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N004:Shift+F1 - [Shift+F1]")<< TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N004:F1 - [Shift+F1]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N004 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

               Qt::Key_Tab      on  Qt::Key_Tab

       Shift + Qt::Key_Tab      on  Qt::Key_Tab

               Qt::Key_Backtab  on  Qt::Key_Tab

       Shift + Qt::Key_Backtab  on  Qt::Key_Tab

    */

    QTest::newRow("N005a - slot1")		           << SetupAccel << TriggerSlot1 << QString("")<< int(Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N005a:Tab - [Tab]")	           << TestAccel << NoWidget << QString("")     << int(Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("N005a:Shift+Tab - [Tab]")          << TestAccel << NoWidget << QString("")     << int(Qt::SHIFT + Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    // (Shift+)BackTab != Tab, but Shift+BackTab == Shift+Tab

    QTest::newRow("N005a:Backtab - [Tab]")	           << TestAccel << NoWidget << QString("")     << int(Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N005a:Shift+Backtab - [Tab]")      << TestAccel << NoWidget << QString("")     << int(Qt::SHIFT + Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N005a - clear")		           << ClearAll << 0 << QString("")	       << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

               Qt::Key_Tab      on  Shift + Qt::Key_Tab

       Shift + Qt::Key_Tab      on  Shift + Qt::Key_Tab

               Qt::Key_Backtab  on  Shift + Qt::Key_Tab

       Shift + Qt::Key_Backtab  on  Shift + Qt::Key_Tab

    */

    QTest::newRow("N005b - slot1")		           << SetupAccel << TriggerSlot1 << QString("")<< int(Qt::SHIFT + Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N005b:Tab - [Shift+Tab]")          << TestAccel << NoWidget << QString("")     << int(Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N005b:Shift+Tab - [Shift+Tab]")    << TestAccel << NoWidget << QString("")     << int(Qt::SHIFT + Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N005b:BackTab - [Shift+Tab]")      << TestAccel << NoWidget << QString("")     << int(Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N005b:Shift+BackTab - [Shift+Tab]")<< TestAccel << NoWidget << QString("")     << int(Qt::SHIFT + Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N005b - clear")		           << ClearAll << 0 << QString("")	       << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

               Qt::Key_Tab      on  Qt::Key_Backtab

       Shift + Qt::Key_Tab      on  Qt::Key_Backtab

               Qt::Key_Backtab  on  Qt::Key_Backtab

       Shift + Qt::Key_Backtab  on  Qt::Key_Backtab

    */

    QTest::newRow("N006a - slot1")		           << SetupAccel << TriggerSlot1 << QString("")<< int(Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N006a:Tab - [BackTab]")	           << TestAccel << NoWidget << QString("")     << int(Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    // This should work, since platform dependent code will transform the

    // Shift+Tab into a Shift+BackTab, which should trigger the shortcut

    QTest::newRow("N006a:Shift+Tab - [BackTab]")      << TestAccel << NoWidget << QString("")     << int(Qt::SHIFT + Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered; //XFAIL

    QTest::newRow("N006a:BackTab - [BackTab]")        << TestAccel << NoWidget << QString("")     << int(Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("N006a:Shift+BackTab - [BackTab]")  << TestAccel << NoWidget << QString("")     << int(Qt::SHIFT + Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N006a - clear")		           << ClearAll << 0 << QString("")	       << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

               Qt::Key_Tab      on  Shift + Qt::Key_Backtab

       Shift + Qt::Key_Tab      on  Shift + Qt::Key_Backtab

               Qt::Key_Backtab  on  Shift + Qt::Key_Backtab

       Shift + Qt::Key_Backtab  on  Shift + Qt::Key_Backtab

    */

    QTest::newRow("N006b - slot1")		           << SetupAccel << TriggerSlot1 << QString("")<< int(Qt::SHIFT + Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N006b:Tab - [Shift+BackTab]")      << TestAccel << NoWidget << QString("")     << int(Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N006b:Shift+Tab - [Shift+BackTab]")<< TestAccel << NoWidget << QString("")     << int(Qt::SHIFT + Qt::Key_Tab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N006b:BackTab - [Shift+BackTab]")  << TestAccel << NoWidget << QString("")     << int(Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N006b:Shift+BackTab - [Shift+BackTab]")<< TestAccel << NoWidget << QString("") << int(Qt::SHIFT + Qt::Key_Backtab) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered; //XFAIL

    QTest::newRow("N006b - clear")		           << ClearAll << 0 << QString("")	       << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    //===========================================

    // [Shift + key] and [key] on shortcuts with

    // and without modifiers

    //===========================================

    /* Testing Single Sequences

       Qt::Key_F1

       Shift + Qt::Key_F1

    */

    QTest::newRow("N007 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N007 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::SHIFT + Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N007:F1")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N007:Shift + F1")	    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_F1) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N007 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

       Qt::Key_M

       Shift + Qt::Key_M

       Ctrl  + Qt::Key_M

       Alt   + Qt::Key_M

    */

    QTest::newRow("N01 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N02 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::SHIFT + Qt::Key_M) << int('M') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N03 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::CTRL + Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N04 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::ALT + Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N:Qt::Key_M")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N:Shift+Qt::Key_M")		    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_M) << int('M') << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N:Ctrl+Qt::Key_M")		    << TestAccel << NoWidget << QString("")	    << int(Qt::CTRL + Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N:Alt+Qt::Key_M")		    << TestAccel << NoWidget << QString("")	    << int(Qt::ALT + Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    /* Testing Single Sequence Ambiguity

       Qt::Key_M on shortcut2

    */

    QTest::newRow("N05 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N:Qt::Key_M on slot")	    << TestAccel << NoWidget << QString("") << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << 0 << 0 << Ambiguous;

    QTest::newRow("N05 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Specialkeys

       Qt::Key_aring

       Qt::Key_Aring

       Qt::UNICODE_ACCEL + Qt::Key_K

    */

    QTest::newRow("N06 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::Key_Aring) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N07 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::SHIFT+Qt::Key_Aring) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N08 - slot2")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::UNICODE_ACCEL + Qt::Key_K) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N:Qt::Key_aring")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_Aring) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N:Qt::Key_Aring")		    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT+Qt::Key_Aring) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N:Qt::Key_aring - Text Form")   << TestAccel << NoWidget << QString("")	    << 0 << 0xC5 << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N:Qt::Key_Aring - Text Form")   << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT+0) << 0xC5 << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N:Qt::UNICODE_ACCEL + Qt::Key_K")   << TestAccel << NoWidget << QString("")	    << int(Qt::UNICODE_ACCEL + Qt::Key_K) << int('k') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N09 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Multiple Sequences

       Qt::Key_M

       Qt::Key_I, Qt::Key_M

       Shift+Qt::Key_I, Qt::Key_M

    */

    QTest::newRow("N10 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N11 - slot2")		    << SetupAccel << TriggerSlot2 << QString("")    << int(Qt::Key_I) << 0 << int(Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N12 - slot1")		    << SetupAccel << TriggerSlot1 << QString("")    << int(Qt::SHIFT + Qt::Key_I) << 0 << int(Qt::Key_M) << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("N:Qt::Key_M (2)")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N:Qt::Key_I, Qt::Key_M")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_I) << int('i') << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("N:Shift+Qt::Key_I, Qt::Key_M")	    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_I) << int('I') << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("N13 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

}

// ------------------------------------------------------------------

// Text Elements ----------------------------------------------------

// ------------------------------------------------------------------

void tst_QShortcut::text_data()

{

    defElements();

    // Clear all

    QTest::newRow("T00 - clear") << ClearAll <<0<<QString("")<<0<<0<<0<<0<<0<<0<<0<<0<<0;

    //===========================================

    // [Shift + key] on non-shift shortcuts testing

    //===========================================

    /* Testing Single Sequences

       Shift + Qt::Key_M    on  Qt::Key_M

               Qt::Key_M    on  Qt::Key_M

       Shift + Qt::Key_Plus on  Qt::Key_Pluss

               Qt::Key_Plus on  Qt::Key_Pluss

    */

    QTest::newRow("T001 - slot1")		    << SetupAccel << TriggerSlot1 << QString("M")   << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("T001:Shift+M - [M]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_M) << int('M') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("T001:M - [M]")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("T001 - slot2")		    << SetupAccel << TriggerSlot2 << QString("+")   << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("T001:Shift++ [+]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("T001:+ [+]")		    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("T001 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

       Shift + Qt::Key_M    on  Shift + Qt::Key_M

               Qt::Key_M    on  Shift + Qt::Key_M

       Shift + Qt::Key_Plus on  Shift + Qt::Key_Pluss

               Qt::Key_Plus on  Shift + Qt::Key_Pluss

       Shift + Ctrl + Qt::Key_Plus on  Ctrl + Qt::Key_Pluss

               Ctrl + Qt::Key_Plus on  Ctrl + Qt::Key_Pluss

    */

    QTest::newRow("T002 - slot1")		    << SetupAccel << TriggerSlot1 << QString("Shift+M")   << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("T002:Shift+M - [Shift+M]")  << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_M) << int('M') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("T002:M - [Shift+M]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_M) << int('m') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("T002 - slot2")		    << SetupAccel << TriggerSlot2 << QString("Shift++")   << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("T002:Shift++ [Shift++]")    << TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot2Triggered;

    QTest::newRow("T002:+ [Shift++]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("T002 - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all

    /* Testing Single Sequences

       Shift + Ctrl + Qt::Key_Plus on  Ctrl + Qt::Key_Plus

               Ctrl + Qt::Key_Plus on  Ctrl + Qt::Key_Plus

	              Qt::Key_Plus on  Ctrl + Qt::Key_Plus

    */

    QTest::newRow("T002b - slot1")		    << SetupAccel << TriggerSlot1 << QString("Ctrl++")    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    //commented out because the behaviour changed, those tests should be updated

    //QTest::newRow("T002b:Shift+Ctrl++ [Ctrl++]")<< TestAccel << NoWidget << QString("")	    << int(Qt::SHIFT + Qt::CTRL + Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("T002b:Ctrl++ [Ctrl++]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::CTRL + Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << Slot1Triggered;

    QTest::newRow("T002b:+ [Ctrl++]")	    << TestAccel << NoWidget << QString("")	    << int(Qt::Key_Plus) << int('+') << 0 << 0 << 0 << 0 << 0 << 0 << NoResult;

    QTest::newRow("T002b - clear")		    << ClearAll << 0 << QString("")		    << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0; // Clear all