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 // System includes

    18 #include <HbApplication>

    19 #include <HbDocumentLoader>

    20 #include <HbStackedWidget>

    21 #include <HbRadioButtonList>

    22 #include <HbAction>

    23 #include <HbLineEdit>

    24 #include <HbLabel>

    25 #include <HbCheckBox>

    26 #include <QGraphicsWidget>

    27 #include <QObjectList>

    28 #include <QtCore>

    29 #include <QTest>

    30 #include <QDebug>

    31 #include <QList>

    32 #include <HbListWidget>

    33 #include <HbListWidgetItem>

    34 #include <HbParameterLengthLimiter>

    35 

    36 // User includes

    37 #include "testwlanwizardcontext.h"

    38 #include "hbautotest.h"

    39 #include "wlanwizard.h"

    40 #include "wlanwizard_p.h"

    41 #include "wlanwizardpageinternal.h"

    42 #include "wlanwizardhelper.h"

    43 #include "wlanqtutils_context.h"

    44 #include "wlanqtutils.h"

    45 #include "wlanqtutilsap.h"

    46 #include "eapqtconfiginterface_context.h"

    47 #include "eapwizard.h"

    48 #include "eapwizard_p.h"

    49 #include "eapwizardpage.h"

    50 #include "wpswizardpage.h"

    51 #include "wlanmgmtclient_context.h"

    52 #include "wpswizardstepfour.h"

    53 #include "wpswizardstepfour_p.h"

    54 #include "cwpsactiverunner.h"

    55 

    56 // External function prototypes

    57 

    58 // Local constants

    59 class TestRadioButtonList: public HbRadioButtonList

    60 {

    61 public:

    62     void emitActivated(const QModelIndex &modelIndex)

    63     { HbRadioButtonList::emitActivated(modelIndex); }

    64 };

    65 

    66 

    67 // ---------------------------------------------------------

    68 // FRAMEWORK FUNCTIONS

    69 // ---------------------------------------------------------

    70 

    71 ContextWlanApList::ContextWlanApList()

    72 {

    73 

    74 }

    75 

    76 ContextWlanApList::~ContextWlanApList()

    77 {

    78     clear();

    79 }

    80 

    81 void ContextWlanApList::Add(QString name, int netMode, int secMode, bool wpaPskInUse,

    82     bool wpsSupported, int signalStrength)

    83 {

    84     QSharedPointer<WlanQtUtilsAp> temp = QSharedPointer<WlanQtUtilsAp>(new WlanQtUtilsAp());

    85     temp->setValue(WlanQtUtilsAp::ConfIdSsid, name);

    86     temp->setValue(WlanQtUtilsAp::ConfIdConnectionMode, netMode);

    87     temp->setValue(WlanQtUtilsAp::ConfIdSecurityMode, secMode);

    88     temp->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, wpaPskInUse);

    89     temp->setValue(WlanQtUtilsAp::ConfIdWpsSupported, wpsSupported);

    90     temp->setValue(WlanQtUtilsAp::ConfIdSignalStrength, signalStrength);

    91 

    92     mList.append(temp);

    93 }

    94 

    95 void ContextWlanApList::clear()

    96 {

    97     mList.clear();

    98 }

    99 

   100 

   101 TestWlanWizardContext::TestWlanWizardContext() :

   102     mView(NULL),

   103     mMainWindow(NULL),

   104     mWlanQtUtilsContext(NULL),

   105     mEapQtUtilsContext(NULL),

   106     mWlanMgmtClientContext(NULL),

   107     mApList(NULL),

   108     mApOpenList(NULL)   

   109 {

   110     

   111 }

   112 TestWlanWizardContext::~TestWlanWizardContext()

   113 {

   114     

   115 }

   116 

   117 /**

   118  * This function will be called before the first test function is executed.

   119  */

   120 void TestWlanWizardContext::initTestCase()

   121 {

   122     qDebug("TestWlanWizardContext::initTestCase");

   123 

   124     mMainWindow = new HbAutoTestMainWindow;

   125 

   126     mView = new TestView();

   127 

   128     mMainWindow->addView(mView);

   129     mMainWindow->setCurrentView(mView);

   130     mMainWindow->installEventFilter(this);

   131     mMainWindow->show();

   132 

   133     QTest::qWait(1);

   134     while (!mEvent) {

   135         QTest::qWait(WaitTimeForUi);

   136     }

   137     mEvent = false;

   138     mApList = new ContextWlanApList();

   139     mApOpenList = new ContextWlanApList();

   140 

   141 }

   142 

   143 /**

   144  * This function will be called after the last test function was executed.

   145  */

   146 void TestWlanWizardContext::cleanupTestCase()

   147 {

   148     qDebug("TestWlanWizardContext::cleanupTestCase");

   149 

   150     qDebug("delete mApList");

   151     delete mApList;

   152     mApList = NULL;

   153     delete mApOpenList;

   154     mApOpenList = NULL;

   155 

   156     qDebug("delete mMainWindow");

   157     mMainWindow->setAttribute( Qt::WA_DeleteOnClose, true );

   158     mMainWindow->close();

   159     mMainWindow = NULL;

   160     QTest::qWait(WaitTimeForUi);

   161     qDebug("TestWlanWizardContext::cleanupTestCase exit");

   162 }

   163 

   164 /**

   165  * This function will be called before each test function is executed.

   166  */

   167 void TestWlanWizardContext::init()

   168 {

   169     qDebug("TestWlanWizardContext::init()");

   170 

   171     mView->createWizard();

   172     mWlanQtUtilsContext = new WlanQtUtilsContext(mView->mWizard->d_ptr->mWlanQtUtils.data());

   173 

   174     mEapQtUtilsContext = new EapQtConfigInterfaceContext();

   175     mEapQtUtilsContext->setObject(getEapQtConfig());

   176     

   177     mWlanMgmtClientContext = new WlanMgmtClientContext();

   178     //mWlanMgmtClientContext->setObject(mWlanMgmtClient);

   179     

   180     WpsPageStepFour* wps = (WpsPageStepFour*)(mView->mWizard->d_ptr->mPages[WpsWizardPage::PageWpsWizardStep4]);

   181     Q_ASSERT(wps);

   182     mWlanMgmtClientContext->setObject(wps->d_ptr->mWpsActiveRunner->iWLANMgmtClient);

   183 }

   184 

   185 /**

   186  * This function will be called after each test function is executed.

   187  */

   188 void TestWlanWizardContext::cleanup()

   189 {

   190     qDebug("TestWlanWizardContext::cleanup()");

   191 

   192     delete mWlanQtUtilsContext;

   193     delete mEapQtUtilsContext;

   194     delete mWlanMgmtClientContext;

   195     

   196     mView->deleteWizard();

   197     mApList->clear();

   198     mApOpenList->clear();

   199     QTest::qWait(1);

   200 }

   201 

   202 

   203 /*!

   204  * Filter to catch focus event to the text editor widget.

   205  */

   206 bool TestWlanWizardContext::eventFilter(QObject *obj, QEvent *event)

   207 {

   208     if (obj == mMainWindow && event->type() == QEvent::Show) {

   209         mMainWindow->removeEventFilter(this);

   210         mEvent = true;

   211     }

   212     return false;

   213 }

   214 

   215 QGraphicsWidget* TestWlanWizardContext::findChildItem(const QString &itemName, QGraphicsItem *widget)

   216 {

   217     QList<QGraphicsItem*> list = widget->childItems();

   218     for (int i = 0; i < list.size(); i++) {

   219         QGraphicsItem* item = list[i];

   220         

   221         QGraphicsWidget* widget = NULL;

   222         if (item->isWidget()) {

   223             widget = (QGraphicsWidget*)item;

   224         }

   225         if (widget && widget->objectName() == itemName) {

   226             return widget;

   227         }

   228         else if ((item = findChildItem(itemName, item))) {

   229             return (QGraphicsWidget*)item;

   230         }

   231     }

   232     return 0;

   233 }

   234 

   235 bool TestWlanWizardContext::verifyStatus(WizardStatusSignal status, int iapId)

   236 {

   237     return mView->verifyStatus(status, iapId);

   238 }

   239 

   240 bool TestWlanWizardContext::verifyCurrentPage(int pageId, int retries, int wait_ms)

   241 {

   242     bool ret = true;

   243     for (int i = 0; i < retries; i++) {

   244         QTest::qWait(wait_ms);

   245         WlanWizardPrivate *pPrivate = mView->mWizard->d_ptr;

   246         HbWidget* current = qobject_cast<HbWidget*> (pPrivate->mStackedWidget->currentWidget());

   247         WlanWizardPage *page = pPrivate->mPageMapper[current];

   248         

   249         // TODO: verify title in this method

   250         

   251         if (page == pPrivate->mPages[pageId]) {

   252             switch(pageId) {

   253             case WlanWizardPageInternal::PageNetworkMode:

   254                 return verifyDialogText("dialog_6", hbTrId("txt_occ_dialog_select_network_mode_and_status"));

   255             

   256             case WlanWizardPageInternal::PageNetworkSecurity:

   257                 return verifyDialogText("dialog_6", hbTrId("txt_occ_dialog_select_network_security_mode"));

   258             

   259             case WlanWizardPageInternal::PageSsid:

   260                 return verifyDialogText("dialog", hbTrId("txt_occ_dialog_insert_the_name_of_the_new_wlan_net"));

   261             

   262             case WlanWizardPageInternal::PageSummary:

   263                 if (pPrivate->mTitle->plainText() != hbTrId("txt_occ_title_wlan_setup_wizard_summary")){

   264                     qWarning("TestWlanWizardContext::verifyCurrentPage: Invalid title");

   265                     return false;

   266                 }

   267                 return true;

   268                

   269             case EapWizardPage::PageOuterType:

   270                 return verifyDialogText("title", hbTrId("txt_occ_title_select_eap_type"));

   271 

   272             case EapWizardPage::PageCertificateCa:

   273                 return verifyDialogText("title", hbTrId("txt_occ_title_select_authority_certificate"));

   274                 

   275             case EapWizardPage::PageCertificateUser:

   276                 return verifyDialogText("title", hbTrId("txt_occ_title_select_user_certificate"));

   277                 

   278             case EapWizardPage::PageNewPacStorePassword:

   279                 ret &= verifyDialogText("setlabel_55", hbTrId("txt_occ_setlabel_new_pac_store_password"));

   280                 ret &= verifyDialogText("setlabel_56", hbTrId("txt_occ_setlabel_confirm_password"));

   281                 return ret;

   282 

   283             case EapWizardPage::PagePromptPacStorePassword:

   284                 return verifyDialogText("setlabel_59", hbTrId("txt_occ_setlabel_eap_pac_store_password"));

   285 

   286             case WpsWizardPage::PageWpsWizardStep2:

   287                 return verifyDialogText("label", hbTrId("txt_occ_dialog_selected_network_supports_wifi_pro"));

   288                 break;

   289 

   290             case WpsWizardPage::PageWpsWizardStep3_Button:

   291                 return verifyDialogText("label_heading", hbTrId("txt_occ_dialog_first_press_button_on_the_wireless"));

   292                 break;

   293 

   294             case WpsWizardPage::PageWpsWizardStep3_Number:

   295                 // TODO: something better here??

   296                 return true;

   297                 

   298             case WpsWizardPage::PageWpsWizardStep4:

   299                 return verifyDialogText("label_heading", hbTrId("txt_occ_dialog_negotiating"));

   300                 

   301             case WpsWizardPage::PageWpsWizardStep5:

   302                 return verifyDialogText("label", hbTrId("txt_occ_dialog_settings_received_for_multiple_wlan"));

   303                 

   304             default:

   305                 return false;

   306             }

   307         }

   308     }

   309     qWarning("verifyCurrentPage: expected: %d", pageId);

   310     return false;

   311 }

   312 

   313 bool TestWlanWizardContext::verifyCurrentPageWithInfo(

   314     int pageId, const QString &info, int retries, int wait_ms)

   315 {

   316     bool ret = true;

   317     for (int i = 0; i < retries; i++) {

   318         QTest::qWait(wait_ms);

   319 

   320         WlanWizardPrivate *pPrivate = mView->mWizard->d_ptr;

   321         HbWidget* current = qobject_cast<HbWidget*> (pPrivate->mStackedWidget->currentWidget());

   322         WlanWizardPage *page = pPrivate->mPageMapper[current];

   323 

   324         // TODO: verify title in this method

   325         

   326         if (page == pPrivate->mPages[pageId]) {

   327             switch(pageId) {

   328             case WlanWizardPageInternal::PageGenericError:

   329                 return verifyDialogText("dialog", info);

   330 

   331             case WlanWizardPageInternal::PageKeyQuery:

   332                 return verifyDialogText("dialog", HbParameterLengthLimiter("txt_occ_dialog_enter_key_for_1").arg(info));

   333 

   334             case WlanWizardPageInternal::PageProcessSettings:

   335                 return verifyDialogText("dialog", HbParameterLengthLimiter("txt_occ_dialog_checking_connection_to_1").arg(info));

   336 

   337             case WlanWizardPageInternal::PageScanning:

   338                 return verifyDialogText("dialog", HbParameterLengthLimiter("txt_occ_dialog_searching").arg(info));

   339                

   340             case EapWizardPage::PageUsernamePassword:

   341                 ret &= verifyDialogText(

   342                     "setlabel_55",

   343                     HbParameterLengthLimiter("txt_occ_setlabel_user_name_for_1").arg(info));

   344                 ret &= verifyDialogText("setlabel_56", hbTrId("txt_occ_setlabel_eap_password"));

   345                 return ret;

   346                 

   347             case EapWizardPage::PageIdentity:

   348                 ret &= verifyDialogText("setlabel_53", HbParameterLengthLimiter("txt_occ_setlabel_user_name_for_1").arg(info));

   349                 ret &= verifyDialogText("setlabel_53_val", hbTrId("txt_occ_setlabel_user_name_val_generate_automatic"));

   350                 ret &= verifyDialogText("setlabel_54", hbTrId("txt_occ_setlabel_eap_realm"));

   351                 ret &= verifyDialogText("setlabel_54_val", hbTrId("txt_occ_setlabel_eap_realm_val_generate_automatically"));

   352                 return ret;

   353                 

   354             case EapWizardPage::PageInnerTypePeap:

   355             case EapWizardPage::PageInnerTypeEapTtls:

   356                 return verifyDialogText("title", HbParameterLengthLimiter("txt_occ_title_select_innear_eap_type_for_1").arg(info));

   357             

   358             default:

   359                 return verifyCurrentPage(pageId, retries, wait_ms);

   360             }

   361         }

   362     }

   363     qWarning("verifyCurrentPage: expected: %d", pageId);

   364     return false;

   365 }

   366 

   367 

   368 bool TestWlanWizardContext::verifyDialogText(const QString objName, const QString text)

   369 {

   370     HbWidget* current = qobject_cast<HbWidget*> (

   371         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   372     HbWidget* widget = qobject_cast<HbWidget*> (

   373         findChildItem(objName, current));

   374     

   375     if (widget) {

   376         HbLabel *label = qobject_cast<HbLabel*>(widget);

   377         if (label) {

   378             if(label->plainText() == text) {

   379                 if (!label->isVisible()){

   380                     qWarning("verifyDialogText: not visible");

   381                     return false;

   382                 }

   383                 return true;

   384                 

   385             } else {

   386                 qWarning("verifyDialogText: not match");

   387                 qDebug() << "expect: " << text;

   388                 qDebug() << "actual: " << label->plainText();

   389                 return false;

   390             }

   391         }

   392         HbCheckBox *checkBox = qobject_cast<HbCheckBox*>(widget);

   393         

   394         if (checkBox) {

   395             if(checkBox->text() == text) {

   396                 if (!checkBox->isVisible()){

   397                     qWarning("verifyDialogText: not visible");

   398                     return false;

   399                 }

   400                 return true;

   401                 

   402             } else {

   403                 qWarning("verifyDialogText: not match");

   404                 qDebug() << "expect: " << text;

   405                 qDebug() << "actual: " << checkBox->text();

   406                 return false;

   407             }

   408         }

   409     }

   410     

   411     qWarning("verifyDialogText: object not found");

   412     

   413     return false;

   414 }

   415 

   416 bool TestWlanWizardContext::verifyActionButtons(ButtonStatus prevStatus,

   417     ButtonStatus cancelStatus,

   418     ButtonStatus nextStatus,

   419     ButtonStatus finishStatus)

   420 {

   421     WlanWizardPrivate *pPrivate = mView->mWizard->d_ptr;

   422     ButtonStatus prevReally = ButtonHidden;

   423     ButtonStatus cancelReally = ButtonHidden;

   424     ButtonStatus nextReally = ButtonHidden;

   425     ButtonStatus finishReally = ButtonHidden;

   426 

   427     if(pPrivate->mActionPrevious->isVisible()) {

   428         if(pPrivate->mActionPrevious->isEnabled()) {

   429             prevReally = ButtonEnabled;

   430         } else {

   431             prevReally = ButtonDisabled;

   432         }

   433     }

   434 

   435     if(pPrivate->mActionCancel->isVisible()) {

   436         if(pPrivate->mActionCancel->isEnabled()) {

   437             cancelReally = ButtonEnabled;

   438         } else {

   439             cancelReally = ButtonDisabled;

   440         }

   441     }

   442 

   443     if(pPrivate->mActionNext->isVisible()) {

   444         if(pPrivate->mActionNext->isEnabled()) {

   445             nextReally = ButtonEnabled;

   446         } else {

   447             nextReally = ButtonDisabled;

   448         }

   449     }

   450 

   451     if(pPrivate->mActionFinish->isVisible()) {

   452         if(pPrivate->mActionFinish->isEnabled()) {

   453             finishReally = ButtonEnabled;

   454         } else {

   455             finishReally = ButtonDisabled;

   456         }

   457     }

   458     bool ret = true;

   459     if (prevReally != prevStatus){

   460         qWarning("Previous Button: really: %d, status: %d", prevReally, prevStatus);

   461         ret = false;

   462     }

   463     if (cancelReally != cancelStatus){

   464         qWarning("Cancel Button: really: %d, status: %d", cancelReally, cancelStatus);

   465         ret = false;

   466     }

   467     if (nextReally != nextStatus){

   468         qWarning("Next Button: really: %d, status: %d", nextReally, nextStatus);

   469         ret = false;

   470     }

   471     if (finishReally != finishStatus){

   472         qWarning("Finish Button: really: %d, status: %d", finishReally, finishStatus);

   473         ret = false;

   474     }

   475     

   476     return ret;

   477 }

   478 

   479 bool TestWlanWizardContext::verifySummaryPage(

   480     const QString &ssid, 

   481     int netMode, 

   482     bool hidden,

   483     int secMode, 

   484     bool useWpaPsk,

   485     const QString &destination, 

   486     int outerType,

   487     int innerType,

   488     bool eapFastProvMode)

   489 {

   490     bool ret = true;

   491     int i = 0;

   492     HbListWidget* listWidget = qobject_cast<HbListWidget*> (

   493         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   494     

   495     if (!listWidget){

   496         qWarning("verifySummaryPage: ListWidget not found");

   497         return false;

   498     }

   499     

   500     // VERIFY: NETWORK NAME

   501     HbListWidgetItem *item = listWidget->item(i++);

   502     if (item->text() != hbTrId("txt_occ_dblist_network_name")) {

   503         qWarning("verifySummaryPage: no match network name");

   504         ret = false;

   505     }

   506     

   507     if (item->secondaryText() != ssid){

   508         qWarning("verifySummaryPage: no match ssid");

   509         ret = false;

   510     }

   511     

   512     // VERIFY: NETWORK MODE

   513     item = listWidget->item(i++);

   514     if (item->text() != hbTrId("txt_occ_dblist_network_mode")) {

   515         qWarning("verifySummaryPage: no match network mode");

   516         ret = false;

   517     }

   518     QString netModeString(toNetworkModeString(netMode, hidden));

   519     if (item->secondaryText() != netModeString){

   520         qWarning("verifySummaryPage: no match network mode value");

   521         qDebug() << "Actual: " << item->secondaryText();

   522         qDebug() << "Expected: " << netModeString;

   523         ret = false;

   524     }

   525     

   526     // VERIFY: SECURITY MODE

   527     item = listWidget->item(i++);

   528     if (item->text() != hbTrId("txt_occ_dblist_security_mode")) {

   529         qWarning("verifySummaryPage: no match security mode");

   530         ret = false;

   531     }

   532     

   533     if (item->secondaryText() != toSecurityModeString(secMode, useWpaPsk)){

   534         qWarning("verifySummaryPage: no match security mode value");

   535         ret = false;

   536     }

   537     

   538     // VERIFY: EAP OUTER TYPE

   539     if (outerType != -1) {

   540         item = listWidget->item(i++);

   541         if (item->text() != hbTrId("txt_occ_dblist_outer_eap")) {

   542             qWarning("verifySummaryPage: no match eap outer type");

   543             ret = false;

   544         }

   545         if (item->secondaryText() != eapTypeToString(outerType)){

   546             qWarning("verifySummaryPage: no match eap outer type value");

   547             ret = false;

   548         }

   549     }

   550     

   551     // VERIFY: EAP INNER TYPE

   552     if (innerType != -1) {

   553         item = listWidget->item(i++);

   554         if (item->text() != hbTrId("txt_occ_dblist_inner_eap")) {

   555             qWarning("verifySummaryPage: no match eap inner type");

   556             ret = false;

   557         }

   558         if (item->secondaryText() != eapTypeToString(innerType)){

   559             qWarning("verifySummaryPage: no match eap inner type value");

   560             ret = false;

   561         }

   562     }

   563     

   564     // VERIFY: EAP FAST PROVISIONING MODE

   565     if (eapFastProvMode) {

   566         item = listWidget->item(i++);

   567         if (item->text() != hbTrId("txt_occ_dblist_provisioning_mode_for_eapfast")) {

   568             qWarning("verifySummaryPage: no match eap prov mode");

   569             ret = false;

   570         }

   571         if (item->secondaryText() != hbTrId("txt_occ_dblist_provisioning_mode_for_val_unauthent")){

   572             qWarning("verifySummaryPage: no match eap prov mode value");

   573             ret = false;

   574         }

   575     }

   576 

   577     // VERIFY: DESTINATION

   578     if (destination.length() > 0) {

   579         item = listWidget->item(i++);

   580         if (item->text() != hbTrId("txt_occ_dblist_destination")) {

   581             qWarning("verifySummaryPage: no match destination");

   582             ret = false;

   583         }

   584         if (item->secondaryText() != destination){

   585             qWarning("verifySummaryPage: no match destination value");

   586             ret = false;

   587         }

   588     }

   589 

   590     

   591     return ret;

   592 }

   593 

   594 bool TestWlanWizardContext::mouseClickObject(const QString objName)

   595 {

   596     HbWidget* current = qobject_cast<HbWidget*> (

   597         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   598     HbWidget* widget = (HbWidget*) findChildItem(objName, current);

   599     

   600     if (widget) {

   601         HbAutoTest::mouseClick(mMainWindow, widget);

   602         widget->clearFocus();

   603         widget->setFocus();

   604         return true;

   605     }

   606     qWarning("mouseClickObject: object not found");

   607     

   608     return false;

   609 }

   610 

   611 bool TestWlanWizardContext::insertTextToObject(const QString objName, const QString text)

   612 {

   613     HbWidget* current = qobject_cast<HbWidget*> (

   614         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   615     HbWidget* widget = (HbWidget*) findChildItem(objName, current);

   616 

   617     if (widget) {

   618         for (int i = 0; i < text.size(); i++) {

   619             HbAutoTest::keyPress(mMainWindow, text.at(i).toAscii(), 0, 10);

   620             QTest::qWait(20);

   621         }

   622         return true;

   623     }

   624     qWarning("insertTextToObject: object not found");

   625     return false;

   626 }

   627 

   628 bool TestWlanWizardContext::selectRadioButton(const QString objName, int index)

   629 {

   630     HbWidget* current = qobject_cast<HbWidget*> (

   631         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   632     TestRadioButtonList* widget = (TestRadioButtonList*) findChildItem(objName, current);

   633 

   634     if (widget) {

   635         if (widget->items().length() <= index) {

   636             qWarning("selectRadioButton: index out of range");

   637             return false;

   638         }

   639         widget->setSelected(index);

   640         widget->emitActivated(widget->currentIndex());

   641         return true;

   642     }

   643     qWarning("selectRadioButton: object not found");

   644     

   645     return false;

   646 }

   647 

   648 bool TestWlanWizardContext::verifyRadioButtonState(

   649     const QString objName, 

   650     int index, 

   651     const QString &text)

   652 {

   653     HbWidget* current = qobject_cast<HbWidget*> (

   654         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   655     

   656     HbRadioButtonList* widget = qobject_cast<HbRadioButtonList*>( 

   657         findChildItem(objName, current));

   658 

   659     if (widget) {

   660         if (widget->selected() != index) {

   661             qWarning("verifyRadioButtonState: invalid index");

   662             return false;

   663         }

   664         

   665         if (widget->items().at(index) != text) {

   666             qWarning("verifyRadioButtonState: text does not match");

   667             return false;

   668         }

   669         

   670         return true;

   671     }

   672     qWarning("verifyRadioButtonState: object not found");

   673     

   674     return false;

   675 }

   676 

   677 QStringList TestWlanWizardContext::verifyRadioButtons(const QString objName)

   678 {

   679     HbWidget* current = qobject_cast<HbWidget*> (

   680         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   681 

   682     HbRadioButtonList* widget = qobject_cast<HbRadioButtonList*>( 

   683         findChildItem(objName, current));

   684     

   685     QStringList ret;

   686 

   687     if (widget) {

   688         ret = widget->items();

   689     }

   690     else {

   691         qWarning("verifyRadioButtons: object not found");

   692     }

   693 

   694     return ret;

   695 }

   696 

   697 int TestWlanWizardContext::verifySelectedRadioButton(const QString objName)

   698 {

   699     HbWidget* current = qobject_cast<HbWidget*> (

   700         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   701 

   702     HbRadioButtonList* widget = qobject_cast<HbRadioButtonList*>( 

   703         findChildItem(objName, current));

   704 

   705     int ret = ListNotFound;

   706 

   707     if (widget) {

   708         ret = widget->selected();

   709     }

   710     else {

   711         qWarning("verifySelectedRadioButton: object not found");

   712     }

   713 

   714     return ret;

   715 }

   716 

   717 bool TestWlanWizardContext::verifyCheckBoxState(const QString &objName, bool checked)

   718 {

   719     HbWidget* current = qobject_cast<HbWidget*> (

   720         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   721     HbCheckBox* widget = qobject_cast<HbCheckBox*>(

   722         findChildItem(objName, current));

   723 

   724     if (widget) {

   725         if (widget->isChecked() != checked) {

   726             qWarning("Checkbox in wrong state");

   727             return false;

   728         }

   729         return true;

   730     } 

   731     qWarning("verifyCheckBoxState: object not found");

   732     return false;

   733 }

   734 

   735 bool TestWlanWizardContext::selectCheckBoxState(const QString &objName, bool check)

   736 {

   737     HbWidget* current = qobject_cast<HbWidget*> (

   738         mView->mWizard->d_ptr->mStackedWidget->currentWidget());

   739     HbCheckBox* widget = qobject_cast<HbCheckBox*>(

   740         findChildItem(objName, current));

   741 

   742     if (widget) {

   743         if (check) {

   744             widget->setCheckState(Qt::Checked);

   745         } else {

   746             widget->setCheckState(Qt::Unchecked);

   747         }

   748         return true;

   749         

   750     } 

   751     qWarning("selectCheckBoxState: object not found");

   752     return false; 

   753 }

   754 

   755 bool TestWlanWizardContext::mouseClickNext()

   756 {

   757     if (mView->mWizard->d_ptr->mActionNext->isEnabled()) {

   758         mView->mWizard->d_ptr->mActionNext->activate(QAction::Trigger);

   759         return true;

   760     }

   761     qWarning("Next button not enabled");

   762     return false;

   763 }

   764 

   765 bool TestWlanWizardContext::mouseClickPrevious()

   766 {

   767     if (mView->mWizard->d_ptr->mActionPrevious->isEnabled()) {

   768         mView->mWizard->d_ptr->mActionPrevious->activate(QAction::Trigger);

   769         return true;

   770     }

   771     qWarning("mouseClickPrevious: Previous button not enabled");

   772     

   773     return false;

   774 }

   775 

   776 bool TestWlanWizardContext::mouseClickCancel()

   777 {

   778     if (mView->mWizard->d_ptr->mActionCancel->isEnabled()) {

   779         mView->mWizard->d_ptr->mActionCancel->activate(QAction::Trigger);

   780         return true;

   781     }

   782     qWarning("mouseClickCancel: Cancel button not enabled");

   783     

   784     return false;

   785 }

   786 

   787 bool TestWlanWizardContext::mouseClickFinish()

   788 {

   789     if (mView->mWizard->d_ptr->mActionFinish->isEnabled()) {

   790         mView->mWizard->d_ptr->mActionFinish->activate(QAction::Trigger);

   791         return true;

   792     }

   793     qWarning("mouseClickFinish: Finish button not enabled");

   794     

   795     return false;

   796 }

   797 

   798 QString TestWlanWizardContext::toNetworkModeString(int netMode, bool isHidden)

   799 {

   800     QString ret;

   801     switch (netMode) {

   802     case CMManagerShim::Adhoc:

   803         ret = hbTrId("txt_occ_dblist_network_mode_val_adhoc");

   804         break;

   805 

   806      default:

   807          if (isHidden) {

   808              ret = hbTrId("txt_occ_dblist_network_mode_val_infrastructure_hi");

   809          } else {

   810              ret = hbTrId("txt_occ_dblist_network_mode_val_infrastructure_pu");

   811          }

   812          break;

   813      }

   814     return ret;

   815 } 

   816 

   817 QString TestWlanWizardContext::toSecurityModeString(int secMode, int useWpaPsk)

   818 {

   819     QString ret;

   820     switch (secMode) {

   821     case CMManagerShim::WlanSecMode802_1x:

   822         ret = hbTrId("txt_occ_dblist_security_mode_val_8021x");

   823         break;

   824         

   825     case CMManagerShim::WlanSecModeWep:

   826         ret = hbTrId("txt_occ_dblist_security_mode_val_wep");

   827         break;

   828         

   829     case CMManagerShim::WlanSecModeWpa:

   830         if (useWpaPsk) {

   831             ret = hbTrId("txt_occ_dblist_security_mode_val_wpawpa2psk");

   832         } else {

   833             ret = hbTrId("txt_occ_dblist_security_mode_val_wpawpa2_with_eap");

   834         }

   835         break;

   836         

   837     case CMManagerShim::WlanSecModeWpa2:

   838         if (useWpaPsk) {

   839             ret = hbTrId("txt_occ_dblist_security_mode_val_wpa2_with_passwor");

   840         } else {

   841             ret = hbTrId("txt_occ_dblist_security_mode_val_wpa2_with_eap");

   842         }

   843         break;

   844         

   845     default:

   846         Q_ASSERT(secMode == CMManagerShim::WlanSecModeOpen);

   847         ret = hbTrId("txt_occ_dblist_security_mode_val_open");

   848         break;

   849     }

   850     return ret;

   851 }

   852 

   853 

   854 EapQtConfigInterface *TestWlanWizardContext::getEapQtConfig()

   855 {

   856     return mView->mWizard->d_ptr->mEapWizard->d_ptr->mEapConfIf.data();

   857 }

   858 

   859 QString TestWlanWizardContext::eapTypeToString(int type)

   860 {

   861     QCOMPARE(mView->mWizard->d_ptr->mEapWizard != NULL, true);

   862     return mView->mWizard->d_ptr->mEapWizard->d_ptr->eapTypeToString(type);

   863 }

   864 

   865 void TestWlanWizardContext::callWlanWizard_startPageOperation()

   866 {

   867     mView->mWizard->d_ptr->startPageOperation();

   868 }

   869 

   870 

   871 void TestWlanWizardContext::setWlanMgmtClientObject(CWlanMgmtClient* object)

   872 {

   873     // TODO: mWlanMgmtClient = object;

   874 }

   875 

   876 TestView::TestView() : mWizard(NULL)

   877 {

   878     qDebug("TestView::TestView()");

   879 }

   880 

   881 TestView::~TestView()

   882 {

   883     qDebug("TestView::~TestView()");

   884 }

   885 

   886 void TestView::createWizard()

   887 {

   888     qDebug("TestView::createWizard");

   889     Q_ASSERT(mWizard == NULL);

   890     mWizard = new WlanWizard(mainWindow());

   891     bool ok;

   892     ok = connect(

   893         mWizard, SIGNAL(finished(int, bool)), 

   894         this, SLOT(finished(int, bool)), 

   895         Qt::QueuedConnection);

   896     Q_ASSERT(ok);

   897 

   898     ok = connect(

   899         mWizard, SIGNAL(cancelled()), 

   900         this, SLOT(cancelled()),

   901         Qt::QueuedConnection);

   902     Q_ASSERT(ok);

   903     

   904     mWizardStatus = WizardStatusSignalNone;

   905     mConnectedIapId = -100;

   906 }

   907 

   908 void TestView::showWizard()

   909 {

   910     qDebug("TestView::showWizard()");

   911     Q_ASSERT(mWizard);

   912     mWizard->show();

   913 }

   914 

   915 void TestView::deleteWizard()

   916 {

   917     qDebug("TestView::deleteWizard");

   918 

   919     Q_ASSERT(mWizard != NULL);

   920     QMetaObject::invokeMethod(mWizard, "deleteLater", Qt::QueuedConnection);

   921     QTest::qWait(100); 

   922     mWizard = NULL; 

   923 }

   924 

   925 void TestView::finished(int iapId, bool connected)

   926 {

   927     qDebug("TestView::complete(), iap id: %d, connected: %d", iapId, connected);

   928     

   929     if (mWizardStatus != WizardStatusSignalNone) {

   930         qWarning("TestView::finished: multiple signals received");

   931         mWizardStatus = WizardStatusSignalUndefined;

   932     } else {

   933         mWizardStatus = WizardStatusSignalFinished;

   934         mConnectedIapId = iapId;

   935     }

   936 }

   937 

   938 void TestView::cancelled()

   939 {

   940     qDebug("TestView::cancelled()");

   941     if (mWizardStatus != WizardStatusSignalNone) {

   942         qWarning("TestView::cancelled: multiple signals received");

   943         mWizardStatus = WizardStatusSignalUndefined;

   944     } else {

   945         mWizardStatus = WizardStatusSignalCancelled;

   946     }

   947 }

   948 

   949 bool TestView::verifyStatus(WizardStatusSignal status, int iapId )

   950 {

   951     // Since connections to cancelled and finished signals are queued

   952     // we need to use qWait() here.

   953     QTest::qWait(100);

   954     bool ret = true;

   955     if (status != mWizardStatus){

   956         qWarning("TestView::verifyStatus, status: expected: %d, actual: %d", status, mWizardStatus);

   957         ret = false;

   958     }

   959     if (status == WizardStatusSignalFinished) {

   960         if (iapId != mConnectedIapId) {

   961             qWarning("TestView::verifyStatus, iapid: expected: %d, actual: %d", iapId, mConnectedIapId);

   962             ret = false;

   963         }

   964     }

   965     return ret;

   966 }

   967 

   968