Mercurial Mercurial > oss > FCL > sf > app > phone / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
phonesettings/cpphonesettingsplugins/cpnetworkplugin/tsrc/ut_cpnetworkpluginform/ut_networkpluginform.cpp
changeset 76 cfea66083b62
parent 60 1eef62f5c541
equal deleted inserted replaced
74:d1c62c765e48 76:cfea66083b62 
    17 
    17 
    18 #include "ut_networkpluginform.h"
 
    18 #include "ut_networkpluginform.h"
 
    19 #include "qtestmains60ui.h"
 
    19 #include "qtestmains60ui.h"
 
    20 #include "cpitemdatahelper.h"
 
    20 #include "cpitemdatahelper.h"
 
    21 #include "psetwrapper.h"
 
    21 #include "psetwrapper.h"
 
       
    22 #include "cpplugincommon.h"
 
    22 #define private public
 
    23 #define private public
 
    23 #include "cpnetworkpluginform.h"
 
    24 #include "cpnetworkpluginform.h"
 
    24 
    25 
    25 
    26 
    26 class CPsetContainer
 
    27 class CPsetContainer
 
    62     initialize();
 
    63     initialize();
 
    63 
    64 
    64     QVERIFY(!m_networkPluginForm);
 
    65     QVERIFY(!m_networkPluginForm);
 
    65     CPsetContainer tmpPsetContainer;
 
    66     CPsetContainer tmpPsetContainer;
 
    66     m_networkWrapper = new PSetNetworkWrapper(tmpPsetContainer);
 
    67     m_networkWrapper = new PSetNetworkWrapper(tmpPsetContainer);
 
    67     expect("PSetWrapper::networkWrapper").returns(m_networkWrapper);
 
    68     EXPECT(PSetWrapper, networkWrapper).returns(m_networkWrapper);
 
    68     expect("PSetNetworkWrapper::isManualNetworkSelectionSupported").returns(true);
 
    69     EXPECT(PSetNetworkWrapper, isManualNetworkSelectionSupported).returns(true);
 
    69     if(i) {
 
    70     if(i) {
 
    70         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
    71         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
    71     } else {
 
    72     } else {
 
    72         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
    73         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
    73     }
 
    74     }
 
    74     i++;
 
    75     i++;
 
    75     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
    76     EXPECT(PSetNetworkWrapper, getNetworkSelectionMode).willOnce(invoke(this, &updateNetworkSelectionMode));
 
    76     m_networkPluginForm = new CpNetworkPluginForm();
 
    77     m_networkPluginForm = new CpNetworkPluginForm();
 
    77     QVERIFY(m_networkPluginForm);
 
    78     QVERIFY(m_networkPluginForm);
 
    78 }
 
    79 }
 
    79 
    80 
    80 
    81 
   112 /*!
 
   113 /*!
 
   113   UT_CpNetworkPluginForm::t_networkModeStateChanged
 
   114   UT_CpNetworkPluginForm::t_networkModeStateChanged
 
   114  */
 
   115  */
 
   115 void UT_CpNetworkPluginForm::t_networkModeStateChanged()
 
   116 void UT_CpNetworkPluginForm::t_networkModeStateChanged()
 
   116 {
 
   117 {
 
   117     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   118     EXPECT(SettingsWrapper, isPhoneOffline).returns(false);
 
   118     m_networkPluginForm->networkModeStateChanged(0);
 
   119     m_networkPluginForm->networkModeStateChanged(0);
 
   119 
   120 
   120     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   121     EXPECT(SettingsWrapper, isPhoneOffline).returns(false);
 
   121     m_networkPluginForm->networkModeStateChanged(1);
 
   122     m_networkPluginForm->networkModeStateChanged(1);
 
   122 
   123 
   123     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   124     EXPECT(SettingsWrapper, isPhoneOffline).returns(false);
 
   124     m_networkPluginForm->networkModeStateChanged(2);
 
   125     m_networkPluginForm->networkModeStateChanged(2);
 
   125     
   126     
   126     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   127     EXPECT(SettingsWrapper, isPhoneOffline).returns(false);
 
   127     m_networkPluginForm->networkModeStateChanged(3);
 
   128     m_networkPluginForm->networkModeStateChanged(3);
 
   128     
   129     
   129     expect("CpSettingsWrapper::isPhoneOffline").returns(true);
 
   130     EXPECT(SettingsWrapper, isPhoneOffline).returns(true);
 
   130     m_networkPluginForm->networkModeStateChanged(0);
 
   131     m_networkPluginForm->networkModeStateChanged(0);
 
   131     
   132     
   132     QVERIFY(verify());
 
   133     QVERIFY(verify());
 
   133 }
 
   134 }
 
   134 
   135 
   135 /*!
 
   136 /*!
 
   136   UT_CpNetworkPluginForm::t_operatorSelectionStateChanged
 
   137   UT_CpNetworkPluginForm::t_operatorSelectionStateChanged
 
   137  */
 
   138  */
 
   138 void UT_CpNetworkPluginForm::t_operatorSelectionStateChanged()
 
   139 void UT_CpNetworkPluginForm::t_operatorSelectionStateChanged()
 
   139 {
 
   140 {
 
   140     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   141     EXPECT(SettingsWrapper, isPhoneOffline).returns(false);
 
   141     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
   142     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
   142     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   143     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   143     m_networkPluginForm->operatorSelectionStateChanged();
 
   144     m_networkPluginForm->operatorSelectionStateChanged();
 
   144 
   145 
   145     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   146     EXPECT(SettingsWrapper, isPhoneOffline).returns(false);
 
   146     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
   147     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
   147     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   148     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   148     m_networkPluginForm->operatorSelectionStateChanged();
 
   149     m_networkPluginForm->operatorSelectionStateChanged();
 
   149     
   150     
   150     expect("CpSettingsWrapper::isPhoneOffline").returns(true);
 
   151     EXPECT(SettingsWrapper, isPhoneOffline).returns(true);
 
   151     m_networkPluginForm->operatorSelectionStateChanged();
 
   152     m_networkPluginForm->operatorSelectionStateChanged();
 
   152     
   153     
   153     QVERIFY(verify());
 
   154     QVERIFY(verify());
 
   154 }
 
   155 }
 
   155 
   156 
   176 {
 
   177 {
 
   177     PSetNetworkWrapper::NetworkInfo temp;
 
   178     PSetNetworkWrapper::NetworkInfo temp;
 
   178     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   179     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   179     networkInfoList.append(&temp);
 
   180     networkInfoList.append(&temp);
 
   180     
   181     
   181     expect("HbDialog::open");
 
   182     EXPECT(HbDialog, open);
 
   182     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
   183     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
   183     
   184     
   184     QVERIFY(verify());
 
   185     QVERIFY(verify());
 
   185 }
 
   186 }
 
   186 
   187 
   189  */
 
   190  */
 
   190 void UT_CpNetworkPluginForm::t_networkReqestFailed()
 
   191 void UT_CpNetworkPluginForm::t_networkReqestFailed()
 
   191 {
 
   192 {
 
   192     PSetNetworkWrapper::ErrorCode error(PSetNetworkWrapper::ErrCauseCallActive);
 
   193     PSetNetworkWrapper::ErrorCode error(PSetNetworkWrapper::ErrCauseCallActive);
 
   193     PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestSetNetworkMode);
 
   194     PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestSetNetworkMode);
 
   194     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   195     EXPECT(PSetNetworkWrapper, getNetworkAccessMode);
 
   195     m_networkPluginForm->networkReqestFailed(error, type);
 
   196     m_networkPluginForm->networkReqestFailed(error, type);
 
   196     
   197     
   197     error = PSetNetworkWrapper::ErrNoNetworkService;
 
   198     error = PSetNetworkWrapper::ErrNoNetworkService;
 
   198     type = PSetNetworkWrapper::RequestSetNetworkMode;
 
   199     type = PSetNetworkWrapper::RequestSetNetworkMode;
 
   199     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   200     EXPECT(PSetNetworkWrapper, getNetworkAccessMode);
 
   200     m_networkPluginForm->networkReqestFailed(error, type);
 
   201     m_networkPluginForm->networkReqestFailed(error, type);
 
   201     
   202     
   202     error = PSetNetworkWrapper::ErrOfflineOpNotAllowed;
 
   203     error = PSetNetworkWrapper::ErrOfflineOpNotAllowed;
 
   203     type = PSetNetworkWrapper::RequestSetNetworkMode;
 
   204     type = PSetNetworkWrapper::RequestSetNetworkMode;
 
   204     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   205     EXPECT(PSetNetworkWrapper, getNetworkAccessMode);
 
   205     m_networkPluginForm->networkReqestFailed(error, type);
 
   206     m_networkPluginForm->networkReqestFailed(error, type);
 
   206     
   207     
   207     PSetNetworkWrapper::NetworkInfo temp;
 
   208     PSetNetworkWrapper::NetworkInfo temp;
 
   208     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   209     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   209     networkInfoList.append(&temp);
 
   210     networkInfoList.append(&temp);
 
   210     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
   211     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
   211     error = PSetNetworkWrapper::ErrNoNetworkAccess;
 
   212     error = PSetNetworkWrapper::ErrNoNetworkAccess;
 
   212     type = PSetNetworkWrapper::RequestSetNetwork;
 
   213     type = PSetNetworkWrapper::RequestSetNetwork;
 
   213     expect("HbDialog::open");
 
   214     EXPECT(HbDialog, open);
 
   214     m_networkPluginForm->networkReqestFailed(error, type);
 
   215     m_networkPluginForm->networkReqestFailed(error, type);
 
   215     
   216     
   216     QVERIFY(verify());
 
   217     QVERIFY(verify());
 
   217 }
 
   218 }
 
   218 
   219 
   220   UT_CpNetworkPluginForm::t_userCancel
 
   221   UT_CpNetworkPluginForm::t_userCancel
 
   221  */
 
   222  */
 
   222 void UT_CpNetworkPluginForm::t_userCancel()
 
   223 void UT_CpNetworkPluginForm::t_userCancel()
 
   223 {
 
   224 {
 
   224     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
   225     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
   225     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   226     EXPECT(PSetNetworkWrapper, getNetworkSelectionMode).willOnce(invoke(this, &updateNetworkSelectionMode));
 
   226     m_networkPluginForm->userCancel();
 
   227     m_networkPluginForm->userCancel();
 
   227     
   228     
   228     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
   229     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
   229     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   230     EXPECT(PSetNetworkWrapper, getNetworkSelectionMode).willOnce(invoke(this, &updateNetworkSelectionMode));
 
   230     m_networkPluginForm->userCancel();
 
   231     m_networkPluginForm->userCancel();
 
   231     
   232     
   232     QVERIFY(verify());
 
   233     QVERIFY(verify());
 
   233 }
 
   234 }
 
   234 
   235 
   277   UT_CpNetworkPluginForm::t_primaryIconForNetwork
 
   278   UT_CpNetworkPluginForm::t_primaryIconForNetwork
 
   278  */
 
   279  */
 
   279 void UT_CpNetworkPluginForm::t_primaryIconForNetwork()
 
   280 void UT_CpNetworkPluginForm::t_primaryIconForNetwork()
 
   280 {
 
   281 {
 
   281     QScopedPointer<PSetWrapper> wrapper(new PSetWrapper()); 
   282     QScopedPointer<PSetWrapper> wrapper(new PSetWrapper()); 
   282     expect("PSetWrapper::networkWrapper").returns(wrapper.data()); 
   283     EXPECT(PSetWrapper, networkWrapper).returns(wrapper.data()); 
   283     
   284     
   284     QScopedPointer<CpNetworkPluginFormAdapter> 
   285     QScopedPointer<CpNetworkPluginFormAdapter> 
   285         formClassAdapter(new CpNetworkPluginFormAdapter());
 
   286         formClassAdapter(new CpNetworkPluginFormAdapter());
 
   286     PSetNetworkWrapper::NetworkInfo currentInfo;
 
   287     PSetNetworkWrapper::NetworkInfo currentInfo;
 
   287     
   288     
   288     // Test: forbidden icon flag ON, mode: GSM, status: forbidden 
   289     // Test: forbidden icon flag ON, mode: GSM, status: forbidden 
   289     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 
   290     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 
   290     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
   291     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
   291     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
   292     EXPECT(SettingsWrapper, forbiddenIconSupported).returns(true); 
   292     QString iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   293     QString iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   293     QCOMPARE(iconName, KIconGsmForbidden); 
   294     QCOMPARE(iconName, KIconGsmForbidden); 
   294     
   295     
   295     // Test: forbidden icon flag ON, mode: GSM, status: available
 
   296     // Test: forbidden icon flag ON, mode: GSM, status: available
 
   296     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 
   297     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 
   297     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
   298     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
   298     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
   299     EXPECT(SettingsWrapper, forbiddenIconSupported).returns(true); 
   299     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   300     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   300     QCOMPARE(iconName, KIconGsmNotForbidden); 
   301     QCOMPARE(iconName, KIconGsmNotForbidden); 
   301     
   302     
   302     // Test: forbidden icon flag ON, mode: WCDMA, status: forbidden 
   303     // Test: forbidden icon flag ON, mode: WCDMA, status: forbidden 
   303     currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 
   304     currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 
   304     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
   305     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
   305     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
   306     EXPECT(SettingsWrapper, forbiddenIconSupported).returns(true); 
   306     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   307     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   307     QCOMPARE(iconName, KIconWcdmaForbidden); 
   308     QCOMPARE(iconName, KIconWcdmaForbidden); 
   308      
   309      
   309     // Test: forbidden icon flag ON, mode: WCDMA, status: available
 
   310     // Test: forbidden icon flag ON, mode: WCDMA, status: available
 
   310     currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 
   311     currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 
   311     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
   312     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
   312     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
   313     EXPECT(SettingsWrapper, forbiddenIconSupported).returns(true); 
   313     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   314     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   314     QCOMPARE(iconName, KIconWcdmaNotForbidden); 
   315     QCOMPARE(iconName, KIconWcdmaNotForbidden); 
   315 
   316 
   316     // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: forbidden 
   317     // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: forbidden 
   317     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 
   318     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 
   318     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
   319     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
   319     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
   320     EXPECT(SettingsWrapper, forbiddenIconSupported).returns(true); 
   320     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   321     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   321     QCOMPARE(iconName, KIconGsmAndWcdmaForbidden); 
   322     QCOMPARE(iconName, KIconGsmAndWcdmaForbidden); 
   322      
   323      
   323     // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: available
 
   324     // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: available
 
   324     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 
   325     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 
   325     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
   326     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
   326     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
   327     EXPECT(SettingsWrapper,forbiddenIconSupported).returns(true); 
   327     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   328     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   328     QCOMPARE(iconName, KIconGsmAndWcdmaNotForbidden); 
   329     QCOMPARE(iconName, KIconGsmAndWcdmaNotForbidden); 
   329     
   330     
   330     // Test: forbidden icon flag OFF
 
   331     // Test: forbidden icon flag OFF
 
   331     expect("CpSettingsWrapper::forbiddenIconSupported").returns(false);
 
   332     EXPECT(SettingsWrapper, forbiddenIconSupported).returns(false);
 
   332     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   333     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
   333     QCOMPARE(iconName, QString("")); 
   334     QCOMPARE(iconName, QString("")); 
   334 }
 
   335 }
 
   335 
   336 
   336 /*!
 
   337 /*!
FCL/sf/app/phone