1 /*!

     2 * Copyright (c) 2010 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 <QtGui>

    19 #include <QtTest/QtTest>

    20 #include "ut_manufacturerkeysequencehandler.h"

    21 #define private friend class UT_ManufacturerKeySequenceHandler;private

    22 #include "manufacturerkeysequencehandler.h"

    23 #include "keysequencerecognitionservicedefs.h"

    24 #include "qtestmains60.h"

    25 

    26 const bool KIsEmbedded = false;

    27 

    28 void generateException()

    29 {

    30     qBadAlloc();

    31 }

    32 

    33 UT_ManufacturerKeySequenceHandler::UT_ManufacturerKeySequenceHandler()

    34     :

    35     m_handler(0)

    36 {

    37     

    38 }

    39 

    40 

    41 UT_ManufacturerKeySequenceHandler::~UT_ManufacturerKeySequenceHandler()

    42 {

    43     delete m_handler;

    44 }

    45 

    46 

    47 void UT_ManufacturerKeySequenceHandler::init()

    48 {

    49     initialize();

    50     

    51     m_handler = new ManufacturerKeySequenceHandler();

    52 }

    53 

    54 

    55 void UT_ManufacturerKeySequenceHandler::cleanup()

    56 {

    57     reset();

    58     

    59     delete m_handler;

    60     m_handler = 0;

    61 }

    62 

    63 

    64 void UT_ManufacturerKeySequenceHandler::t_keySequenceValidator()

    65 {

    66     QString expectedValidator =

    67         QRegExp::escape(KCodeSwVersion) + "|" +

    68         QRegExp::escape(KCodeActivateRfsNormal)  + "|" +

    69         QRegExp::escape(KCodeActivateRfsDeep) + "|" +

    70         QRegExp::escape(KCodeBtAddress) + "|" +

    71         QRegExp::escape(KCodeRFLoopback) + "|" +

    72         QRegExp::escape(KCodeBtDebugMode);

    73     

    74     expect("KeySequenceHandler::setKeySequenceValidator")

    75         .with(expectedValidator);

    76     

    77     QScopedPointer<ManufacturerKeySequenceHandler> handler(

    78         new ManufacturerKeySequenceHandler());

    79     

    80     QVERIFY(verify());

    81 }

    82 

    83 

    84 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceDeviceManagerCodes()

    85 {

    86     XQAiwInterfaceDescriptor dummyDescriptor;

    87     QPointer<XQAiwRequest> request =

    88         new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

    89     EXPECT(XQApplicationManager::create)

    90         .with(

    91             QString("com.nokia.services"), QString("devicemanager"), 

    92             QString("showVersionNumber()"), KIsEmbedded)

    93         .returns(request.data());

    94     EXPECT(XQAiwRequest::send).returns(true);

    95     

    96     bool handled = m_handler->executeKeySequence(KCodeSwVersion);

    97     

    98     QVERIFY(verify());

    99     emit request->requestOk(QVariant(true));

   100     QVERIFY(request.isNull());

   101     QCOMPARE(handled, true);

   102 }

   103 

   104 

   105 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceFactoryResetCodes()

   106 {

   107     XQAiwInterfaceDescriptor dummyDescriptor;

   108     QPointer<XQAiwRequest> request =

   109         new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   110     EXPECT(XQApplicationManager::create)

   111         .with(

   112             QString("com.nokia.symbian"), QString("IFactoryReset"), 

   113             QString("showResetUi()"), KIsEmbedded)

   114         .returns(request.data());

   115     EXPECT(XQAiwRequest::send).returns(true);

   116     

   117     bool handled = m_handler->executeKeySequence(KCodeActivateRfsNormal);

   118     

   119     QVERIFY(verify());

   120     emit request->requestOk(QVariant(true));

   121     QVERIFY(request.isNull());

   122     QCOMPARE(handled, true);

   123     

   124     request = new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   125     EXPECT(XQApplicationManager::create)

   126         .with(

   127             QString("com.nokia.symbian"), QString("IFactoryReset"), 

   128             QString("showResetUi()"), KIsEmbedded)

   129         .returns(request.data());

   130     EXPECT(XQAiwRequest::send).returns(true);

   131     

   132     handled = m_handler->executeKeySequence(KCodeActivateRfsDeep);

   133     

   134     QVERIFY(verify());

   135     emit request->requestOk(QVariant(true));

   136     QVERIFY(request.isNull());

   137     QCOMPARE(handled, true);

   138 }

   139 

   140 

   141 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceBluetoothCodes()

   142 {

   143     XQAiwInterfaceDescriptor dummyDescriptor;

   144     QPointer<XQAiwRequest> request =

   145         new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   146     EXPECT(XQApplicationManager::create)

   147         .with(

   148             QString("com.nokia.services"), QString("bluetooth"), 

   149             QString("showBluetoothDeviceAddress()"), KIsEmbedded)

   150         .returns(request.data());

   151     EXPECT(XQAiwRequest::send).returns(true);

   152     

   153     bool handled = m_handler->executeKeySequence(KCodeBtAddress);

   154     

   155     QVERIFY(verify());

   156     emit request->requestOk(QVariant(true));

   157     QVERIFY(request.isNull());

   158     QCOMPARE(handled, true);

   159     

   160     request = new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   161     EXPECT(XQApplicationManager::create)

   162         .with(

   163             QString("com.nokia.services"), QString("bluetooth"), 

   164             QString("showBluetoothLoopback()"), KIsEmbedded)

   165         .returns(request.data());

   166     EXPECT(XQAiwRequest::send).returns(true);

   167     

   168     handled = m_handler->executeKeySequence(KCodeRFLoopback);

   169     

   170     QVERIFY(verify());

   171     emit request->requestOk(QVariant(true));

   172     QVERIFY(request.isNull());

   173     QCOMPARE(handled, true);

   174     

   175     request = new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   176     EXPECT(XQApplicationManager::create)

   177         .with(

   178             QString("com.nokia.services"), QString("bluetooth"), 

   179             QString("activateBluetoothDebugMode()"), KIsEmbedded)

   180         .returns(request.data());

   181     EXPECT(XQAiwRequest::send).returns(true);

   182     

   183     handled = m_handler->executeKeySequence(KCodeBtDebugMode);

   184     

   185     QVERIFY(verify());

   186     emit request->requestOk(QVariant(true));

   187     QVERIFY(request.isNull());

   188     QCOMPARE(handled, true);

   189 }

   190 

   191 

   192 void UT_ManufacturerKeySequenceHandler::t_executeInvalidKeySequence()

   193 {

   194     const QString KUnknownSequence = "123";

   195     bool handled = m_handler->executeKeySequence(KUnknownSequence);

   196     QCOMPARE(handled, false);

   197 }

   198 

   199 

   200 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceRequestDispatchingFails()

   201 {

   202     // controlled synchronous Qt Highway error during request processing

   203     XQAiwInterfaceDescriptor dummyDescriptor;

   204     QPointer<XQAiwRequest> request =

   205         new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   206     EXPECT(XQApplicationManager::create)

   207         .with(

   208             QString("com.nokia.services"), QString("devicemanager"), 

   209             QString("showVersionNumber()"), KIsEmbedded)

   210         .returns(request.data());

   211     EXPECT(XQAiwRequest::send).returns(false);

   212     

   213     bool handled = m_handler->executeKeySequence(KCodeSwVersion);

   214     m_handler->requestError(0, QString(""));

   215     

   216     QVERIFY(verify());

   217     QVERIFY(request.isNull());

   218     QCOMPARE(handled, false);

   219     

   220     // controlled asynchronous Qt Highway error during request processing

   221     request = new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   222     EXPECT(XQApplicationManager::create)

   223         .with(

   224             QString("com.nokia.services"), QString("devicemanager"), 

   225             QString("showVersionNumber()"), KIsEmbedded)

   226         .returns(request.data());

   227     EXPECT(XQAiwRequest::send).returns(true);

   228     

   229     handled = m_handler->executeKeySequence(KCodeSwVersion);

   230     

   231     QVERIFY(verify());

   232     emit request->requestError(0, QString(""));

   233     QVERIFY(request.isNull());

   234     // asynchronous errors have to be silently discarded

   235     QCOMPARE(handled, true);

   236     

   237     // exception during service request dispatching/send

   238     request = new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   239     EXPECT(XQApplicationManager::create)

   240         .with(

   241             QString("com.nokia.services"), QString("devicemanager"), 

   242             QString("showVersionNumber()"), KIsEmbedded)

   243         .returns(request.data());

   244     EXPECT(XQAiwRequest::send)

   245         .willOnce(invokeWithoutArguments(generateException));

   246     

   247     int result = 0;

   248     QT_TRYCATCH_ERROR(

   249         result, handled = m_handler->executeKeySequence(KCodeSwVersion));

   250     

   251     QVERIFY(verify());

   252     QVERIFY(request.isNull());

   253     QVERIFY(0 != result);

   254     

   255     // request object creation fails

   256     handled = m_handler->executeKeySequence(KCodeSwVersion);

   257     QCOMPARE(handled, false);

   258 }

   259 

   260 

   261 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceSimultaneousRequest()

   262 {

   263     XQAiwInterfaceDescriptor dummyDescriptor;

   264     QPointer<XQAiwRequest> request =

   265         new XQAiwRequest(dummyDescriptor, QString(""), KIsEmbedded);

   266     EXPECT(XQApplicationManager::create)

   267         .with(

   268             QString("com.nokia.services"), QString("devicemanager"), 

   269             QString("showVersionNumber()"), KIsEmbedded)

   270         .returns(request.data());

   271     EXPECT(XQAiwRequest::send).returns(true);

   272     

   273     bool handled = m_handler->executeKeySequence(KCodeSwVersion);

   274     

   275     QVERIFY(verify());

   276     QVERIFY(!request.isNull());

   277     QCOMPARE(handled, true);

   278     

   279     // simultaneous request attempt

   280     EXPECT(XQApplicationManager::create).times(0);

   281     EXPECT(XQAiwRequest::send).times(0);

   282     handled = m_handler->executeKeySequence(KCodeSwVersion);

   283     QCOMPARE(handled, false);

   284 }

   285 

   286 QTEST_MAIN_S60(UT_ManufacturerKeySequenceHandler)