/*

* Copyright (c) 2009 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:

*

*/

#include "ut_networkpluginform.h"

#include "qtestmains60ui.h"

#include "cpitemdatahelper.h"

#include "psetwrapper.h"

#define private public

#include "cpnetworkpluginform.h"

class CPsetContainer

{

public:

    CPsetContainer(){};

    ~CPsetContainer(){};

};

const QString KIconGsmForbidden("qtg_small_network_off"); 

const QString KIconGsmNotForbidden("qtg_small_network");

const QString KIconWcdmaForbidden("qtg_small_wcdma_off"); 

const QString KIconWcdmaNotForbidden("qtg_small_wcdma");

const QString KIconGsmAndWcdmaForbidden("qtg_small_pd_wcdma_off"); 

const QString KIconGsmAndWcdmaNotForbidden("qtg_small_pd_wcdma");

/*!

  UT_CpNetworkPluginForm::UT_CpNetworkPluginForm

 */

UT_CpNetworkPluginForm::UT_CpNetworkPluginForm() 

    : m_networkPluginForm(NULL), i(0)

{

    SmcDefaultValue<PSetNetworkWrapper::ErrorCode>::SetL(PSetNetworkWrapper::ErrNoError);

}

/*!

  UT_CpNetworkPluginForm::~UT_CpNetworkPluginForm

 */

UT_CpNetworkPluginForm::~UT_CpNetworkPluginForm()

{

}

/*!

  UT_CpNetworkPluginForm::init

 */

void UT_CpNetworkPluginForm::init()

{

    initialize();

    QVERIFY(!m_networkPluginForm);

    CPsetContainer tmpPsetContainer;

    m_networkWrapper = new PSetNetworkWrapper(tmpPsetContainer);

    expect("PSetWrapper::networkWrapper").returns(m_networkWrapper);

    expect("PSetNetworkWrapper::isManualNetworkSelectionSupported").returns(true);

    if(i) {

        m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;

    } else {

        m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;

    }

    i++;

    expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));

    m_networkPluginForm = new CpNetworkPluginForm();

    QVERIFY(m_networkPluginForm);

}

/*!

  UT_CpNetworkPluginForm::t_networkModeStateChanged

 */

void UT_CpNetworkPluginForm::t_networkModeStateChanged()

{

    expect("CpSettingsWrapper::isPhoneOffline").returns(false);

    m_networkPluginForm->networkModeStateChanged(0);

    expect("CpSettingsWrapper::isPhoneOffline").returns(false);

    m_networkPluginForm->networkModeStateChanged(1);

    expect("CpSettingsWrapper::isPhoneOffline").returns(false);

    m_networkPluginForm->networkModeStateChanged(2);

    expect("CpSettingsWrapper::isPhoneOffline").returns(false);

        m_networkPluginForm->networkModeStateChanged(3);

    expect("CpSettingsWrapper::isPhoneOffline").returns(true);

    m_networkPluginForm->networkModeStateChanged(0);

    QVERIFY(verify());

}

/*!

  UT_CpNetworkPluginForm::t_operatorSelectionStateChanged

 */

void UT_CpNetworkPluginForm::t_operatorSelectionStateChanged()

{

    expect("CpSettingsWrapper::isPhoneOffline").returns(false);

    m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;

    expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));

    m_networkPluginForm->operatorSelectionStateChanged();

    expect("CpSettingsWrapper::isPhoneOffline").returns(false);

    m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;

    expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));

    m_networkPluginForm->operatorSelectionStateChanged();

    expect("CpSettingsWrapper::isPhoneOffline").returns(true);

    m_networkPluginForm->operatorSelectionStateChanged();

    QVERIFY(verify());

}

/*!

  UT_CpNetworkPluginForm::t_networkAccessModeGot

 */

void UT_CpNetworkPluginForm::t_networkAccessModeGot()

{

    m_networkPluginForm->networkAccessModeGot(0);

    m_networkPluginForm->networkAccessModeGot(1);

    m_networkPluginForm->networkAccessModeGot(2);

    m_networkPluginForm->networkAccessModeGot(3);

    QVERIFY(verify());

}

/*!

  UT_CpNetworkPluginForm::t_availableNetworksGot

 */

void UT_CpNetworkPluginForm::t_availableNetworksGot()

{

    PSetNetworkWrapper::NetworkInfo temp;

    QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;

    networkInfoList.append(&temp);

    expect("HbDialog::open");

    m_networkPluginForm->availableNetworksGot(networkInfoList);

    QVERIFY(verify());

}

/*!

  UT_CpNetworkPluginForm::t_networkReqestFailed

 */

void UT_CpNetworkPluginForm::t_networkReqestFailed()

{

    PSetNetworkWrapper::ErrorCode error(PSetNetworkWrapper::ErrCauseCallActive);

    PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestSetNetworkMode);

    expect("PSetNetworkWrapper::getNetworkAccessMode");

    m_networkPluginForm->networkReqestFailed(error, type);

    error = PSetNetworkWrapper::ErrNoNetworkService;

    type = PSetNetworkWrapper::RequestSetNetworkMode;

    expect("PSetNetworkWrapper::getNetworkAccessMode");

    m_networkPluginForm->networkReqestFailed(error, type);

    error = PSetNetworkWrapper::ErrOfflineOpNotAllowed;

    type = PSetNetworkWrapper::RequestSetNetworkMode;

    expect("PSetNetworkWrapper::getNetworkAccessMode");

    m_networkPluginForm->networkReqestFailed(error, type);

    PSetNetworkWrapper::NetworkInfo temp;

    QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;

    networkInfoList.append(&temp);

    m_networkPluginForm->availableNetworksGot(networkInfoList);

    error = PSetNetworkWrapper::ErrNoNetworkAccess;

    type = PSetNetworkWrapper::RequestSetNetwork;

    expect("HbDialog::open");

    m_networkPluginForm->networkReqestFailed(error, type);

    QVERIFY(verify());

}

