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     

    73     expect("KeySequenceHandler::setKeySequenceValidator")

    74         .with(expectedValidator);

    75     

    76     QScopedPointer<ManufacturerKeySequenceHandler> handler(

    77         new ManufacturerKeySequenceHandler());

    78     

    79     QVERIFY(verify());

    80 }

    81 

    82 

    83 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceDeviceManagerCodes()

    84 {

    85     XQAiwInterfaceDescriptor dummyDescriptor;

    86     QPointer<XQAiwRequest> request =

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

    88     EXPECT(XQApplicationManager, create)

    89         .with(

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

    91             QString("showVersionNumber()"), KIsEmbedded)

    92         .returns(request.data());

    93     EXPECT(XQAiwRequest, send).returns(true);

    94     

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

    96     

    97     QVERIFY(verify());

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

    99     QVERIFY(request.isNull());

   100     QCOMPARE(handled, true);

   101 }

   102 

   103 

   104 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceFactoryResetCodes()

   105 {

   106     XQAiwInterfaceDescriptor dummyDescriptor;

   107     QPointer<XQAiwRequest> request =

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

   109     EXPECT(XQApplicationManager, create)

   110         .with(

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

   112             QString("showResetUi()"), KIsEmbedded)

   113         .returns(request.data());

   114     EXPECT(XQAiwRequest, send).returns(true);

   115     

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

   117     

   118     QVERIFY(verify());

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

   120     QVERIFY(request.isNull());

   121     QCOMPARE(handled, true);

   122     

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

   124     EXPECT(XQApplicationManager, create)

   125         .with(

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

   127             QString("showResetUi()"), KIsEmbedded)

   128         .returns(request.data());

   129     EXPECT(XQAiwRequest, send).returns(true);

   130     

   131     handled = m_handler->executeKeySequence(KCodeActivateRfsDeep);

   132     

   133     QVERIFY(verify());

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

   135     QVERIFY(request.isNull());

   136     QCOMPARE(handled, true);

   137 }

   138 

   139 

   140 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceBluetoothCodes()

   141 {

   142     XQAiwInterfaceDescriptor dummyDescriptor;

   143     QPointer<XQAiwRequest> request =

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

   145     EXPECT(XQApplicationManager, create)

   146         .with(

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

   148             QString("showBluetoothDeviceAddress()"), KIsEmbedded)

   149         .returns(request.data());

   150     EXPECT(XQAiwRequest, send).returns(true);

   151     

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

   153     

   154     QVERIFY(verify());

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

   156     QVERIFY(request.isNull());

   157     QCOMPARE(handled, true);

   158     

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

   160     EXPECT(XQApplicationManager, create)

   161         .with(

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

   163             QString("showBluetoothLoopback()"), KIsEmbedded)

   164         .returns(request.data());

   165     EXPECT(XQAiwRequest, send).returns(true);

   166     

   167     handled = m_handler->executeKeySequence(KCodeRFLoopback);

   168     

   169     QVERIFY(verify());

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

   171     QVERIFY(request.isNull());

   172     QCOMPARE(handled, true);

   173 }

   174 

   175 

   176 void UT_ManufacturerKeySequenceHandler::t_executeInvalidKeySequence()

   177 {

   178     const QString KUnknownSequence = "123";

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

   180     QCOMPARE(handled, false);

   181 }

   182 

   183 

   184 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceRequestDispatchingFails()

   185 {

   186     // controlled synchronous Qt Highway error during request processing

   187     XQAiwInterfaceDescriptor dummyDescriptor;

   188     QPointer<XQAiwRequest> request =

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

   190     EXPECT(XQApplicationManager, create)

   191         .with(

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

   193             QString("showVersionNumber()"), KIsEmbedded)

   194         .returns(request.data());

   195     EXPECT(XQAiwRequest, send).returns(false);

   196     

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

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

   199     

   200     QVERIFY(verify());

   201     QVERIFY(request.isNull());

   202     QCOMPARE(handled, false);

   203     

   204     // controlled asynchronous Qt Highway error during request processing

   205     request = 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(true);

   212     

   213     handled = m_handler->executeKeySequence(KCodeSwVersion);

   214     

   215     QVERIFY(verify());

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

   217     QVERIFY(request.isNull());

   218     // asynchronous errors have to be silently discarded

   219     QCOMPARE(handled, true);

   220     

   221     // exception during service request dispatching/send

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

   223     EXPECT(XQApplicationManager, create)

   224         .with(

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

   226             QString("showVersionNumber()"), KIsEmbedded)

   227         .returns(request.data());

   228     EXPECT(XQAiwRequest, send)

   229         .willOnce(invokeWithoutArguments(generateException));

   230     

   231     int result = 0;

   232     QT_TRYCATCH_ERROR(

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

   234     

   235     QVERIFY(verify());

   236     QVERIFY(request.isNull());

   237     QVERIFY(0 != result);

   238     

   239     // request object creation fails

   240     handled = m_handler->executeKeySequence(KCodeSwVersion);

   241     QCOMPARE(handled, false);

   242 }

   243 

   244 

   245 void UT_ManufacturerKeySequenceHandler::t_executeKeySequenceSimultaneousRequest()

   246 {

   247     XQAiwInterfaceDescriptor dummyDescriptor;

   248     QPointer<XQAiwRequest> request =

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

   250     EXPECT(XQApplicationManager, create)

   251         .with(

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

   253             QString("showVersionNumber()"), KIsEmbedded)

   254         .returns(request.data());

   255     EXPECT(XQAiwRequest, send).returns(true);

   256     

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

   258     

   259     QVERIFY(verify());

   260     QVERIFY(!request.isNull());

   261     QCOMPARE(handled, true);

   262     

   263     // simultaneous request attempt

   264     EXPECT(XQApplicationManager, create).times(0);

   265     EXPECT(XQAiwRequest, send).times(0);

   266     handled = m_handler->executeKeySequence(KCodeSwVersion);

   267     QCOMPARE(handled, false);

   268 }

   269 

   270 QTEST_MAIN_S60(UT_ManufacturerKeySequenceHandler)