diff -r fb81b597edf1 -r bdc64aa9b954 wlanutilities/wlanwizard/tsrc/ut/testwlanwizardcontext.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/wlanutilities/wlanwizard/tsrc/ut/testwlanwizardcontext.cpp	Mon Aug 23 13:30:09 2010 +0300
@@ -0,0 +1,968 @@
+/*
+ * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ */
+
+// System includes
+#include <HbApplication>
+#include <HbDocumentLoader>
+#include <HbStackedWidget>
+#include <HbRadioButtonList>
+#include <HbAction>
+#include <HbLineEdit>
+#include <HbLabel>
+#include <HbCheckBox>
+#include <QGraphicsWidget>
+#include <QObjectList>
+#include <QtCore>
+#include <QTest>
+#include <QDebug>
+#include <QList>
+#include <HbListWidget>
+#include <HbListWidgetItem>
+#include <HbParameterLengthLimiter>
+
+// User includes
+#include "testwlanwizardcontext.h"
+#include "hbautotest.h"
+#include "wlanwizard.h"
+#include "wlanwizard_p.h"
+#include "wlanwizardpageinternal.h"
+#include "wlanwizardhelper.h"
+#include "wlanqtutils_context.h"
+#include "wlanqtutils.h"
+#include "wlanqtutilsap.h"
+#include "eapqtconfiginterface_context.h"
+#include "eapwizard.h"
+#include "eapwizard_p.h"
+#include "eapwizardpage.h"
+#include "wpswizardpage.h"
+#include "wlanmgmtclient_context.h"
+#include "wpswizardstepfour.h"
+#include "wpswizardstepfour_p.h"
+#include "cwpsactiverunner.h"
+
+// External function prototypes
+
+// Local constants
+class TestRadioButtonList: public HbRadioButtonList
+{
+public:
+    void emitActivated(const QModelIndex &modelIndex)
+    { HbRadioButtonList::emitActivated(modelIndex); }
+};
+
+
+// ---------------------------------------------------------
+// FRAMEWORK FUNCTIONS
+// ---------------------------------------------------------
+
+ContextWlanApList::ContextWlanApList()
+{
+
+}
+
+ContextWlanApList::~ContextWlanApList()
+{
+    clear();
+}
+
+void ContextWlanApList::Add(QString name, int netMode, int secMode, bool wpaPskInUse,
+    bool wpsSupported, int signalStrength)
+{
+    QSharedPointer<WlanQtUtilsAp> temp = QSharedPointer<WlanQtUtilsAp>(new WlanQtUtilsAp());
+    temp->setValue(WlanQtUtilsAp::ConfIdSsid, name);
+    temp->setValue(WlanQtUtilsAp::ConfIdConnectionMode, netMode);
+    temp->setValue(WlanQtUtilsAp::ConfIdSecurityMode, secMode);
+    temp->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, wpaPskInUse);
+    temp->setValue(WlanQtUtilsAp::ConfIdWpsSupported, wpsSupported);
+    temp->setValue(WlanQtUtilsAp::ConfIdSignalStrength, signalStrength);
+
+    mList.append(temp);
+}
+
+void ContextWlanApList::clear()
+{
+    mList.clear();
+}
+
+
+TestWlanWizardContext::TestWlanWizardContext() :
+    mView(NULL),
+    mMainWindow(NULL),
+    mWlanQtUtilsContext(NULL),
+    mEapQtUtilsContext(NULL),
+    mWlanMgmtClientContext(NULL),
+    mApList(NULL),
+    mApOpenList(NULL)   
+{
+    
+}
+TestWlanWizardContext::~TestWlanWizardContext()
+{
+    
+}
+
+/**
+ * This function will be called before the first test function is executed.
+ */
+void TestWlanWizardContext::initTestCase()
+{
+    qDebug("TestWlanWizardContext::initTestCase");
+
+    mMainWindow = new HbAutoTestMainWindow;
+
+    mView = new TestView();
+
+    mMainWindow->addView(mView);
+    mMainWindow->setCurrentView(mView);
+    mMainWindow->installEventFilter(this);
+    mMainWindow->show();
+
+    QTest::qWait(1);
+    while (!mEvent) {
+        QTest::qWait(WaitTimeForUi);
+    }
+    mEvent = false;
+    mApList = new ContextWlanApList();
+    mApOpenList = new ContextWlanApList();
+
+}
+
+/**
+ * This function will be called after the last test function was executed.
+ */
+void TestWlanWizardContext::cleanupTestCase()
+{
+    qDebug("TestWlanWizardContext::cleanupTestCase");
+
+    qDebug("delete mApList");
+    delete mApList;
+    mApList = NULL;
+    delete mApOpenList;
+    mApOpenList = NULL;
+
+    qDebug("delete mMainWindow");
+    mMainWindow->setAttribute( Qt::WA_DeleteOnClose, true );
+    mMainWindow->close();
+    mMainWindow = NULL;
+    QTest::qWait(WaitTimeForUi);
+    qDebug("TestWlanWizardContext::cleanupTestCase exit");
+}
+
+/**
+ * This function will be called before each test function is executed.
+ */
+void TestWlanWizardContext::init()
+{
+    qDebug("TestWlanWizardContext::init()");
+
+    mView->createWizard();
+    mWlanQtUtilsContext = new WlanQtUtilsContext(mView->mWizard->d_ptr->mWlanQtUtils.data());
+
+    mEapQtUtilsContext = new EapQtConfigInterfaceContext();
+    mEapQtUtilsContext->setObject(getEapQtConfig());
+    
+    mWlanMgmtClientContext = new WlanMgmtClientContext();
+    //mWlanMgmtClientContext->setObject(mWlanMgmtClient);
+    
+    WpsPageStepFour* wps = (WpsPageStepFour*)(mView->mWizard->d_ptr->mPages[WpsWizardPage::PageWpsWizardStep4]);
+    Q_ASSERT(wps);
+    mWlanMgmtClientContext->setObject(wps->d_ptr->mWpsActiveRunner->iWLANMgmtClient);
+}
+
+/**
+ * This function will be called after each test function is executed.
+ */
+void TestWlanWizardContext::cleanup()
+{
+    qDebug("TestWlanWizardContext::cleanup()");
+
+    delete mWlanQtUtilsContext;
+    delete mEapQtUtilsContext;
+    delete mWlanMgmtClientContext;
+    
+    mView->deleteWizard();
+    mApList->clear();
+    mApOpenList->clear();
+    QTest::qWait(1);
+}
+
+
+/*!
+ * Filter to catch focus event to the text editor widget.
+ */
+bool TestWlanWizardContext::eventFilter(QObject *obj, QEvent *event)
+{
+    if (obj == mMainWindow && event->type() == QEvent::Show) {
+        mMainWindow->removeEventFilter(this);
+        mEvent = true;
+    }
+    return false;
+}
+
+QGraphicsWidget* TestWlanWizardContext::findChildItem(const QString &itemName, QGraphicsItem *widget)
+{
+    QList<QGraphicsItem*> list = widget->childItems();
+    for (int i = 0; i < list.size(); i++) {
+        QGraphicsItem* item = list[i];
+        
+        QGraphicsWidget* widget = NULL;
+        if (item->isWidget()) {
+            widget = (QGraphicsWidget*)item;
+        }
+        if (widget && widget->objectName() == itemName) {
+            return widget;
+        }
+        else if ((item = findChildItem(itemName, item))) {
+            return (QGraphicsWidget*)item;
+        }
+    }
+    return 0;
+}
+
+bool TestWlanWizardContext::verifyStatus(WizardStatusSignal status, int iapId)
+{
+    return mView->verifyStatus(status, iapId);
+}
+
+bool TestWlanWizardContext::verifyCurrentPage(int pageId, int retries, int wait_ms)
+{
+    bool ret = true;
+    for (int i = 0; i < retries; i++) {
+        QTest::qWait(wait_ms);
+        WlanWizardPrivate *pPrivate = mView->mWizard->d_ptr;
+        HbWidget* current = qobject_cast<HbWidget*> (pPrivate->mStackedWidget->currentWidget());
+        WlanWizardPage *page = pPrivate->mPageMapper[current];
+        
+        // TODO: verify title in this method
+        
+        if (page == pPrivate->mPages[pageId]) {
+            switch(pageId) {
+            case WlanWizardPageInternal::PageNetworkMode:
+                return verifyDialogText("dialog_6", hbTrId("txt_occ_dialog_select_network_mode_and_status"));
+            
+            case WlanWizardPageInternal::PageNetworkSecurity:
+                return verifyDialogText("dialog_6", hbTrId("txt_occ_dialog_select_network_security_mode"));
+            
+            case WlanWizardPageInternal::PageSsid:
+                return verifyDialogText("dialog", hbTrId("txt_occ_dialog_insert_the_name_of_the_new_wlan_net"));
+            
+            case WlanWizardPageInternal::PageSummary:
+                if (pPrivate->mTitle->plainText() != hbTrId("txt_occ_title_wlan_setup_wizard_summary")){
+                    qWarning("TestWlanWizardContext::verifyCurrentPage: Invalid title");
+                    return false;
+                }
+                return true;
+               
+            case EapWizardPage::PageOuterType:
+                return verifyDialogText("title", hbTrId("txt_occ_title_select_eap_type"));
+
+            case EapWizardPage::PageCertificateCa:
+                return verifyDialogText("title", hbTrId("txt_occ_title_select_authority_certificate"));
+                
+            case EapWizardPage::PageCertificateUser:
+                return verifyDialogText("title", hbTrId("txt_occ_title_select_user_certificate"));
+                
+            case EapWizardPage::PageNewPacStorePassword:
+                ret &= verifyDialogText("setlabel_55", hbTrId("txt_occ_setlabel_new_pac_store_password"));
+                ret &= verifyDialogText("setlabel_56", hbTrId("txt_occ_setlabel_confirm_password"));
+                return ret;
+
+            case EapWizardPage::PagePromptPacStorePassword:
+                return verifyDialogText("setlabel_59", hbTrId("txt_occ_setlabel_eap_pac_store_password"));
+
+            case WpsWizardPage::PageWpsWizardStep2:
+                return verifyDialogText("label", hbTrId("txt_occ_dialog_selected_network_supports_wifi_pro"));
+                break;
+
+            case WpsWizardPage::PageWpsWizardStep3_Button:
+                return verifyDialogText("label_heading", hbTrId("txt_occ_dialog_first_press_button_on_the_wireless"));
+                break;
+
+            case WpsWizardPage::PageWpsWizardStep3_Number:
+                // TODO: something better here??
+                return true;
+                
+            case WpsWizardPage::PageWpsWizardStep4:
+                return verifyDialogText("label_heading", hbTrId("txt_occ_dialog_negotiating"));
+                
+            case WpsWizardPage::PageWpsWizardStep5:
+                return verifyDialogText("label", hbTrId("txt_occ_dialog_settings_received_for_multiple_wlan"));
+                
+            default:
+                return false;
+            }
+        }
+    }
+    qWarning("verifyCurrentPage: expected: %d", pageId);
+    return false;
+}
+
+bool TestWlanWizardContext::verifyCurrentPageWithInfo(
+    int pageId, const QString &info, int retries, int wait_ms)
+{
+    bool ret = true;
+    for (int i = 0; i < retries; i++) {
+        QTest::qWait(wait_ms);
+
+        WlanWizardPrivate *pPrivate = mView->mWizard->d_ptr;
+        HbWidget* current = qobject_cast<HbWidget*> (pPrivate->mStackedWidget->currentWidget());
+        WlanWizardPage *page = pPrivate->mPageMapper[current];
+
+        // TODO: verify title in this method
+        
+        if (page == pPrivate->mPages[pageId]) {
+            switch(pageId) {
+            case WlanWizardPageInternal::PageGenericError:
+                return verifyDialogText("dialog", info);
+
+            case WlanWizardPageInternal::PageKeyQuery:
+                return verifyDialogText("dialog", HbParameterLengthLimiter("txt_occ_dialog_enter_key_for_1").arg(info));
+
+            case WlanWizardPageInternal::PageProcessSettings:
+                return verifyDialogText("dialog", HbParameterLengthLimiter("txt_occ_dialog_checking_connection_to_1").arg(info));
+
+            case WlanWizardPageInternal::PageScanning:
+                return verifyDialogText("dialog", HbParameterLengthLimiter("txt_occ_dialog_searching").arg(info));
+               
+            case EapWizardPage::PageUsernamePassword:
+                ret &= verifyDialogText(
+                    "setlabel_55",
+                    HbParameterLengthLimiter("txt_occ_setlabel_user_name_for_1").arg(info));
+                ret &= verifyDialogText("setlabel_56", hbTrId("txt_occ_setlabel_eap_password"));
+                return ret;
+                
+            case EapWizardPage::PageIdentity:
+                ret &= verifyDialogText("setlabel_53", HbParameterLengthLimiter("txt_occ_setlabel_user_name_for_1").arg(info));
+                ret &= verifyDialogText("setlabel_53_val", hbTrId("txt_occ_setlabel_user_name_val_generate_automatic"));
+                ret &= verifyDialogText("setlabel_54", hbTrId("txt_occ_setlabel_eap_realm"));
+                ret &= verifyDialogText("setlabel_54_val", hbTrId("txt_occ_setlabel_eap_realm_val_generate_automatically"));
+                return ret;
+                
+            case EapWizardPage::PageInnerTypePeap:
+            case EapWizardPage::PageInnerTypeEapTtls:
+                return verifyDialogText("title", HbParameterLengthLimiter("txt_occ_title_select_innear_eap_type_for_1").arg(info));
+            
+            default:
+                return verifyCurrentPage(pageId, retries, wait_ms);
+            }
+        }
+    }
+    qWarning("verifyCurrentPage: expected: %d", pageId);
+    return false;
+}
+
+
+bool TestWlanWizardContext::verifyDialogText(const QString objName, const QString text)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    HbWidget* widget = qobject_cast<HbWidget*> (
+        findChildItem(objName, current));
+    
+    if (widget) {
+        HbLabel *label = qobject_cast<HbLabel*>(widget);
+        if (label) {
+            if(label->plainText() == text) {
+                if (!label->isVisible()){
+                    qWarning("verifyDialogText: not visible");
+                    return false;
+                }
+                return true;
+                
+            } else {
+                qWarning("verifyDialogText: not match");
+                qDebug() << "expect: " << text;
+                qDebug() << "actual: " << label->plainText();
+                return false;
+            }
+        }
+        HbCheckBox *checkBox = qobject_cast<HbCheckBox*>(widget);
+        
+        if (checkBox) {
+            if(checkBox->text() == text) {
+                if (!checkBox->isVisible()){
+                    qWarning("verifyDialogText: not visible");
+                    return false;
+                }
+                return true;
+                
+            } else {
+                qWarning("verifyDialogText: not match");
+                qDebug() << "expect: " << text;
+                qDebug() << "actual: " << checkBox->text();
+                return false;
+            }
+        }
+    }
+    
+    qWarning("verifyDialogText: object not found");
+    
+    return false;
+}
+
+bool TestWlanWizardContext::verifyActionButtons(ButtonStatus prevStatus,
+    ButtonStatus cancelStatus,
+    ButtonStatus nextStatus,
+    ButtonStatus finishStatus)
+{
+    WlanWizardPrivate *pPrivate = mView->mWizard->d_ptr;
+    ButtonStatus prevReally = ButtonHidden;
+    ButtonStatus cancelReally = ButtonHidden;
+    ButtonStatus nextReally = ButtonHidden;
+    ButtonStatus finishReally = ButtonHidden;
+
+    if(pPrivate->mActionPrevious->isVisible()) {
+        if(pPrivate->mActionPrevious->isEnabled()) {
+            prevReally = ButtonEnabled;
+        } else {
+            prevReally = ButtonDisabled;
+        }
+    }
+
+    if(pPrivate->mActionCancel->isVisible()) {
+        if(pPrivate->mActionCancel->isEnabled()) {
+            cancelReally = ButtonEnabled;
+        } else {
+            cancelReally = ButtonDisabled;
+        }
+    }
+
+    if(pPrivate->mActionNext->isVisible()) {
+        if(pPrivate->mActionNext->isEnabled()) {
+            nextReally = ButtonEnabled;
+        } else {
+            nextReally = ButtonDisabled;
+        }
+    }
+
+    if(pPrivate->mActionFinish->isVisible()) {
+        if(pPrivate->mActionFinish->isEnabled()) {
+            finishReally = ButtonEnabled;
+        } else {
+            finishReally = ButtonDisabled;
+        }
+    }
+    bool ret = true;
+    if (prevReally != prevStatus){
+        qWarning("Previous Button: really: %d, status: %d", prevReally, prevStatus);
+        ret = false;
+    }
+    if (cancelReally != cancelStatus){
+        qWarning("Cancel Button: really: %d, status: %d", cancelReally, cancelStatus);
+        ret = false;
+    }
+    if (nextReally != nextStatus){
+        qWarning("Next Button: really: %d, status: %d", nextReally, nextStatus);
+        ret = false;
+    }
+    if (finishReally != finishStatus){
+        qWarning("Finish Button: really: %d, status: %d", finishReally, finishStatus);
+        ret = false;
+    }
+    
+    return ret;
+}
+
+bool TestWlanWizardContext::verifySummaryPage(
+    const QString &ssid, 
+    int netMode, 
+    bool hidden,
+    int secMode, 
+    bool useWpaPsk,
+    const QString &destination, 
+    int outerType,
+    int innerType,
+    bool eapFastProvMode)
+{
+    bool ret = true;
+    int i = 0;
+    HbListWidget* listWidget = qobject_cast<HbListWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    
+    if (!listWidget){
+        qWarning("verifySummaryPage: ListWidget not found");
+        return false;
+    }
+    
+    // VERIFY: NETWORK NAME
+    HbListWidgetItem *item = listWidget->item(i++);
+    if (item->text() != hbTrId("txt_occ_dblist_network_name")) {
+        qWarning("verifySummaryPage: no match network name");
+        ret = false;
+    }
+    
+    if (item->secondaryText() != ssid){
+        qWarning("verifySummaryPage: no match ssid");
+        ret = false;
+    }
+    
+    // VERIFY: NETWORK MODE
+    item = listWidget->item(i++);
+    if (item->text() != hbTrId("txt_occ_dblist_network_mode")) {
+        qWarning("verifySummaryPage: no match network mode");
+        ret = false;
+    }
+    QString netModeString(toNetworkModeString(netMode, hidden));
+    if (item->secondaryText() != netModeString){
+        qWarning("verifySummaryPage: no match network mode value");
+        qDebug() << "Actual: " << item->secondaryText();
+        qDebug() << "Expected: " << netModeString;
+        ret = false;
+    }
+    
+    // VERIFY: SECURITY MODE
+    item = listWidget->item(i++);
+    if (item->text() != hbTrId("txt_occ_dblist_security_mode")) {
+        qWarning("verifySummaryPage: no match security mode");
+        ret = false;
+    }
+    
+    if (item->secondaryText() != toSecurityModeString(secMode, useWpaPsk)){
+        qWarning("verifySummaryPage: no match security mode value");
+        ret = false;
+    }
+    
+    // VERIFY: EAP OUTER TYPE
+    if (outerType != -1) {
+        item = listWidget->item(i++);
+        if (item->text() != hbTrId("txt_occ_dblist_outer_eap")) {
+            qWarning("verifySummaryPage: no match eap outer type");
+            ret = false;
+        }
+        if (item->secondaryText() != eapTypeToString(outerType)){
+            qWarning("verifySummaryPage: no match eap outer type value");
+            ret = false;
+        }
+    }
+    
+    // VERIFY: EAP INNER TYPE
+    if (innerType != -1) {
+        item = listWidget->item(i++);
+        if (item->text() != hbTrId("txt_occ_dblist_inner_eap")) {
+            qWarning("verifySummaryPage: no match eap inner type");
+            ret = false;
+        }
+        if (item->secondaryText() != eapTypeToString(innerType)){
+            qWarning("verifySummaryPage: no match eap inner type value");
+            ret = false;
+        }
+    }
+    
+    // VERIFY: EAP FAST PROVISIONING MODE
+    if (eapFastProvMode) {
+        item = listWidget->item(i++);
+        if (item->text() != hbTrId("txt_occ_dblist_provisioning_mode_for_eapfast")) {
+            qWarning("verifySummaryPage: no match eap prov mode");
+            ret = false;
+        }
+        if (item->secondaryText() != hbTrId("txt_occ_dblist_provisioning_mode_for_val_unauthent")){
+            qWarning("verifySummaryPage: no match eap prov mode value");
+            ret = false;
+        }
+    }
+
+    // VERIFY: DESTINATION
+    if (destination.length() > 0) {
+        item = listWidget->item(i++);
+        if (item->text() != hbTrId("txt_occ_dblist_destination")) {
+            qWarning("verifySummaryPage: no match destination");
+            ret = false;
+        }
+        if (item->secondaryText() != destination){
+            qWarning("verifySummaryPage: no match destination value");
+            ret = false;
+        }
+    }
+
+    
+    return ret;
+}
+
+bool TestWlanWizardContext::mouseClickObject(const QString objName)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    HbWidget* widget = (HbWidget*) findChildItem(objName, current);
+    
+    if (widget) {
+        HbAutoTest::mouseClick(mMainWindow, widget);
+        widget->clearFocus();
+        widget->setFocus();
+        return true;
+    }
+    qWarning("mouseClickObject: object not found");
+    
+    return false;
+}
+
+bool TestWlanWizardContext::insertTextToObject(const QString objName, const QString text)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    HbWidget* widget = (HbWidget*) findChildItem(objName, current);
+
+    if (widget) {
+        for (int i = 0; i < text.size(); i++) {
+            HbAutoTest::keyPress(mMainWindow, text.at(i).toAscii(), 0, 10);
+            QTest::qWait(20);
+        }
+        return true;
+    }
+    qWarning("insertTextToObject: object not found");
+    return false;
+}
+
+bool TestWlanWizardContext::selectRadioButton(const QString objName, int index)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    TestRadioButtonList* widget = (TestRadioButtonList*) findChildItem(objName, current);
+
+    if (widget) {
+        if (widget->items().length() <= index) {
+            qWarning("selectRadioButton: index out of range");
+            return false;
+        }
+        widget->setSelected(index);
+        widget->emitActivated(widget->currentIndex());
+        return true;
+    }
+    qWarning("selectRadioButton: object not found");
+    
+    return false;
+}
+
+bool TestWlanWizardContext::verifyRadioButtonState(
+    const QString objName, 
+    int index, 
+    const QString &text)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    
+    HbRadioButtonList* widget = qobject_cast<HbRadioButtonList*>( 
+        findChildItem(objName, current));
+
+    if (widget) {
+        if (widget->selected() != index) {
+            qWarning("verifyRadioButtonState: invalid index");
+            return false;
+        }
+        
+        if (widget->items().at(index) != text) {
+            qWarning("verifyRadioButtonState: text does not match");
+            return false;
+        }
+        
+        return true;
+    }
+    qWarning("verifyRadioButtonState: object not found");
+    
+    return false;
+}
+
+QStringList TestWlanWizardContext::verifyRadioButtons(const QString objName)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+
+    HbRadioButtonList* widget = qobject_cast<HbRadioButtonList*>( 
+        findChildItem(objName, current));
+    
+    QStringList ret;
+
+    if (widget) {
+        ret = widget->items();
+    }
+    else {
+        qWarning("verifyRadioButtons: object not found");
+    }
+
+    return ret;
+}
+
+int TestWlanWizardContext::verifySelectedRadioButton(const QString objName)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+
+    HbRadioButtonList* widget = qobject_cast<HbRadioButtonList*>( 
+        findChildItem(objName, current));
+
+    int ret = ListNotFound;
+
+    if (widget) {
+        ret = widget->selected();
+    }
+    else {
+        qWarning("verifySelectedRadioButton: object not found");
+    }
+
+    return ret;
+}
+
+bool TestWlanWizardContext::verifyCheckBoxState(const QString &objName, bool checked)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    HbCheckBox* widget = qobject_cast<HbCheckBox*>(
+        findChildItem(objName, current));
+
+    if (widget) {
+        if (widget->isChecked() != checked) {
+            qWarning("Checkbox in wrong state");
+            return false;
+        }
+        return true;
+    } 
+    qWarning("verifyCheckBoxState: object not found");
+    return false;
+}
+
+bool TestWlanWizardContext::selectCheckBoxState(const QString &objName, bool check)
+{
+    HbWidget* current = qobject_cast<HbWidget*> (
+        mView->mWizard->d_ptr->mStackedWidget->currentWidget());
+    HbCheckBox* widget = qobject_cast<HbCheckBox*>(
+        findChildItem(objName, current));
+
+    if (widget) {
+        if (check) {
+            widget->setCheckState(Qt::Checked);
+        } else {
+            widget->setCheckState(Qt::Unchecked);
+        }
+        return true;
+        
+    } 
+    qWarning("selectCheckBoxState: object not found");
+    return false; 
+}
+
+bool TestWlanWizardContext::mouseClickNext()
+{
+    if (mView->mWizard->d_ptr->mActionNext->isEnabled()) {
+        mView->mWizard->d_ptr->mActionNext->activate(QAction::Trigger);
+        return true;
+    }
+    qWarning("Next button not enabled");
+    return false;
+}
+
+bool TestWlanWizardContext::mouseClickPrevious()
+{
+    if (mView->mWizard->d_ptr->mActionPrevious->isEnabled()) {
+        mView->mWizard->d_ptr->mActionPrevious->activate(QAction::Trigger);
+        return true;
+    }
+    qWarning("mouseClickPrevious: Previous button not enabled");
+    
+    return false;
+}
+
+bool TestWlanWizardContext::mouseClickCancel()
+{
+    if (mView->mWizard->d_ptr->mActionCancel->isEnabled()) {
+        mView->mWizard->d_ptr->mActionCancel->activate(QAction::Trigger);
+        return true;
+    }
+    qWarning("mouseClickCancel: Cancel button not enabled");
+    
+    return false;
+}
+
+bool TestWlanWizardContext::mouseClickFinish()
+{
+    if (mView->mWizard->d_ptr->mActionFinish->isEnabled()) {
+        mView->mWizard->d_ptr->mActionFinish->activate(QAction::Trigger);
+        return true;
+    }
+    qWarning("mouseClickFinish: Finish button not enabled");
+    
+    return false;
+}
+
+QString TestWlanWizardContext::toNetworkModeString(int netMode, bool isHidden)
+{
+    QString ret;
+    switch (netMode) {
+    case CMManagerShim::Adhoc:
+        ret = hbTrId("txt_occ_dblist_network_mode_val_adhoc");
+        break;
+
+     default:
+         if (isHidden) {
+             ret = hbTrId("txt_occ_dblist_network_mode_val_infrastructure_hi");
+         } else {
+             ret = hbTrId("txt_occ_dblist_network_mode_val_infrastructure_pu");
+         }
+         break;
+     }
+    return ret;
+} 
+
+QString TestWlanWizardContext::toSecurityModeString(int secMode, int useWpaPsk)
+{
+    QString ret;
+    switch (secMode) {
+    case CMManagerShim::WlanSecMode802_1x:
+        ret = hbTrId("txt_occ_dblist_security_mode_val_8021x");
+        break;
+        
+    case CMManagerShim::WlanSecModeWep:
+        ret = hbTrId("txt_occ_dblist_security_mode_val_wep");
+        break;
+        
+    case CMManagerShim::WlanSecModeWpa:
+        if (useWpaPsk) {
+            ret = hbTrId("txt_occ_dblist_security_mode_val_wpawpa2psk");
+        } else {
+            ret = hbTrId("txt_occ_dblist_security_mode_val_wpawpa2_with_eap");
+        }
+        break;
+        
+    case CMManagerShim::WlanSecModeWpa2:
+        if (useWpaPsk) {
+            ret = hbTrId("txt_occ_dblist_security_mode_val_wpa2_with_passwor");
+        } else {
+            ret = hbTrId("txt_occ_dblist_security_mode_val_wpa2_with_eap");
+        }
+        break;
+        
+    default:
+        Q_ASSERT(secMode == CMManagerShim::WlanSecModeOpen);
+        ret = hbTrId("txt_occ_dblist_security_mode_val_open");
+        break;
+    }
+    return ret;
+}
+
+
+EapQtConfigInterface *TestWlanWizardContext::getEapQtConfig()
+{
+    return mView->mWizard->d_ptr->mEapWizard->d_ptr->mEapConfIf.data();
+}
+
+QString TestWlanWizardContext::eapTypeToString(int type)
+{
+    QCOMPARE(mView->mWizard->d_ptr->mEapWizard != NULL, true);
+    return mView->mWizard->d_ptr->mEapWizard->d_ptr->eapTypeToString(type);
+}
+
+void TestWlanWizardContext::callWlanWizard_startPageOperation()
+{
+    mView->mWizard->d_ptr->startPageOperation();
+}
+
+
+void TestWlanWizardContext::setWlanMgmtClientObject(CWlanMgmtClient* object)
+{
+    // TODO: mWlanMgmtClient = object;
+}
+
+TestView::TestView() : mWizard(NULL)
+{
+    qDebug("TestView::TestView()");
+}
+
+TestView::~TestView()
+{
+    qDebug("TestView::~TestView()");
+}
+
+void TestView::createWizard()
+{
+    qDebug("TestView::createWizard");
+    Q_ASSERT(mWizard == NULL);
+    mWizard = new WlanWizard(mainWindow());
+    bool ok;
+    ok = connect(
+        mWizard, SIGNAL(finished(int, bool)), 
+        this, SLOT(finished(int, bool)), 
+        Qt::QueuedConnection);
+    Q_ASSERT(ok);
+
+    ok = connect(
+        mWizard, SIGNAL(cancelled()), 
+        this, SLOT(cancelled()),
+        Qt::QueuedConnection);
+    Q_ASSERT(ok);
+    
+    mWizardStatus = WizardStatusSignalNone;
+    mConnectedIapId = -100;
+}
+
+void TestView::showWizard()
+{
+    qDebug("TestView::showWizard()");
+    Q_ASSERT(mWizard);
+    mWizard->show();
+}
+
+void TestView::deleteWizard()
+{
+    qDebug("TestView::deleteWizard");
+
+    Q_ASSERT(mWizard != NULL);
+    QMetaObject::invokeMethod(mWizard, "deleteLater", Qt::QueuedConnection);
+    QTest::qWait(100); 
+    mWizard = NULL; 
+}
+
+void TestView::finished(int iapId, bool connected)
+{
+    qDebug("TestView::complete(), iap id: %d, connected: %d", iapId, connected);
+    
+    if (mWizardStatus != WizardStatusSignalNone) {
+        qWarning("TestView::finished: multiple signals received");
+        mWizardStatus = WizardStatusSignalUndefined;
+    } else {
+        mWizardStatus = WizardStatusSignalFinished;
+        mConnectedIapId = iapId;
+    }
+}
+
+void TestView::cancelled()
+{
+    qDebug("TestView::cancelled()");
+    if (mWizardStatus != WizardStatusSignalNone) {
+        qWarning("TestView::cancelled: multiple signals received");
+        mWizardStatus = WizardStatusSignalUndefined;
+    } else {
+        mWizardStatus = WizardStatusSignalCancelled;
+    }
+}
+
+bool TestView::verifyStatus(WizardStatusSignal status, int iapId )
+{
+    // Since connections to cancelled and finished signals are queued
+    // we need to use qWait() here.
+    QTest::qWait(100);
+    bool ret = true;
+    if (status != mWizardStatus){
+        qWarning("TestView::verifyStatus, status: expected: %d, actual: %d", status, mWizardStatus);
+        ret = false;
+    }
+    if (status == WizardStatusSignalFinished) {
+        if (iapId != mConnectedIapId) {
+            qWarning("TestView::verifyStatus, iapid: expected: %d, actual: %d", iapId, mConnectedIapId);
+            ret = false;
+        }
+    }
+    return ret;
+}
+
+