/*!

  UT_CpNetworkPluginForm::t_userCancel

 */

void UT_CpNetworkPluginForm::t_userCancel()

{

    m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;

    expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));

    m_networkPluginForm->userCancel();

    m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;

    expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));

    m_networkPluginForm->userCancel();

    QVERIFY(verify());

}

/*!

  UT_CpNetworkPluginForm::t_handleSearchingNetworks

 */

void UT_CpNetworkPluginForm::t_handleSearchingNetworks()

{

    PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestNone);

    m_networkPluginForm->handleSearchingNetworks(type);

    type = PSetNetworkWrapper::RequestEnumerateNetworks;

    m_networkPluginForm->handleSearchingNetworks(type);

    QVERIFY(verify());

}

/*!

  UT_CpNetworkPluginForm::t_handleRequestingSelectedNetwork

 */

void UT_CpNetworkPluginForm::t_handleRequestingSelectedNetwork()

{

    m_networkPluginForm->handleRequestingSelectedNetwork(true);

    m_networkPluginForm->handleRequestingSelectedNetwork(false);

}

/*!

  UT_CpNetworkPluginForm::t_handleNetworkChanged

 */

void UT_CpNetworkPluginForm::t_handleNetworkChanged()

{

    PSetNetworkWrapper::NetworkInfo currentInfo;

    PSetNetworkWrapper::RegistrationStatus status(PSetNetworkWrapper::RegisteredOnHomeNetwork);

    m_networkPluginForm->handleNetworkChanged(currentInfo, status); 

    status = PSetNetworkWrapper::RegisteredRoaming;

    currentInfo.m_longName = "test";

    m_networkPluginForm->handleNetworkChanged(currentInfo, status);

    status = PSetNetworkWrapper::RegisteredRoaming;

    currentInfo.m_shortName = "test";

    m_networkPluginForm->handleNetworkChanged(currentInfo, status);

}

/*!

  UT_CpNetworkPluginForm::t_primaryIconForNetwork

 */

void UT_CpNetworkPluginForm::t_primaryIconForNetwork()

{

    QScopedPointer<PSetWrapper> wrapper(new PSetWrapper()); 

    expect("PSetWrapper::networkWrapper").returns(wrapper.data()); 

    QScopedPointer<CpNetworkPluginFormAdapter> 

        formClassAdapter(new CpNetworkPluginFormAdapter());

    PSetNetworkWrapper::NetworkInfo currentInfo;

    // Test: forbidden icon flag ON, mode: GSM, status: forbidden 

    currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 

    currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 

    expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 

    QString iconName = formClassAdapter->primaryIconForNetwork(currentInfo);

    QCOMPARE(iconName, KIconGsmForbidden); 

    // Test: forbidden icon flag ON, mode: GSM, status: available

    currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 

    currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 

    expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 

    iconName = formClassAdapter->primaryIconForNetwork(currentInfo);

    QCOMPARE(iconName, KIconGsmNotForbidden); 

    // Test: forbidden icon flag ON, mode: WCDMA, status: forbidden 

    currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 

    currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 

    expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 

    iconName = formClassAdapter->primaryIconForNetwork(currentInfo);

    QCOMPARE(iconName, KIconWcdmaForbidden); 

    // Test: forbidden icon flag ON, mode: WCDMA, status: available

    currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 

    currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 

    expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 

    iconName = formClassAdapter->primaryIconForNetwork(currentInfo);

    QCOMPARE(iconName, KIconWcdmaNotForbidden); 

    // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: forbidden 

    currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 

    currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 

    expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 

    iconName = formClassAdapter->primaryIconForNetwork(currentInfo);

    QCOMPARE(iconName, KIconGsmAndWcdmaForbidden); 

    // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: available

    currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 

    currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 

    expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 

    iconName = formClassAdapter->primaryIconForNetwork(currentInfo);

    QCOMPARE(iconName, KIconGsmAndWcdmaNotForbidden); 

    // Test: forbidden icon flag OFF

    expect("CpSettingsWrapper::forbiddenIconSupported").returns(false);

    iconName = formClassAdapter->primaryIconForNetwork(currentInfo);

    QCOMPARE(iconName, QString("")); 

}

/*!

  UT_CpNetworkPluginForm::cleanup

 */

void UT_CpNetworkPluginForm::cleanup()

{

    reset();

    delete m_networkPluginForm;

    m_networkPluginForm = NULL;

    delete m_networkWrapper;

    m_networkWrapper = NULL;

}

/*!

  UT_CpNetworkPluginForm::t_memleak

 */

void UT_CpNetworkPluginForm::t_memleak()

{

}

/*!

  UT_CpNetworkPluginForm::updateNetworkSelectionMode

 */

void UT_CpNetworkPluginForm::updateNetworkSelectionMode(

    PSetNetworkWrapper::NetworkSelectionMode& mode)

{

    mode = m_NetworkSelectionMode;

}

QTEST_MAIN_S60UI(UT_CpNetworkPluginForm)