1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 #include <QEventLoop>

    20 #include <QDebug>

    21 #include <QtCore>

    22 #include "mytestwindowgroup.h"

    23 #include <W32STD.H>

    24 #include <xqkeycapture.h>

    25 

    26 #include <QFile>

    27 

    28 class TestXQKeyCapture : public QObject

    29 {

    30     Q_OBJECT

    31 

    32 public:

    33     TestXQKeyCapture(): QObject(), keyCapture(0) {};

    34 

    35 

    36 private slots:

    37     void initTestCase();

    38     void cleanupTestCase();

    39     void init();

    40     void cleanup();

    41     

    42     void testCreateAndDestroy();

    43 

    44     void testCaptureKey_data();

    45     void testCaptureKey();

    46 

    47     void testCaptureKeyList_data();

    48     void testCaptureKeyList();

    49 

    50 	void testCaptureKey_S60_data();

    51 	void testCaptureKey_S60();

    52 

    53     void testCaptureKeyList_S60_data();

    54 	void testCaptureKeyList_S60();

    55 

    56     void testCaptureKeyUpAndDowns_data();

    57     void testCaptureKeyUpAndDowns();

    58 

    59     void testCaptureKeyUpAndDownsList_data();

    60     void testCaptureKeyUpAndDownsList();

    61 

    62     void testCaptureKeyUpAndDowns_S60_data();

    63     void testCaptureKeyUpAndDowns_S60();

    64 

    65     void testCaptureKeyUpAndDownsList_S60_data();

    66     void testCaptureKeyUpAndDownsList_S60();

    67 

    68     void testCaptureLongKey_data();

    69     void testCaptureLongKey();

    70 

    71     void testCaptureLongKeyList_data();

    72     void testCaptureLongKeyList();

    73 

    74     void testCaptureLongKey_S60_data();

    75     void testCaptureLongKey_S60();

    76 

    77     void testCaptureLongKeyList_S60_data();

    78     void testCaptureLongKeyList_S60();

    79 

    80     void testCancelCaptureKey_data();

    81     void testCancelCaptureKey();

    82 

    83     void testCancelCaptureKeyList_data();

    84     void testCancelCaptureKeyList();

    85 

    86     void testCancelCaptureKey_S60_data();

    87     void testCancelCaptureKey_S60();

    88 

    89     void testCancelCaptureKeyList_S60_data();

    90     void testCancelCaptureKeyList_S60();

    91 

    92     void testCancelCaptureKeyUpAndDowns_data();

    93     void testCancelCaptureKeyUpAndDowns();

    94 

    95     void testCancelCaptureKeyUpAndDownsList_data();

    96     void testCancelCaptureKeyUpAndDownsList();

    97 

    98     void testCancelCaptureKeyUpAndDowns_S60_data();

    99     void testCancelCaptureKeyUpAndDowns_S60();

   100 

   101     void testCancelCaptureKeyUpAndDownsList_S60_data();

   102     void testCancelCaptureKeyUpAndDownsList_S60();

   103 

   104     void testCancelCaptureLongKey_data();

   105     void testCancelCaptureLongKey();

   106 

   107     void testCancelCaptureLongKeyList_data();

   108     void testCancelCaptureLongKeyList();

   109 

   110     void testCancelCaptureLongKey_S60_data();

   111     void testCancelCaptureLongKey_S60();

   112 

   113     void testCancelCaptureLongKeyList_S60_data();

   114     void testCancelCaptureLongKeyList_S60();

   115 

   116     void testErrorString();

   117     void testErrorId();

   118 	

   119 	void testKeyMapperFile();

   120 

   121 private:

   122 	QString clearString(const QString& line);

   123 	QString clearString(const QString& line, const QString& prefix, const QString& comment);

   124     

   125 private:

   126     XQKeyCapture* keyCapture;

   127 

   128     Qt::Key aKey;

   129     Qt::KeyboardModifiers aModifiersMap;

   130     Qt::KeyboardModifiers aModifier;

   131     

   132     int numOfArgs;

   133     WindowGroupActionType actionType;

   134     QList<unsigned int> results;

   135     QList<unsigned int> additionalResults;

   136     

   137     QList<long int> cancelResults;

   138     QList<long int> cancelAdditionalResults;

   139     

   140     long int additionalRequestHandle;

   141     

   142     bool willBeAdditionalRequest;

   143     bool additionalResult;

   144     bool ignoreWindowGroupAction;

   145     

   146     

   147 public slots:

   148     void windowGroupAction( WindowGroupActionType, QList<unsigned int> );

   149     void windowGroupActionCancel( WindowGroupActionType, QList<long int> );

   150     

   151 };

   152 

   153 // ======== MEMBER FUNCTIONS ========

   154 void TestXQKeyCapture::initTestCase()

   155 {

   156     bool ret = connect( MyTestWindowGroup::Instance(), SIGNAL( windowGroupAction( WindowGroupActionType, QList<unsigned int> )),

   157             this, SLOT( windowGroupAction( WindowGroupActionType, QList<unsigned int> ) ) );

   158     QVERIFY( ret );

   159     ret = connect( MyTestWindowGroup::Instance(), SIGNAL( windowGroupActionCancel( WindowGroupActionType, QList<long int> )),

   160             this, SLOT( windowGroupActionCancel( WindowGroupActionType, QList<long int> ) ) );

   161     QVERIFY( ret );

   162     

   163 }

   164 

   165 void TestXQKeyCapture::cleanupTestCase()

   166 {

   167     //delete MyTestWindowGroup::Instance();

   168 }

   169 

   170 void TestXQKeyCapture::init()

   171 {

   172     keyCapture = new XQKeyCapture();

   173 }

   174 

   175 void TestXQKeyCapture::cleanup()

   176 {

   177     delete keyCapture;

   178 }

   179 

   180 void TestXQKeyCapture::testCreateAndDestroy()

   181 {

   182     //empty, all done in init and cleanup

   183 }

   184 

   185 ////////////////////////////////////////////////////////////////

   186 // CAPTURE

   187 //Capture Key

   188 ////////////////////////////////////////////////////////////////

   189 void TestXQKeyCapture::testCaptureKey_data()

   190 {

   191     QTest::addColumn<unsigned int>("qtKey");

   192     QTest::addColumn<unsigned int>("qtMask");

   193     QTest::addColumn<unsigned int>("qtModifier");

   194 

   195     QTest::addColumn<unsigned int>("symbianKey");

   196     QTest::addColumn<unsigned int>("symbianMask");

   197     QTest::addColumn<unsigned int>("symbianModifier");

   198         

   199     QTest::addColumn<long int>("reqNum");

   200     

   201     QTest::addColumn<bool>("additional");

   202     QTest::addColumn<unsigned int>("additionalSymbianKey");

   203     

   204     QTest::newRow("esc_key") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   205                             << static_cast<unsigned int> ( Qt::NoModifier )

   206                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   207                             << static_cast<unsigned int> ( EKeyEscape )

   208                             << static_cast<unsigned int> ( 0 )

   209                             << static_cast<unsigned int> ( 0 )

   210                             << static_cast<long int> ( 12 )

   211                             << false

   212                             << static_cast<unsigned int> ( 0 );

   213 

   214     QTest::newRow("esc_key_not_supported") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   215                             << static_cast<unsigned int> ( Qt::NoModifier )

   216                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   217                             << static_cast<unsigned int> ( EKeyEscape )

   218                             << static_cast<unsigned int> ( 0 )

   219                             << static_cast<unsigned int> ( 0 )

   220                             << static_cast<long int> ( KErrNotSupported )

   221                             << false

   222                             << static_cast<unsigned int> ( 0 );

   223     

   224     QTest::newRow("esc_key_modifiers") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   225                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier )

   226                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier ) 

   227                             << static_cast<unsigned int> ( EKeyEscape )

   228                             << static_cast<unsigned int> ( EModifierShift | EModifierCtrl | EModifierAlt | EModifierKeypad )

   229                             << static_cast<unsigned int> ( EModifierShift | EModifierCtrl | EModifierAlt | EModifierKeypad )

   230                             << static_cast<long int> ( 13 )

   231                             << false

   232                             << static_cast<unsigned int> ( 0 );

   233     

   234     QTest::newRow("shift_key") << static_cast<unsigned int> ( Qt::Key_Shift ) 

   235                             << static_cast<unsigned int> ( Qt::ShiftModifier )

   236                             << static_cast<unsigned int> ( Qt::ShiftModifier ) 

   237                             << static_cast<unsigned int> ( EKeyLeftShift )

   238                             << static_cast<unsigned int> ( EModifierShift )

   239                             << static_cast<unsigned int> ( EModifierShift )

   240                             << static_cast<long int> ( 12 )

   241                             << true

   242                             << static_cast<unsigned int> ( EKeyRightShift );

   243 

   244     QTest::newRow("control_key") << static_cast<unsigned int> ( Qt::Key_Control ) 

   245                             << static_cast<unsigned int> ( Qt::NoModifier )

   246                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   247                             << static_cast<unsigned int> ( EKeyLeftCtrl )

   248                             << static_cast<unsigned int> ( 0 )

   249                             << static_cast<unsigned int> ( 0 )

   250                             << static_cast<long int> ( 12 )

   251                             << true

   252                             << static_cast<unsigned int> ( EKeyRightCtrl );

   253                             

   254     QTest::newRow("meta_key") << static_cast<unsigned int> ( Qt::Key_Super_R ) 

   255                             << static_cast<unsigned int> ( Qt::NoModifier )

   256                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   257                             << static_cast<unsigned int> ( EKeyRightFunc )

   258                             << static_cast<unsigned int> ( 0 )

   259                             << static_cast<unsigned int> ( 0 )

   260                             << static_cast<long int> ( 12 )

   261                             << true

   262                             << static_cast<unsigned int> ( EKeyRightFunc );

   263 

   264 

   265 }

   266 

   267 void TestXQKeyCapture::testCaptureKey()

   268 {

   269     numOfArgs = 3;

   270     actionType = WGATCaptureKey;

   271     additionalResult = false;

   272     ignoreWindowGroupAction = false;

   273     

   274     QFETCH(unsigned int, qtKey);

   275     QFETCH(unsigned int, qtMask);

   276     QFETCH(unsigned int, qtModifier);

   277 

   278     QFETCH(unsigned int, symbianKey);

   279     QFETCH(unsigned int, symbianMask);

   280     QFETCH(unsigned int, symbianModifier);

   281 

   282     QFETCH(long int, reqNum);

   283     

   284     QFETCH(bool, additional);

   285     QFETCH(unsigned int, additionalSymbianKey);

   286     

   287     willBeAdditionalRequest = additional;

   288     

   289     results.clear();

   290     results << symbianKey << symbianMask << symbianModifier;

   291     

   292     additionalResults.clear();

   293     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   294     

   295     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   296 

   297     keyCapture->captureKey( static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   298 

   299 //    keyCapture->captureKey( QList<Qt::Key>() << static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   300 }

   301 

   302 void TestXQKeyCapture::testCaptureKeyList_data() 

   303 {

   304     testCaptureKey_data();

   305 }

   306 

   307 void TestXQKeyCapture::testCaptureKeyList()

   308 {

   309     numOfArgs = 3;

   310     actionType = WGATCaptureKey;

   311     additionalResult = false;

   312     ignoreWindowGroupAction = false;

   313     

   314     QFETCH(unsigned int, qtKey);

   315     QFETCH(unsigned int, qtMask);

   316     QFETCH(unsigned int, qtModifier);

   317 

   318     QFETCH(unsigned int, symbianKey);

   319     QFETCH(unsigned int, symbianMask);

   320     QFETCH(unsigned int, symbianModifier);

   321 

   322     QFETCH(long int, reqNum);

   323     

   324     QFETCH(bool, additional);

   325     QFETCH(unsigned int, additionalSymbianKey);

   326     

   327     willBeAdditionalRequest = additional;

   328     

   329     results.clear();

   330     results << symbianKey << symbianMask << symbianModifier;

   331     

   332     additionalResults.clear();

   333     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   334     

   335     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   336 

   337     keyCapture->captureKey( QList<Qt::Key>() << static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   338 }

   339 

   340 ////////////////////////////////////////////////////////////////

   341 //Capture Key Up And Downs

   342 ////////////////////////////////////////////////////////////////

   343 

   344 void TestXQKeyCapture::testCaptureKey_S60_data()

   345 {

   346     QTest::addColumn<unsigned int>("s60Key");

   347     QTest::addColumn<unsigned int>("qtMask");

   348     QTest::addColumn<unsigned int>("qtModifier");

   349 

   350     QTest::addColumn<unsigned int>("symbianKey");

   351     QTest::addColumn<unsigned int>("symbianMask");

   352     QTest::addColumn<unsigned int>("symbianModifier");

   353         

   354     QTest::addColumn<long int>("reqNum");

   355     

   356     QTest::addColumn<bool>("additional");

   357     QTest::addColumn<unsigned int>("additionalSymbianKey");

   358     

   359     QTest::newRow("esc_key") << static_cast<unsigned int> ( EKeyEscape ) 

   360                             << static_cast<unsigned int> ( Qt::NoModifier )

   361                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   362                             << static_cast<unsigned int> ( EKeyEscape )

   363                             << static_cast<unsigned int> ( 0 )

   364                             << static_cast<unsigned int> ( 0 )

   365                             << static_cast<long int> ( 12 )

   366                             << false

   367                             << static_cast<unsigned int> ( 0 );

   368 

   369     QTest::newRow("esc_key_not_supported") << static_cast<unsigned int> ( EKeyEscape ) 

   370                             << static_cast<unsigned int> ( Qt::NoModifier )

   371                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   372                             << static_cast<unsigned int> ( EKeyEscape )

   373                             << static_cast<unsigned int> ( 0 )

   374                             << static_cast<unsigned int> ( 0 )

   375                             << static_cast<long int> ( KErrNotSupported )

   376                             << false

   377                             << static_cast<unsigned int> ( 0 );

   378     

   379     QTest::newRow("esc_key_modifiers") << static_cast<unsigned int> ( EKeyEscape ) 

   380                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier )

   381                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier ) 

   382                             << static_cast<unsigned int> ( EKeyEscape )

   383                             << static_cast<unsigned int> ( EModifierShift | EModifierCtrl | EModifierAlt | EModifierKeypad )

   384                             << static_cast<unsigned int> ( EModifierShift | EModifierCtrl | EModifierAlt | EModifierKeypad )

   385                             << static_cast<long int> ( 13 )

   386                             << false

   387                             << static_cast<unsigned int> ( 0 );

   388     

   389     QTest::newRow("shift_key") << static_cast<unsigned int> ( EKeyLeftShift ) 

   390                             << static_cast<unsigned int> ( Qt::ShiftModifier )

   391                             << static_cast<unsigned int> ( Qt::ShiftModifier ) 

   392                             << static_cast<unsigned int> ( EKeyLeftShift )

   393                             << static_cast<unsigned int> ( EModifierShift )

   394                             << static_cast<unsigned int> ( EModifierShift )

   395                             << static_cast<long int> ( 12 )

   396                             << true

   397                             << static_cast<unsigned int> ( EKeyRightShift );

   398 

   399     QTest::newRow("control_key") << static_cast<unsigned int> ( EKeyRightCtrl ) 

   400                             << static_cast<unsigned int> ( Qt::NoModifier )

   401                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   402                             << static_cast<unsigned int> ( EKeyRightCtrl )

   403                             << static_cast<unsigned int> ( 0 )

   404                             << static_cast<unsigned int> ( 0 )

   405                             << static_cast<long int> ( 12 )

   406                             << true

   407                             << static_cast<unsigned int> ( EKeyRightFunc );

   408                             

   409     QTest::newRow("meta_key") << static_cast<unsigned int> ( EKeyLeftCtrl ) 

   410                             << static_cast<unsigned int> ( Qt::NoModifier )

   411                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   412                             << static_cast<unsigned int> ( EKeyLeftCtrl )

   413                             << static_cast<unsigned int> ( 0 )

   414                             << static_cast<unsigned int> ( 0 )

   415                             << static_cast<long int> ( 12 )

   416                             << true

   417                             << static_cast<unsigned int> ( EKeyLeftFunc );

   418 

   419 

   420 }

   421 

   422 void TestXQKeyCapture::testCaptureKey_S60()

   423 {

   424     numOfArgs = 3;

   425     actionType = WGATCaptureKey;

   426     additionalResult = false;

   427     ignoreWindowGroupAction = false;

   428     

   429     QFETCH(unsigned int, s60Key);

   430     QFETCH(unsigned int, qtMask);

   431     QFETCH(unsigned int, qtModifier);

   432 

   433     QFETCH(unsigned int, symbianKey);

   434     QFETCH(unsigned int, symbianMask);

   435     QFETCH(unsigned int, symbianModifier);

   436 

   437     QFETCH(long int, reqNum);

   438     

   439     QFETCH(bool, additional);

   440     QFETCH(unsigned int, additionalSymbianKey);

   441     

   442     willBeAdditionalRequest = additional;

   443     

   444     results.clear();

   445     results << symbianKey << symbianMask << symbianModifier;

   446     

   447     additionalResults.clear();

   448     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   449     

   450     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   451     keyCapture->captureKey( static_cast<TUint> (s60Key), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   452 }

   453 

   454 void TestXQKeyCapture::testCaptureKeyList_S60_data()

   455 {

   456     testCaptureKey_S60_data();

   457 }

   458 

   459 void TestXQKeyCapture::testCaptureKeyList_S60()

   460 {

   461     numOfArgs = 3;

   462     actionType = WGATCaptureKey;

   463     additionalResult = false;

   464     ignoreWindowGroupAction = false;

   465     

   466     QFETCH(unsigned int, s60Key);

   467     QFETCH(unsigned int, qtMask);

   468     QFETCH(unsigned int, qtModifier);

   469 

   470     QFETCH(unsigned int, symbianKey);

   471     QFETCH(unsigned int, symbianMask);

   472     QFETCH(unsigned int, symbianModifier);

   473 

   474     QFETCH(long int, reqNum);

   475     

   476     QFETCH(bool, additional);

   477     QFETCH(unsigned int, additionalSymbianKey);

   478     

   479     willBeAdditionalRequest = additional;

   480     

   481     results.clear();

   482     results << symbianKey << symbianMask << symbianModifier;

   483     

   484     additionalResults.clear();

   485     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   486     

   487     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   488     keyCapture->captureKey(QList<TUint>() << static_cast<TUint> (s60Key), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   489 }

   490 

   491 ////////////////////////////////////////////////////////////////

   492 //Capture Key Up And Downs

   493 ////////////////////////////////////////////////////////////////

   494 void TestXQKeyCapture::testCaptureKeyUpAndDowns_data()

   495 {

   496     QTest::addColumn<unsigned int>("qtKey");

   497     QTest::addColumn<unsigned int>("qtMask");

   498     QTest::addColumn<unsigned int>("qtModifier");

   499 

   500     QTest::addColumn<unsigned int>("symbianKey");

   501     QTest::addColumn<unsigned int>("symbianMask");

   502     QTest::addColumn<unsigned int>("symbianModifier");

   503         

   504     QTest::addColumn<long int>("reqNum");

   505     

   506     QTest::addColumn<bool>("additional");

   507     QTest::addColumn<unsigned int>("additionalSymbianKey");

   508     

   509     QTest::newRow("esc_key") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   510                             << static_cast<unsigned int> ( Qt::NoModifier )

   511                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   512                             << static_cast<unsigned int> ( EStdKeyEscape )

   513                             << static_cast<unsigned int> ( 0 )

   514                             << static_cast<unsigned int> ( 0 )

   515                             << static_cast<long int> ( 12 )

   516                             << false

   517                             << static_cast<unsigned int> ( 0 );

   518 }

   519 

   520 void TestXQKeyCapture::testCaptureKeyUpAndDowns()

   521 {

   522     numOfArgs = 3;

   523     actionType = WGATCaptureKeyUpAndDowns;

   524     additionalResult = false;

   525     ignoreWindowGroupAction = false;

   526     

   527     QFETCH(unsigned int, qtKey);

   528     QFETCH(unsigned int, qtMask);

   529     QFETCH(unsigned int, qtModifier);

   530 

   531     QFETCH(unsigned int, symbianKey);

   532     QFETCH(unsigned int, symbianMask);

   533     QFETCH(unsigned int, symbianModifier);

   534 

   535     QFETCH(long int, reqNum);

   536     

   537     QFETCH(bool, additional);

   538     QFETCH(unsigned int, additionalSymbianKey);

   539     

   540     willBeAdditionalRequest = additional;

   541     

   542     results.clear();

   543     results << symbianKey << symbianMask << symbianModifier;

   544     

   545     additionalResults.clear();

   546     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   547     

   548     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   549     keyCapture->captureKeyUpAndDowns( static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   550 }

   551 

   552 void TestXQKeyCapture::testCaptureKeyUpAndDownsList_data()

   553 {

   554     testCaptureKeyUpAndDowns_data();

   555 }

   556 

   557 void TestXQKeyCapture::testCaptureKeyUpAndDownsList()

   558 {

   559     numOfArgs = 3;

   560     actionType = WGATCaptureKeyUpAndDowns;

   561     additionalResult = false;

   562     ignoreWindowGroupAction = false;

   563     

   564     QFETCH(unsigned int, qtKey);

   565     QFETCH(unsigned int, qtMask);

   566     QFETCH(unsigned int, qtModifier);

   567 

   568     QFETCH(unsigned int, symbianKey);

   569     QFETCH(unsigned int, symbianMask);

   570     QFETCH(unsigned int, symbianModifier);

   571 

   572     QFETCH(long int, reqNum);

   573     

   574     QFETCH(bool, additional);

   575     QFETCH(unsigned int, additionalSymbianKey);

   576     

   577     willBeAdditionalRequest = additional;

   578     

   579     results.clear();

   580     results << symbianKey << symbianMask << symbianModifier;

   581     

   582     additionalResults.clear();

   583     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   584     

   585     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   586     keyCapture->captureKeyUpAndDowns( QList<Qt::Key>() << static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   587 }

   588 

   589 ////////////////////////////////////////////////////////////////

   590 //Capture Key Up And Downs

   591 ////////////////////////////////////////////////////////////////

   592 void TestXQKeyCapture::testCaptureKeyUpAndDowns_S60_data()

   593 {

   594     QTest::addColumn<unsigned int>("qtKey");

   595     QTest::addColumn<unsigned int>("qtMask");

   596     QTest::addColumn<unsigned int>("qtModifier");

   597 

   598     QTest::addColumn<unsigned int>("symbianKey");

   599     QTest::addColumn<unsigned int>("symbianMask");

   600     QTest::addColumn<unsigned int>("symbianModifier");

   601         

   602     QTest::addColumn<long int>("reqNum");

   603     

   604     QTest::addColumn<bool>("additional");

   605     QTest::addColumn<unsigned int>("additionalSymbianKey");

   606     

   607     QTest::newRow("esc_key") << static_cast<unsigned int> ( EStdKeyEscape ) 

   608                             << static_cast<unsigned int> ( Qt::NoModifier )

   609                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   610                             << static_cast<unsigned int> ( EStdKeyEscape )

   611                             << static_cast<unsigned int> ( 0 )

   612                             << static_cast<unsigned int> ( 0 )

   613                             << static_cast<long int> ( 12 )

   614                             << false

   615                             << static_cast<unsigned int> ( 0 );

   616 }

   617 

   618 void TestXQKeyCapture::testCaptureKeyUpAndDowns_S60()

   619 {

   620     numOfArgs = 3;

   621     actionType = WGATCaptureKeyUpAndDowns;

   622     additionalResult = false;

   623     ignoreWindowGroupAction = false;

   624     

   625     QFETCH(unsigned int, qtKey);

   626     QFETCH(unsigned int, qtMask);

   627     QFETCH(unsigned int, qtModifier);

   628 

   629     QFETCH(unsigned int, symbianKey);

   630     QFETCH(unsigned int, symbianMask);

   631     QFETCH(unsigned int, symbianModifier);

   632 

   633     QFETCH(long int, reqNum);

   634     

   635     QFETCH(bool, additional);

   636     QFETCH(unsigned int, additionalSymbianKey);

   637     

   638     willBeAdditionalRequest = additional;

   639     

   640     results.clear();

   641     results << symbianKey << symbianMask << symbianModifier;

   642     

   643     additionalResults.clear();

   644     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   645     

   646     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   647     keyCapture->captureKeyUpAndDowns( static_cast<TUint> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   648 }

   649 

   650 void TestXQKeyCapture::testCaptureKeyUpAndDownsList_S60_data()

   651 {

   652     testCaptureKeyUpAndDowns_S60_data();

   653 }

   654 

   655 void TestXQKeyCapture::testCaptureKeyUpAndDownsList_S60()

   656 {

   657     numOfArgs = 3;

   658     actionType = WGATCaptureKeyUpAndDowns;

   659     additionalResult = false;

   660     ignoreWindowGroupAction = false;

   661     

   662     QFETCH(unsigned int, qtKey);

   663     QFETCH(unsigned int, qtMask);

   664     QFETCH(unsigned int, qtModifier);

   665 

   666     QFETCH(unsigned int, symbianKey);

   667     QFETCH(unsigned int, symbianMask);

   668     QFETCH(unsigned int, symbianModifier);

   669 

   670     QFETCH(long int, reqNum);

   671     

   672     QFETCH(bool, additional);

   673     QFETCH(unsigned int, additionalSymbianKey);

   674     

   675     willBeAdditionalRequest = additional;

   676     

   677     results.clear();

   678     results << symbianKey << symbianMask << symbianModifier;

   679     

   680     additionalResults.clear();

   681     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   682     

   683     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   684     keyCapture->captureKeyUpAndDowns( QList<TUint>() << static_cast<TUint> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   685 }

   686 

   687 ////////////////////////////////////////////////////////////////

   688 //Capture Long Key

   689 ////////////////////////////////////////////////////////////////

   690 void TestXQKeyCapture::testCaptureLongKey_data()

   691 {

   692     QTest::addColumn<unsigned int>("qtKey");

   693     QTest::addColumn<unsigned int>("qtMask");

   694     QTest::addColumn<unsigned int>("qtModifier");

   695     QTest::addColumn<int>("longFlags");

   696     

   697     QTest::addColumn<unsigned int>("symbianKey");

   698     QTest::addColumn<unsigned int>("symbianMask");

   699     QTest::addColumn<unsigned int>("symbianModifier");

   700     QTest::addColumn<int>("symbianPriority");

   701     QTest::addColumn<int>("symbianLongFlags");

   702         

   703     QTest::addColumn<long int>("reqNum");

   704     

   705     QTest::addColumn<bool>("additional");

   706     QTest::addColumn<unsigned int>("additionalSymbianKey");

   707     

   708     

   709     QTest::newRow("esc_key") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   710                             << static_cast<unsigned int> ( Qt::NoModifier )

   711                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   712                             << static_cast<int> ( XQKeyCapture::LongNormal ) 

   713                             << static_cast<unsigned int> ( EKeyEscape )

   714                             << static_cast<unsigned int> ( 0 )

   715                             << static_cast<unsigned int> ( 0 )

   716                             << static_cast<int> ( 0 ) //priority

   717                             << static_cast<int> ( XQKeyCapture::LongNormal ) 

   718                             << static_cast<long int> ( 12 )

   719                             << false

   720                             << static_cast<unsigned int> ( 0 );

   721 

   722 }

   723 

   724 void TestXQKeyCapture::testCaptureLongKey()

   725 {

   726     numOfArgs = 6;

   727     actionType = WGATCaptureLongKey;

   728     additionalResult = false;

   729     ignoreWindowGroupAction = false;

   730     

   731     QFETCH(unsigned int, qtKey);

   732     QFETCH(unsigned int, qtMask);

   733     QFETCH(unsigned int, qtModifier);

   734     QFETCH(int, longFlags);

   735     

   736     QFETCH(unsigned int, symbianKey);

   737     QFETCH(unsigned int, symbianMask);

   738     QFETCH(unsigned int, symbianModifier);

   739     QFETCH(int, symbianPriority);

   740     QFETCH(int, symbianLongFlags);

   741     

   742     QFETCH(long int, reqNum);

   743     

   744     QFETCH(bool, additional);

   745     QFETCH(unsigned int, additionalSymbianKey);

   746     

   747     willBeAdditionalRequest = additional;

   748     

   749     results.clear();

   750     results << symbianKey << symbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   751     

   752     additionalResults.clear();

   753     additionalResults << additionalSymbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   754     

   755     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   756     keyCapture->captureLongKey( static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ), static_cast<XQKeyCapture::LongFlags> (longFlags) );

   757 }

   758 

   759 void TestXQKeyCapture::testCaptureLongKeyList_data()

   760 {

   761     testCaptureLongKey_data();

   762 }

   763 

   764 void TestXQKeyCapture::testCaptureLongKeyList()

   765 {

   766     numOfArgs = 6;

   767     actionType = WGATCaptureLongKey;

   768     additionalResult = false;

   769     ignoreWindowGroupAction = false;

   770     

   771     QFETCH(unsigned int, qtKey);

   772     QFETCH(unsigned int, qtMask);

   773     QFETCH(unsigned int, qtModifier);

   774     QFETCH(int, longFlags);

   775     

   776     QFETCH(unsigned int, symbianKey);

   777     QFETCH(unsigned int, symbianMask);

   778     QFETCH(unsigned int, symbianModifier);

   779     QFETCH(int, symbianPriority);

   780     QFETCH(int, symbianLongFlags);

   781     

   782     QFETCH(long int, reqNum);

   783     

   784     QFETCH(bool, additional);

   785     QFETCH(unsigned int, additionalSymbianKey);

   786     

   787     willBeAdditionalRequest = additional;

   788     

   789     results.clear();

   790     results << symbianKey << symbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   791     

   792     additionalResults.clear();

   793     additionalResults << additionalSymbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   794     

   795     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   796     keyCapture->captureLongKey( QList<Qt::Key>() << static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ), static_cast<XQKeyCapture::LongFlags> (longFlags) );

   797 }

   798 

   799 ////////////////////////////////////////////////////////////////

   800 //Capture Long Key

   801 ////////////////////////////////////////////////////////////////

   802 void TestXQKeyCapture::testCaptureLongKey_S60_data()

   803 {

   804     QTest::addColumn<unsigned int>("qtKey");

   805     QTest::addColumn<unsigned int>("qtMask");

   806     QTest::addColumn<unsigned int>("qtModifier");

   807     QTest::addColumn<int>("longFlags");

   808     

   809     QTest::addColumn<unsigned int>("symbianKey");

   810     QTest::addColumn<unsigned int>("symbianMask");

   811     QTest::addColumn<unsigned int>("symbianModifier");

   812     QTest::addColumn<int>("symbianPriority");

   813     QTest::addColumn<int>("symbianLongFlags");

   814         

   815     QTest::addColumn<long int>("reqNum");

   816     

   817     QTest::addColumn<bool>("additional");

   818     QTest::addColumn<unsigned int>("additionalSymbianKey");

   819     

   820     

   821     QTest::newRow("esc_key") << static_cast<unsigned int> ( EKeyEscape ) 

   822                             << static_cast<unsigned int> ( Qt::NoModifier )

   823                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   824                             << static_cast<int> ( XQKeyCapture::LongNormal ) 

   825                             << static_cast<unsigned int> ( EKeyEscape )

   826                             << static_cast<unsigned int> ( 0 )

   827                             << static_cast<unsigned int> ( 0 )

   828                             << static_cast<int> ( 0 ) //priority

   829                             << static_cast<int> ( XQKeyCapture::LongNormal ) 

   830                             << static_cast<long int> ( 12 )

   831                             << false

   832                             << static_cast<unsigned int> ( 0 );

   833 

   834 }

   835 

   836 void TestXQKeyCapture::testCaptureLongKey_S60()

   837 {

   838     numOfArgs = 6;

   839     actionType = WGATCaptureLongKey;

   840     additionalResult = false;

   841     ignoreWindowGroupAction = false;

   842     

   843     QFETCH(unsigned int, qtKey);

   844     QFETCH(unsigned int, qtMask);

   845     QFETCH(unsigned int, qtModifier);

   846     QFETCH(int, longFlags);

   847     

   848     QFETCH(unsigned int, symbianKey);

   849     QFETCH(unsigned int, symbianMask);

   850     QFETCH(unsigned int, symbianModifier);

   851     QFETCH(int, symbianPriority);

   852     QFETCH(int, symbianLongFlags);

   853     

   854     QFETCH(long int, reqNum);

   855     

   856     QFETCH(bool, additional);

   857     QFETCH(unsigned int, additionalSymbianKey);

   858     

   859     willBeAdditionalRequest = additional;

   860     

   861     results.clear();

   862     results << symbianKey << symbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   863     

   864     additionalResults.clear();

   865     additionalResults << additionalSymbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   866     

   867     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   868     keyCapture->captureLongKey( static_cast<TUint> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ), static_cast<XQKeyCapture::LongFlags> (longFlags) );

   869 }

   870 

   871 void TestXQKeyCapture::testCaptureLongKeyList_S60_data()

   872 {

   873     testCaptureLongKey_S60_data();

   874 }

   875 

   876 void TestXQKeyCapture::testCaptureLongKeyList_S60()

   877 {

   878     numOfArgs = 6;

   879     actionType = WGATCaptureLongKey;

   880     additionalResult = false;

   881     ignoreWindowGroupAction = false;

   882     

   883     QFETCH(unsigned int, qtKey);

   884     QFETCH(unsigned int, qtMask);

   885     QFETCH(unsigned int, qtModifier);

   886     QFETCH(int, longFlags);

   887     

   888     QFETCH(unsigned int, symbianKey);

   889     QFETCH(unsigned int, symbianMask);

   890     QFETCH(unsigned int, symbianModifier);

   891     QFETCH(int, symbianPriority);

   892     QFETCH(int, symbianLongFlags);

   893     

   894     QFETCH(long int, reqNum);

   895     

   896     QFETCH(bool, additional);

   897     QFETCH(unsigned int, additionalSymbianKey);

   898     

   899     willBeAdditionalRequest = additional;

   900     

   901     results.clear();

   902     results << symbianKey << symbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   903     

   904     additionalResults.clear();

   905     additionalResults << additionalSymbianKey << symbianMask << symbianModifier << symbianPriority << symbianLongFlags;

   906     

   907     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   908     keyCapture->captureLongKey( QList<TUint>() << static_cast<TUint> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ), static_cast<XQKeyCapture::LongFlags> (longFlags) );

   909 }

   910 

   911 ////////////////////////////////////////////////////////////////

   912 // CANCEL

   913 //Cancel Capture Key

   914 ////////////////////////////////////////////////////////////////

   915 void TestXQKeyCapture::testCancelCaptureKey_data()

   916 {

   917     QTest::addColumn<unsigned int>("qtKey");

   918     QTest::addColumn<unsigned int>("qtMask");

   919     QTest::addColumn<unsigned int>("qtModifier");

   920 

   921     QTest::addColumn<long int>("reqNum");

   922     

   923     QTest::addColumn<bool>("additional");

   924     QTest::addColumn<long int>("additionalReqNum");

   925     

   926     QTest::newRow("esc_key") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   927                             << static_cast<unsigned int> ( Qt::NoModifier )

   928                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   929                             << static_cast<long int> ( 12 )

   930                             << false

   931                             << static_cast<long int> ( 0 );

   932 

   933     QTest::newRow("esc_key_not_supported") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   934                             << static_cast<unsigned int> ( Qt::NoModifier )

   935                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   936                             << static_cast<long int> ( KErrNotSupported )

   937                             << false

   938                             << static_cast<long int> ( 0 );

   939     

   940     QTest::newRow("esc_key_modifiers") << static_cast<unsigned int> ( Qt::Key_Escape ) 

   941                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier )

   942                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier ) 

   943                             << static_cast<long int> ( 13 )

   944                             << false

   945                             << static_cast<long int> ( 0 );

   946     

   947     QTest::newRow("shift_key") << static_cast<unsigned int> ( Qt::Key_Shift ) 

   948                             << static_cast<unsigned int> ( Qt::ShiftModifier )

   949                             << static_cast<unsigned int> ( Qt::ControlModifier ) 

   950                             << static_cast<long int> ( 15 )

   951                             << true

   952                             << static_cast<long int> ( 16 );

   953 

   954     QTest::newRow("control_key") << static_cast<unsigned int> ( Qt::Key_Control ) 

   955                             << static_cast<unsigned int> ( Qt::ControlModifier )

   956                             << static_cast<unsigned int> ( Qt::ShiftModifier ) 

   957                             << static_cast<long int> ( 17 )

   958                             << true

   959                             << static_cast<long int> ( 18 );

   960                             

   961     QTest::newRow("meta_key") << static_cast<unsigned int> ( Qt::Key_Meta ) 

   962                             << static_cast<unsigned int> ( Qt::NoModifier )

   963                             << static_cast<unsigned int> ( Qt::NoModifier ) 

   964                             << static_cast<long int> ( 19 )

   965                             << true

   966                             << static_cast<long int> ( 20 );

   967 

   968 

   969 }

   970 

   971 void TestXQKeyCapture::testCancelCaptureKey()

   972 {

   973     numOfArgs = 1;

   974     actionType = WGATCancelCaptureKey;

   975     additionalResult = false;

   976     

   977     QFETCH(unsigned int, qtKey);

   978     QFETCH(unsigned int, qtMask);

   979     QFETCH(unsigned int, qtModifier);

   980 

   981     QFETCH(long int, reqNum);

   982     

   983     QFETCH(bool, additional);

   984     QFETCH(long int, additionalReqNum);

   985     

   986     willBeAdditionalRequest = additional;

   987     additionalRequestHandle = additionalReqNum;

   988     

   989     cancelResults.clear();

   990     cancelResults << reqNum;

   991     

   992     cancelAdditionalResults.clear();

   993     cancelAdditionalResults << additionalReqNum;

   994     

   995     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

   996     ignoreWindowGroupAction = true;

   997     keyCapture->captureKey( static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

   998     ignoreWindowGroupAction = false;

   999     willBeAdditionalRequest = additional;

  1000     keyCapture->cancelCaptureKey( static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

  1001 }

  1002 

  1003 void TestXQKeyCapture::testCancelCaptureKeyList_data()

  1004 {

  1005     testCancelCaptureKey_data();

  1006 }

  1007 

  1008 void TestXQKeyCapture::testCancelCaptureKeyList()

  1009 {

  1010     numOfArgs = 1;

  1011     actionType = WGATCancelCaptureKey;

  1012     additionalResult = false;

  1013     

  1014     QFETCH(unsigned int, qtKey);

  1015     QFETCH(unsigned int, qtMask);

  1016     QFETCH(unsigned int, qtModifier);

  1017 

  1018     QFETCH(long int, reqNum);

  1019     

  1020     QFETCH(bool, additional);

  1021     QFETCH(long int, additionalReqNum);

  1022     

  1023     willBeAdditionalRequest = additional;

  1024     additionalRequestHandle = additionalReqNum;

  1025     

  1026     cancelResults.clear();

  1027     cancelResults << reqNum;

  1028     

  1029     cancelAdditionalResults.clear();

  1030     cancelAdditionalResults << additionalReqNum;

  1031     

  1032     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

  1033     ignoreWindowGroupAction = true;

  1034     keyCapture->captureKey( static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

  1035     ignoreWindowGroupAction = false;

  1036     willBeAdditionalRequest = additional;

  1037     keyCapture->cancelCaptureKey( QList<Qt::Key>() << static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

  1038 }

  1039 

  1040 ////////////////////////////////////////////////////////////////

  1041 // CANCEL

  1042 //Cancel Capture Key

  1043 ////////////////////////////////////////////////////////////////

  1044 void TestXQKeyCapture::testCancelCaptureKey_S60_data()

  1045 {

  1046     QTest::addColumn<unsigned int>("qtKey");

  1047     QTest::addColumn<unsigned int>("qtMask");

  1048     QTest::addColumn<unsigned int>("qtModifier");

  1049 

  1050     QTest::addColumn<long int>("reqNum");

  1051     

  1052     QTest::addColumn<bool>("additional");

  1053     QTest::addColumn<long int>("additionalReqNum");

  1054     

  1055     QTest::newRow("esc_key") << static_cast<unsigned int> ( EKeyEscape ) 

  1056                             << static_cast<unsigned int> ( Qt::NoModifier )

  1057                             << static_cast<unsigned int> ( Qt::NoModifier ) 

  1058                             << static_cast<long int> ( 12 )

  1059                             << false

  1060                             << static_cast<long int> ( 0 );

  1061 

  1062     QTest::newRow("esc_key_not_supported") << static_cast<unsigned int> ( EKeyEscape ) 

  1063                             << static_cast<unsigned int> ( Qt::NoModifier )

  1064                             << static_cast<unsigned int> ( Qt::NoModifier ) 

  1065                             << static_cast<long int> ( KErrNotSupported )

  1066                             << false

  1067                             << static_cast<long int> ( 0 );

  1068     

  1069     QTest::newRow("esc_key_modifiers") << static_cast<unsigned int> ( EKeyEscape ) 

  1070                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier )

  1071                             << static_cast<unsigned int> ( Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt:: KeypadModifier ) 

  1072                             << static_cast<long int> ( 13 )

  1073                             << false

  1074                             << static_cast<long int> ( 0 );

  1075     

  1076     QTest::newRow("shift_key") << static_cast<unsigned int> ( EKeyLeftShift ) 

  1077                             << static_cast<unsigned int> ( Qt::ShiftModifier )

  1078                             << static_cast<unsigned int> ( Qt::ControlModifier ) 

  1079                             << static_cast<long int> ( 15 )

  1080                             << true

  1081                             << static_cast<long int> ( 16 );

  1082 

  1083     QTest::newRow("control_key") << static_cast<unsigned int> ( EKeyLeftCtrl ) 

  1084                             << static_cast<unsigned int> ( Qt::ControlModifier )

  1085                             << static_cast<unsigned int> ( Qt::ShiftModifier ) 

  1086                             << static_cast<long int> ( 17 )

  1087                             << true

  1088                             << static_cast<long int> ( 18 );

  1089                             

  1090     QTest::newRow("meta_key") << static_cast<unsigned int> ( EKeyRightCtrl ) 

  1091                             << static_cast<unsigned int> ( Qt::NoModifier )

  1092                             << static_cast<unsigned int> ( Qt::NoModifier ) 

  1093                             << static_cast<long int> ( 19 )

  1094                             << true

  1095                             << static_cast<long int> ( 20 );

  1096 

  1097 

  1098 }

  1099 

  1100 void TestXQKeyCapture::testCancelCaptureKey_S60()

  1101 {

  1102     numOfArgs = 1;

  1103     actionType = WGATCancelCaptureKey;

  1104     additionalResult = false;

  1105     

  1106     QFETCH(unsigned int, qtKey);

  1107     QFETCH(unsigned int, qtMask);

  1108     QFETCH(unsigned int, qtModifier);

  1109 

  1110     QFETCH(long int, reqNum);

  1111     

  1112     QFETCH(bool, additional);

  1113     QFETCH(long int, additionalReqNum);

  1114     

  1115     willBeAdditionalRequest = additional;

  1116     additionalRequestHandle = additionalReqNum;

  1117     

  1118     cancelResults.clear();

  1119     cancelResults << reqNum;

  1120     

  1121     cancelAdditionalResults.clear();

  1122     cancelAdditionalResults << additionalReqNum;

  1123     

  1124     MyTestWindowGroup::Instance()->setRequestNumber(reqNum);

  1125     ignoreWindowGroupAction = true;

  1126     keyCapture->captureKey( static_cast<TUint> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

  1127     ignoreWindowGroupAction = false;

  1128     willBeAdditionalRequest = additional;

  1129     keyCapture->cancelCaptureKey( static_cast<TUint> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ) );

  1130 }

  1131 

  1132 void TestXQKeyCapture::testCancelCaptureKeyList_S60_data()

  1133 {

  1134     testCancelCaptureKey_S60_data();