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
branchGCC_SURGE
changeset 51 f39ed5e045e0
parent 22 6bb1b21d2484
parent 46 bc5a64e5bc3c
equal deleted inserted replaced
40:bab96b7ed1a4 51:f39ed5e045e0 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 #include "ut_networkpluginform.h"
 
    18 #include "ut_networkpluginform.h"
 
    19 #include "qtestmains60ui.h"
 
    19 #include "qtestmains60ui.h"
 
       
    20 #include "cpitemdatahelper.h"
 
       
    21 #include "psetwrapper.h"
 
    20 #define private public
 
    22 #define private public
 
    21 #include "cpnetworkpluginform.h"
 
    23 #include "cpnetworkpluginform.h"
 
    22 #include "cpitemdatahelper.h"
 
    24 
    23 
    25 
    24 class CPsetContainer
 
    26 class CPsetContainer
 
    25 {
 
    27 {
 
    26 public:
 
    28 public:
 
    27     CPsetContainer(){};
 
    29     CPsetContainer(){};
 
    28     ~CPsetContainer(){};
 
    30     ~CPsetContainer(){};
 
    29 };
 
    31 };
 
    30 
    32 
       
    33 const QString KIconGsmForbidden("qtg_small_network_off"); 
       
    34 const QString KIconGsmNotForbidden("qtg_small_network");
 
       
    35 const QString KIconWcdmaForbidden("qtg_small_wcdma_off"); 
       
    36 const QString KIconWcdmaNotForbidden("qtg_small_wcdma");
 
       
    37 const QString KIconGsmAndWcdmaForbidden("qtg_small_pd_wcdma_off"); 
       
    38 const QString KIconGsmAndWcdmaNotForbidden("qtg_small_pd_wcdma");
 
       
    39 
    31 /*!
 
    40 /*!
 
    32   UT_CpNetworkPluginForm::UT_CpNetworkPluginForm
 
    41   UT_CpNetworkPluginForm::UT_CpNetworkPluginForm
 
    33  */
 
    42  */
 
    34 UT_CpNetworkPluginForm::UT_CpNetworkPluginForm() 
    43 UT_CpNetworkPluginForm::UT_CpNetworkPluginForm() 
    35     : m_networkPluginForm(NULL), i(0)
 
    44     : m_networkPluginForm(NULL), i(0)
 
    54 
    63 
    55     QVERIFY(!m_networkPluginForm);
 
    64     QVERIFY(!m_networkPluginForm);
 
    56     CPsetContainer tmpPsetContainer;
 
    65     CPsetContainer tmpPsetContainer;
 
    57     m_networkWrapper = new PSetNetworkWrapper(tmpPsetContainer);
 
    66     m_networkWrapper = new PSetNetworkWrapper(tmpPsetContainer);
 
    58     expect("PSetWrapper::networkWrapper").returns(m_networkWrapper);
 
    67     expect("PSetWrapper::networkWrapper").returns(m_networkWrapper);
 
       
    68     expect("PSetNetworkWrapper::isManualNetworkSelectionSupported").returns(true);
 
    59     if(i) {
 
    69     if(i) {
 
    60         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
    70         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
    61     } else {
 
    71     } else {
 
    62         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
    72         m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
    63     }
 
    73     }
 
    85     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
    95     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
    86         m_networkPluginForm->networkModeStateChanged(3);
 
    96         m_networkPluginForm->networkModeStateChanged(3);
 
    87     
    97     
    88     expect("CpSettingsWrapper::isPhoneOffline").returns(true);
 
    98     expect("CpSettingsWrapper::isPhoneOffline").returns(true);
 
    89     m_networkPluginForm->networkModeStateChanged(0);
 
    99     m_networkPluginForm->networkModeStateChanged(0);
 
       
   100     
       
   101     QVERIFY(verify());
 
    90 }
 
   102 }
 
    91 
   103 
    92 /*!
 
   104 /*!
 
    93   UT_CpNetworkPluginForm::t_operatorSelectionStateChanged
 
   105   UT_CpNetworkPluginForm::t_operatorSelectionStateChanged
 
    94  */
 
   106  */
 
    95 void UT_CpNetworkPluginForm::t_operatorSelectionStateChanged()
 
   107 void UT_CpNetworkPluginForm::t_operatorSelectionStateChanged()
 
    96 {
 
   108 {
 
    97     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   109     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
    98     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
   110     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
    99     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   111     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   100     m_networkPluginForm->operatorSelectionStateChanged(true);
 
   112     m_networkPluginForm->operatorSelectionStateChanged();
 
   101 
   113 
   102     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   114     expect("CpSettingsWrapper::isPhoneOffline").returns(false);
 
   103     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
   115     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeManual;
 
   104     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   116     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   105     m_networkPluginForm->operatorSelectionStateChanged(true);
 
   117     m_networkPluginForm->operatorSelectionStateChanged();
 
   106     
   118     
   107     expect("CpSettingsWrapper::isPhoneOffline").returns(true);
 
   119     expect("CpSettingsWrapper::isPhoneOffline").returns(true);
 
   108     m_networkPluginForm->operatorSelectionStateChanged(true);
 
   120     m_networkPluginForm->operatorSelectionStateChanged();
 
       
   121     
       
   122     QVERIFY(verify());
 
   109 }
 
   123 }
 
   110 
   124 
   111 /*!
 
   125 /*!
 
   112   UT_CpNetworkPluginForm::t_networkAccessModeGot
 
   126   UT_CpNetworkPluginForm::t_networkAccessModeGot
 
   113  */
 
   127  */
 
   114 void UT_CpNetworkPluginForm::t_networkAccessModeGot()
 
   128 void UT_CpNetworkPluginForm::t_networkAccessModeGot()
 
   115 {
 
   129 {
 
   116     expect("CpSettingFormItemData::setContentWidgetData");
 
       
   117     m_networkPluginForm->networkAccessModeGot(0);
 
   130     m_networkPluginForm->networkAccessModeGot(0);
 
   118     
   131 
   119     expect("CpSettingFormItemData::setContentWidgetData");
 
       
   120     m_networkPluginForm->networkAccessModeGot(1);
 
   132     m_networkPluginForm->networkAccessModeGot(1);
 
   121     
   133 
   122     expect("CpSettingFormItemData::setContentWidgetData");
 
       
   123     m_networkPluginForm->networkAccessModeGot(2);
 
   134     m_networkPluginForm->networkAccessModeGot(2);
 
   124     
   135     
   125     m_networkPluginForm->networkAccessModeGot(3);
 
   136     m_networkPluginForm->networkAccessModeGot(3);
 
       
   137     
       
   138     QVERIFY(verify());
 
   126 }
 
   139 }
 
   127 
   140 
   128 /*!
 
   141 /*!
 
   129   UT_CpNetworkPluginForm::t_availableNetworksGot
 
   142   UT_CpNetworkPluginForm::t_availableNetworksGot
 
   130  */
 
   143  */
 
   132 {
 
   145 {
 
   133     PSetNetworkWrapper::NetworkInfo temp;
 
   146     PSetNetworkWrapper::NetworkInfo temp;
 
   134     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   147     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   135     networkInfoList.append(&temp);
 
   148     networkInfoList.append(&temp);
 
   136     
   149     
   137     expect("HbDialog::exec");
 
   150     expect("HbDialog::open");
 
   138     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
   151     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
       
   152     
       
   153     QVERIFY(verify());
 
   139 }
 
   154 }
 
   140 
   155 
   141 /*!
 
   156 /*!
 
   142   UT_CpNetworkPluginForm::t_networkReqestFailed
 
   157   UT_CpNetworkPluginForm::t_networkReqestFailed
 
   143  */
 
   158  */
 
   147     PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestSetNetworkMode);
 
   162     PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestSetNetworkMode);
 
   148     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   163     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   149     m_networkPluginForm->networkReqestFailed(error, type);
 
   164     m_networkPluginForm->networkReqestFailed(error, type);
 
   150     
   165     
   151     error = PSetNetworkWrapper::ErrNoNetworkService;
 
   166     error = PSetNetworkWrapper::ErrNoNetworkService;
 
   152     type = PSetNetworkWrapper::RequestSetNetwork;
 
   167     type = PSetNetworkWrapper::RequestSetNetworkMode;
 
   153     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   168     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   154     expect("CpSettingFormItemData::setContentWidgetData");
 
       
   155     m_networkPluginForm->networkReqestFailed(error, type);
 
   169     m_networkPluginForm->networkReqestFailed(error, type);
 
   156     
   170     
   157     error = PSetNetworkWrapper::ErrOfflineOpNotAllowed;
 
   171     error = PSetNetworkWrapper::ErrOfflineOpNotAllowed;
 
   158     type = PSetNetworkWrapper::RequestSetNetwork;
 
   172     type = PSetNetworkWrapper::RequestSetNetworkMode;
 
   159     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   173     expect("PSetNetworkWrapper::getNetworkAccessMode");
 
   160     expect("CpSettingFormItemData::setContentWidgetData");
 
       
   161     m_networkPluginForm->networkReqestFailed(error, type);
 
   174     m_networkPluginForm->networkReqestFailed(error, type);
 
   162     
   175     
   163     PSetNetworkWrapper::NetworkInfo temp;
 
   176     PSetNetworkWrapper::NetworkInfo temp;
 
   164     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   177     QList<PSetNetworkWrapper::NetworkInfo*> networkInfoList;
 
   165     networkInfoList.append(&temp);
 
   178     networkInfoList.append(&temp);
 
   166     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
   179     m_networkPluginForm->availableNetworksGot(networkInfoList);
 
   167     error = PSetNetworkWrapper::ErrNoNetworkAccess;
 
   180     error = PSetNetworkWrapper::ErrNoNetworkAccess;
 
   168     type = PSetNetworkWrapper::RequestSetNetwork;
 
   181     type = PSetNetworkWrapper::RequestSetNetwork;
 
   169     expect("HbDialog::exec");
 
   182     expect("HbDialog::open");
 
   170     m_networkPluginForm->networkReqestFailed(error, type);
 
   183     m_networkPluginForm->networkReqestFailed(error, type);
 
       
   184     
       
   185     QVERIFY(verify());
 
   171 }
 
   186 }
 
   172 
   187 
   173 /*!
 
   188 /*!
 
   174   UT_CpNetworkPluginForm::t_userCancel
 
   189   UT_CpNetworkPluginForm::t_userCancel
 
   175  */
 
   190  */
 
   180     m_networkPluginForm->userCancel();
 
   195     m_networkPluginForm->userCancel();
 
   181     
   196     
   182     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
   197     m_NetworkSelectionMode = PSetNetworkWrapper::SelectionModeAutomatic;
 
   183     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   198     expect("PSetNetworkWrapper::getNetworkSelectionMode").willOnce(invoke(this, &updateNetworkSelectionMode));
 
   184     m_networkPluginForm->userCancel();
 
   199     m_networkPluginForm->userCancel();
 
       
   200     
       
   201     QVERIFY(verify());
 
   185 }
 
   202 }
 
   186 
   203 
   187 /*!
 
   204 /*!
 
   188   UT_CpNetworkPluginForm::t_handleSearchingNetworks
 
   205   UT_CpNetworkPluginForm::t_handleSearchingNetworks
 
   189  */
 
   206  */
 
   192     PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestNone);
 
   209     PSetNetworkWrapper::RequestType type(PSetNetworkWrapper::RequestNone);
 
   193     m_networkPluginForm->handleSearchingNetworks(type);
 
   210     m_networkPluginForm->handleSearchingNetworks(type);
 
   194     
   211     
   195     type = PSetNetworkWrapper::RequestEnumerateNetworks;
 
   212     type = PSetNetworkWrapper::RequestEnumerateNetworks;
 
   196     m_networkPluginForm->handleSearchingNetworks(type);
 
   213     m_networkPluginForm->handleSearchingNetworks(type);
 
       
   214     
       
   215     QVERIFY(verify());
 
   197 }
 
   216 }
 
   198 
   217 
   199 /*!
 
   218 /*!
 
   200   UT_CpNetworkPluginForm::t_handleRequestingSelectedNetwork
 
   219   UT_CpNetworkPluginForm::t_handleRequestingSelectedNetwork
 
   201  */
 
   220  */
 
   222     currentInfo.m_shortName = "test";
 
   241     currentInfo.m_shortName = "test";
 
   223     m_networkPluginForm->handleNetworkChanged(currentInfo, status);
 
   242     m_networkPluginForm->handleNetworkChanged(currentInfo, status);
 
   224 }
 
   243 }
 
   225     
   244     
   226 /*!
 
   245 /*!
 
       
   246   UT_CpNetworkPluginForm::t_primaryIconForNetwork
 
       
   247  */
 
       
   248 void UT_CpNetworkPluginForm::t_primaryIconForNetwork()
 
       
   249 {
 
       
   250     QScopedPointer<PSetWrapper> wrapper(new PSetWrapper()); 
       
   251     expect("PSetWrapper::networkWrapper").returns(wrapper.data()); 
       
   252     
       
   253     QScopedPointer<CpNetworkPluginFormAdapter> 
       
   254         formClassAdapter(new CpNetworkPluginFormAdapter());
 
       
   255     PSetNetworkWrapper::NetworkInfo currentInfo;
 
       
   256     
       
   257     // Test: forbidden icon flag ON, mode: GSM, status: forbidden 
       
   258     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 
       
   259     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
       
   260     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
       
   261     QString iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
       
   262     QCOMPARE(iconName, KIconGsmForbidden); 
       
   263     
       
   264     // Test: forbidden icon flag ON, mode: GSM, status: available
 
       
   265     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsm; 
       
   266     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
       
   267     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
       
   268     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
       
   269     QCOMPARE(iconName, KIconGsmNotForbidden); 
       
   270     
       
   271     // Test: forbidden icon flag ON, mode: WCDMA, status: forbidden 
       
   272     currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 
       
   273     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
       
   274     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
       
   275     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
       
   276     QCOMPARE(iconName, KIconWcdmaForbidden); 
       
   277      
       
   278     // Test: forbidden icon flag ON, mode: WCDMA, status: available
 
       
   279     currentInfo.m_access = PSetNetworkWrapper::AccessTypeWcdma; 
       
   280     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
       
   281     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
       
   282     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
       
   283     QCOMPARE(iconName, KIconWcdmaNotForbidden); 
       
   284 
       
   285     // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: forbidden 
       
   286     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 
       
   287     currentInfo.m_status = PSetNetworkWrapper::StatusForbidden; 
       
   288     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
       
   289     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
       
   290     QCOMPARE(iconName, KIconGsmAndWcdmaForbidden); 
       
   291      
       
   292     // Test: forbidden icon flag ON, mode: GSM and WCDMA, status: available
 
       
   293     currentInfo.m_access = PSetNetworkWrapper::AccessTypeGsmAndWcdma; 
       
   294     currentInfo.m_status = PSetNetworkWrapper::StatusAvailable; 
       
   295     expect("CpSettingsWrapper::forbiddenIconSupported").returns(true); 
       
   296     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
       
   297     QCOMPARE(iconName, KIconGsmAndWcdmaNotForbidden); 
       
   298     
       
   299     // Test: forbidden icon flag OFF
 
       
   300     expect("CpSettingsWrapper::forbiddenIconSupported").returns(false);
 
       
   301     iconName = formClassAdapter->primaryIconForNetwork(currentInfo);
 
       
   302     QCOMPARE(iconName, QString("")); 
       
   303 }
 
       
   304 
       
   305 /*!
 
   227   UT_CpNetworkPluginForm::cleanup
 
   306   UT_CpNetworkPluginForm::cleanup
 
   228  */
 
   307  */
 
   229 void UT_CpNetworkPluginForm::cleanup()
 
   308 void UT_CpNetworkPluginForm::cleanup()
 
   230 {
 
   309 {
 
   231     reset();
 
   310     reset();
 
   232     
   311     delete m_networkPluginForm;
 
       
   312     m_networkPluginForm = NULL;
 
   233     delete m_networkWrapper;
 
   313     delete m_networkWrapper;
 
   234     m_networkWrapper = NULL;
 
   314     m_networkWrapper = NULL;
 
   235     delete m_networkPluginForm;
 
       
   236     m_networkPluginForm = NULL;
 
       
   237 }
 
   315 }
 
   238 
   316 
   239 /*!
 
   317 /*!
 
   240   UT_CpNetworkPluginForm::t_memleak
 
   318   UT_CpNetworkPluginForm::t_memleak
 
   241  */
 
   319  */
 
   251     PSetNetworkWrapper::NetworkSelectionMode& mode)
 
   329     PSetNetworkWrapper::NetworkSelectionMode& mode)
 
   252 {
 
   330 {
 
   253     mode = m_NetworkSelectionMode;
 
   331     mode = m_NetworkSelectionMode;
 
   254 }
 
   332 }
 
   255 
   333 
       
   334 
   256 QTEST_MAIN_S60UI(UT_CpNetworkPluginForm)
 
   335 QTEST_MAIN_S60UI(UT_CpNetworkPluginForm)
FCL/sf/app/phone