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 class TestXqKeyCapture : public QObject

    27 {

    28     Q_OBJECT

    29 

    30 public:

    31     TestXqKeyCapture(): QObject(), keyCapture(0) {};

    32 

    33 

    34 private slots:

    35     void initTestCase();

    36     void cleanupTestCase();

    37     void init();

    38     void cleanup();

    39     

    40     void testCreateAndDestroy();

    41 

    42     void testCaptureKey_data();

    43     void testCaptureKey();

    44 

    45     void testCaptureKeyUpAndDowns_data();

    46     void testCaptureKeyUpAndDowns();

    47     

    48     void testCaptureLongKey_data();

    49     void testCaptureLongKey();

    50     

    51     void testCancelCaptureKey_data();

    52     void testCancelCaptureKey();

    53 

    54     void testCancelCaptureKeyUpAndDowns_data();

    55     void testCancelCaptureKeyUpAndDowns();

    56     

    57     void testCancelCaptureLongKey_data();

    58     void testCancelCaptureLongKey();

    59     

    60     void testErrorString();

    61     void testErrorId();

    62     

    63 private:

    64     XqKeyCapture* keyCapture;

    65 

    66     Qt::Key aKey;

    67     Qt::KeyboardModifiers aModifiersMap;

    68     Qt::KeyboardModifiers aModifier;

    69     

    70     int numOfArgs;

    71     WindowGroupActionType actionType;

    72     QList<unsigned int> results;

    73     QList<unsigned int> additionalResults;

    74     

    75     QList<long int> cancelResults;

    76     QList<long int> cancelAdditionalResults;

    77     

    78     long int additionalRequestHandle;

    79     

    80     bool willBeAdditionalRequest;

    81     bool additionalResult;

    82     bool ignoreWindowGroupAction;

    83     

    84     

    85 public slots:

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

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

    88     

    89 };

    90 

    91 // ======== MEMBER FUNCTIONS ========

    92 void TestXqKeyCapture::initTestCase()

    93 {

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

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

    96     QVERIFY( ret );

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

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

    99     QVERIFY( ret );

   100     

   101 }

   102 

   103 void TestXqKeyCapture::cleanupTestCase()

   104 {

   105     //delete MyTestWindowGroup::Instance();

   106 }

   107 

   108 void TestXqKeyCapture::init()

   109 {

   110     keyCapture = new XqKeyCapture();

   111 }

   112 

   113 void TestXqKeyCapture::cleanup()

   114 {

   115     delete keyCapture;

   116 }

   117 

   118 void TestXqKeyCapture::testCreateAndDestroy()

   119 {

   120     //empty, all done in init and cleanup

   121 }

   122 

   123 ////////////////////////////////////////////////////////////////

   124 // CAPTURE

   125 //Capture Key

   126 ////////////////////////////////////////////////////////////////

   127 void TestXqKeyCapture::testCaptureKey_data()

   128 {

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

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

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

   132 

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

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

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

   136         

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

   138     

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

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

   141     

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

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

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

   145                             << static_cast<unsigned int> ( EKeyEscape )

   146                             << static_cast<unsigned int> ( 0 )

   147                             << static_cast<unsigned int> ( 0 )

   148                             << static_cast<long int> ( 12 )

   149                             << false

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

   151 

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

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

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

   155                             << static_cast<unsigned int> ( EKeyEscape )

   156                             << static_cast<unsigned int> ( 0 )

   157                             << static_cast<unsigned int> ( 0 )

   158                             << static_cast<long int> ( KErrNotSupported )

   159                             << false

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

   161     

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

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

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

   165                             << static_cast<unsigned int> ( EKeyEscape )

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

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

   168                             << static_cast<long int> ( 13 )

   169                             << false

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

   171     

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

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

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

   175                             << static_cast<unsigned int> ( EKeyLeftShift )

   176                             << static_cast<unsigned int> ( EModifierShift )

   177                             << static_cast<unsigned int> ( EModifierShift )

   178                             << static_cast<long int> ( 12 )

   179                             << true

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

   181 

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

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

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

   185                             << static_cast<unsigned int> ( EKeyLeftCtrl )

   186                             << static_cast<unsigned int> ( 0 )

   187                             << static_cast<unsigned int> ( 0 )

   188                             << static_cast<long int> ( 12 )

   189                             << true

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

   191                             

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

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

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

   195                             << static_cast<unsigned int> ( EKeyLeftFunc )

   196                             << static_cast<unsigned int> ( 0 )

   197                             << static_cast<unsigned int> ( 0 )

   198                             << static_cast<long int> ( 12 )

   199                             << true

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

   201 

   202 

   203 }

   204 

   205 void TestXqKeyCapture::testCaptureKey()

   206 {

   207     numOfArgs = 3;

   208     actionType = WGATCaptureKey;

   209     additionalResult = false;

   210     ignoreWindowGroupAction = false;

   211     

   212     QFETCH(unsigned int, qtKey);

   213     QFETCH(unsigned int, qtMask);

   214     QFETCH(unsigned int, qtModifier);

   215 

   216     QFETCH(unsigned int, symbianKey);

   217     QFETCH(unsigned int, symbianMask);

   218     QFETCH(unsigned int, symbianModifier);

   219 

   220     QFETCH(long int, reqNum);

   221     

   222     QFETCH(bool, additional);

   223     QFETCH(unsigned int, additionalSymbianKey);

   224     

   225     willBeAdditionalRequest = additional;

   226     

   227     results.clear();

   228     results << symbianKey << symbianMask << symbianModifier;

   229     

   230     additionalResults.clear();

   231     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   232     

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

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

   235 }

   236 

   237 ////////////////////////////////////////////////////////////////

   238 //Capture Key Up And Downs

   239 ////////////////////////////////////////////////////////////////

   240 void TestXqKeyCapture::testCaptureKeyUpAndDowns_data()

   241 {

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

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

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

   245 

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

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

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

   249         

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

   251     

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

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

   254     

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

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

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

   258                             << static_cast<unsigned int> ( EStdKeyEscape )

   259                             << static_cast<unsigned int> ( 0 )

   260                             << static_cast<unsigned int> ( 0 )

   261                             << static_cast<long int> ( 12 )

   262                             << false

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

   264 }

   265 

   266 void TestXqKeyCapture::testCaptureKeyUpAndDowns()

   267 {

   268     numOfArgs = 3;

   269     actionType = WGATCaptureKeyUpAndDowns;

   270     additionalResult = false;

   271     ignoreWindowGroupAction = false;

   272     

   273     QFETCH(unsigned int, qtKey);

   274     QFETCH(unsigned int, qtMask);

   275     QFETCH(unsigned int, qtModifier);

   276 

   277     QFETCH(unsigned int, symbianKey);

   278     QFETCH(unsigned int, symbianMask);

   279     QFETCH(unsigned int, symbianModifier);

   280 

   281     QFETCH(long int, reqNum);

   282     

   283     QFETCH(bool, additional);

   284     QFETCH(unsigned int, additionalSymbianKey);

   285     

   286     willBeAdditionalRequest = additional;

   287     

   288     results.clear();

   289     results << symbianKey << symbianMask << symbianModifier;

   290     

   291     additionalResults.clear();

   292     additionalResults << additionalSymbianKey << symbianMask << symbianModifier;

   293     

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

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

   296 }

   297 

   298 ////////////////////////////////////////////////////////////////

   299 //Capture Long Key

   300 ////////////////////////////////////////////////////////////////

   301 void TestXqKeyCapture::testCaptureLongKey_data()

   302 {

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

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

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

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

   307     

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

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

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

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

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

   313         

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

   315     

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

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

   318     

   319     

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

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

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

   323                             << static_cast<int> ( XqKeyCapture::LongNormal ) 

   324                             << static_cast<unsigned int> ( EKeyEscape )

   325                             << static_cast<unsigned int> ( 0 )

   326                             << static_cast<unsigned int> ( 0 )

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

   328                             << static_cast<int> ( XqKeyCapture::LongNormal ) 

   329                             << static_cast<long int> ( 12 )

   330                             << false

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

   332 

   333 }

   334 

   335 void TestXqKeyCapture::testCaptureLongKey()

   336 {

   337     numOfArgs = 6;

   338     actionType = WGATCaptureLongKey;

   339     additionalResult = false;

   340     ignoreWindowGroupAction = false;

   341     

   342     QFETCH(unsigned int, qtKey);

   343     QFETCH(unsigned int, qtMask);

   344     QFETCH(unsigned int, qtModifier);

   345     QFETCH(int, longFlags);

   346     

   347     QFETCH(unsigned int, symbianKey);

   348     QFETCH(unsigned int, symbianMask);

   349     QFETCH(unsigned int, symbianModifier);

   350     QFETCH(int, symbianPriority);

   351     QFETCH(int, symbianLongFlags);

   352     

   353     QFETCH(long int, reqNum);

   354     

   355     QFETCH(bool, additional);

   356     QFETCH(unsigned int, additionalSymbianKey);

   357     

   358     willBeAdditionalRequest = additional;

   359     

   360     results.clear();

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

   362     

   363     additionalResults.clear();

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

   365     

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

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

   368 }

   369 

   370 ////////////////////////////////////////////////////////////////

   371 // CANCEL

   372 //Cancel Capture Key

   373 ////////////////////////////////////////////////////////////////

   374 void TestXqKeyCapture::testCancelCaptureKey_data()

   375 {

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

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

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

   379 

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

   381     

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

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

   384     

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

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

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

   388                             << static_cast<long int> ( 12 )

   389                             << false

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

   391 

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

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

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

   395                             << static_cast<long int> ( KErrNotSupported )

   396                             << false

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

   398     

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

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

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

   402                             << static_cast<long int> ( 13 )

   403                             << false

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

   405     

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

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

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

   409                             << static_cast<long int> ( 15 )

   410                             << true

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

   412 

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

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

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

   416                             << static_cast<long int> ( 17 )

   417                             << true

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

   419                             

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

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

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

   423                             << static_cast<long int> ( 19 )

   424                             << true

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

   426 

   427 

   428 }

   429 

   430 void TestXqKeyCapture::testCancelCaptureKey()

   431 {

   432     numOfArgs = 1;

   433     actionType = WGATCancelCaptureKey;

   434     additionalResult = false;

   435     

   436     QFETCH(unsigned int, qtKey);

   437     QFETCH(unsigned int, qtMask);

   438     QFETCH(unsigned int, qtModifier);

   439 

   440     QFETCH(long int, reqNum);

   441     

   442     QFETCH(bool, additional);

   443     QFETCH(long int, additionalReqNum);

   444     

   445     willBeAdditionalRequest = additional;

   446     additionalRequestHandle = additionalReqNum;

   447     

   448     cancelResults.clear();

   449     cancelResults << reqNum;

   450     

   451     cancelAdditionalResults.clear();

   452     cancelAdditionalResults << additionalReqNum;

   453     

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

   455     ignoreWindowGroupAction = true;

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

   457     ignoreWindowGroupAction = false;

   458     willBeAdditionalRequest = additional;

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

   460 }

   461 

   462 ////////////////////////////////////////////////////////////////

   463 //Cancel Capture Key Up And Downs

   464 ////////////////////////////////////////////////////////////////

   465 void TestXqKeyCapture::testCancelCaptureKeyUpAndDowns_data()

   466 {

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

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

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

   470 

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

   472     

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

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

   475     

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

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

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

   479                             << static_cast<long int> ( 34 )

   480                             << false

   481                             << static_cast<long int> ( 35 );

   482 

   483 }

   484 

   485 void TestXqKeyCapture::testCancelCaptureKeyUpAndDowns()

   486 {

   487     numOfArgs = 1;

   488     actionType = WGATCancelCaptureKeyUpAndDowns;

   489     additionalResult = false;

   490     

   491     QFETCH(unsigned int, qtKey);

   492     QFETCH(unsigned int, qtMask);

   493     QFETCH(unsigned int, qtModifier);

   494 

   495     QFETCH(long int, reqNum);

   496     

   497     QFETCH(bool, additional);

   498     QFETCH(long int, additionalReqNum);

   499     

   500     willBeAdditionalRequest = additional;

   501     additionalRequestHandle = additionalReqNum;

   502     

   503     cancelResults.clear();

   504     cancelResults << reqNum;

   505     

   506     cancelAdditionalResults.clear();

   507     cancelAdditionalResults << additionalReqNum;

   508     

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

   510     ignoreWindowGroupAction = true;

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

   512     ignoreWindowGroupAction = false;

   513     willBeAdditionalRequest = additional;

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

   515 }

   516 

   517 ////////////////////////////////////////////////////////////////

   518 //Cancel Capture Long Key

   519 ////////////////////////////////////////////////////////////////

   520 void TestXqKeyCapture::testCancelCaptureLongKey_data()

   521 {

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

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

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

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

   526     

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

   528     

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

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

   531     

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

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

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

   535                             << static_cast<int> ( XqKeyCapture::LongNormal ) 

   536                             << static_cast<long int> ( 22 )

   537                             << false

   538                             << static_cast<long int> ( 23 );

   539 

   540 

   541 

   542 

   543 

   544 }

   545 

   546 void TestXqKeyCapture::testCancelCaptureLongKey()

   547 {

   548     numOfArgs = 1;

   549     actionType = WGATCancelCaptureLongKey;

   550     additionalResult = false;

   551     

   552     QFETCH(unsigned int, qtKey);

   553     QFETCH(unsigned int, qtMask);

   554     QFETCH(unsigned int, qtModifier);

   555     QFETCH(int, longFlags);

   556 

   557     QFETCH(long int, reqNum);

   558     

   559     QFETCH(bool, additional);

   560     QFETCH(long int, additionalReqNum);

   561     

   562     willBeAdditionalRequest = additional;

   563     additionalRequestHandle = additionalReqNum;

   564     

   565     cancelResults.clear();

   566     cancelResults << reqNum;

   567     

   568     cancelAdditionalResults.clear();

   569     cancelAdditionalResults << additionalReqNum;

   570     

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

   572     ignoreWindowGroupAction = true;

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

   574     ignoreWindowGroupAction = false;

   575     willBeAdditionalRequest = additional;

   576     keyCapture->cancelCaptureLongKey( static_cast<Qt::Key> (qtKey), Qt::KeyboardModifier( qtMask ), Qt::KeyboardModifier( qtModifier ), static_cast<XqKeyCapture::LongFlags> (longFlags) );

   577 }

   578 

   579 ////////////////////////////////////////////////////////////////

   580 // ERRORS

   581 //errorString

   582 ////////////////////////////////////////////////////////////////

   583 void TestXqKeyCapture::testErrorString()

   584 {

   585     keyCapture->errorString();

   586 }

   587 

   588 ////////////////////////////////////////////////////////////////

   589 // ERRORS

   590 //errorId

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

   592 void TestXqKeyCapture::testErrorId()

   593 {

   594     keyCapture->errorId();

   595 }

   596 

   597 ////////////////////////////////////////////////////////////////

   598 // REQUEST SLOT

   599 //windowGroupAction

   600 ////////////////////////////////////////////////////////////////

   601 void TestXqKeyCapture::windowGroupAction( WindowGroupActionType wgat, QList<unsigned int> paramList )

   602 {

   603     if( !ignoreWindowGroupAction )

   604     {

   605         QVERIFY( wgat == actionType );

   606         QVERIFY( paramList.count() == numOfArgs );

   607         

   608         for( int i = 0; i < numOfArgs; i++)

   609             {

   610             if( additionalResult )

   611                 QVERIFY( paramList[i] == additionalResults[i] );

   612             else 

   613                 QVERIFY( paramList[i] == results[i] );

   614             }

   615     }

   616     if( willBeAdditionalRequest ){

   617         additionalResult = true;

   618         MyTestWindowGroup::Instance()->setRequestNumber(additionalRequestHandle);

   619         }

   620 }

   621 

   622 ////////////////////////////////////////////////////////////////

   623 //windowGroupActionCancel

   624 ////////////////////////////////////////////////////////////////

   625 void TestXqKeyCapture::windowGroupActionCancel( WindowGroupActionType wgat, QList<long int> paramList )

   626 {

   627     QVERIFY( wgat == actionType );

   628     QVERIFY( paramList.count() == numOfArgs );

   629     

   630     for( int i = 0; i < numOfArgs; i++)

   631         {

   632         if( additionalResult )

   633             QVERIFY( paramList[i] == cancelAdditionalResults[i] );

   634         else 

   635             QVERIFY( paramList[i] == cancelResults[i] );

   636         }

   637 

   638     if( willBeAdditionalRequest ){

   639         additionalResult = true;

   640         }

   641 }

   642 

   643 ////////////////////////////////////////////////////////////////

   644 // MAIN

   645 //main

   646 ////////////////////////////////////////////////////////////////

   647 

   648 #ifdef _XQKEYCAPTURE_UNITTEST_LOG_TO_C_

   649     main (int argc, char* argv[]) 

   650     {

   651         QApplication app(argc, argv);

   652         TestXqKeyCapture tc;

   653         int c = 3;

   654         char* v[] = {argv[0], "-o", "c:/test.txt"};

   655         return QTest::qExec(&tc, c, v);

   656     }

   657 #else

   658     QTEST_MAIN(TestXqKeyCapture)

   659 #endif

   660 

   661 #include "test_xqkeycapture.moc"