14 * Description: |
14 * Description: |
15 * |
15 * |
16 */ |
16 */ |
17 |
17 |
18 #include <PsetContainer.h> |
18 #include <PsetContainer.h> |
19 #include <MPsetNetworkInfoObs.h> |
19 #include <mpsetnetworkinfoobs.h> |
|
20 #include <gsmerror.h> |
20 #include "ut_psetnetworkwrapper.h" |
21 #include "ut_psetnetworkwrapper.h" |
21 #include "testutilities.h" |
22 #include "testutilities.h" |
22 #define private public |
23 #define private public |
23 #include "psetnetworkwrapper.h" |
24 #include "psetnetworkwrapper.h" |
24 #include "psetnetworkwrapper_p.h" |
25 #include "psetnetworkwrapper_p.h" |
154 m_psetNetworkMock = NULL; |
160 m_psetNetworkMock = NULL; |
155 m_psetNetworkModeMock = NULL; |
161 m_psetNetworkModeMock = NULL; |
156 } |
162 } |
157 |
163 |
158 /*! |
164 /*! |
|
165 UT_PSetNetworkWrapper::t_construction |
|
166 */ |
|
167 void UT_PSetNetworkWrapper::t_construction() |
|
168 { |
|
169 if (qstrcmp(QTest::currentTestFunction(), "t_exceptionSafety") != 0) { |
|
170 |
|
171 expect("CPsetContainer::CreateNetworkObjectL"). |
|
172 willOnce(invokeWithoutArguments(SimulateLeaveL)); |
|
173 PSetNetworkWrapper *wrapper = NULL; |
|
174 EXPECT_EXCEPTION( |
|
175 wrapper = new PSetNetworkWrapper(*m_psetContainerMock, NULL); |
|
176 delete wrapper; |
|
177 wrapper = NULL; |
|
178 ) |
|
179 QVERIFY(verify()); |
|
180 |
|
181 expect("CPsetContainer::CreateNetworkModeObjectL"). |
|
182 willOnce(invokeWithoutArguments(SimulateLeaveL)); |
|
183 EXPECT_EXCEPTION( |
|
184 wrapper = new PSetNetworkWrapper(*m_psetContainerMock, NULL); |
|
185 delete wrapper; |
|
186 wrapper = NULL; |
|
187 ) |
|
188 QVERIFY(verify()); |
|
189 } |
|
190 } |
|
191 |
|
192 /*! |
159 UT_PSetNetworkWrapper::t_getAvailableNetworks |
193 UT_PSetNetworkWrapper::t_getAvailableNetworks |
160 */ |
194 */ |
161 void UT_PSetNetworkWrapper::t_getAvailableNetworks() |
195 void UT_PSetNetworkWrapper::t_getAvailableNetworks() |
162 { |
196 { |
163 expect("CPsetNetwork::GetAvailableNetworksL"); |
197 expect("CPsetNetwork::GetAvailableNetworksL") |
164 |
198 .willOnce(invokeWithoutArguments(SimulateLeaveL)); |
165 m_wrapper->getAvailableNetworks(); |
199 |
166 |
200 EXPECT_EXCEPTION( |
167 QVERIFY(true == verify()); |
201 m_wrapper->getAvailableNetworks(); |
|
202 ) |
|
203 |
|
204 QVERIFY(verify()); |
168 } |
205 } |
169 |
206 |
170 |
207 |
171 /*! |
208 /*! |
172 UT_PSetNetworkWrapper::t_getNetworkSelectionMode |
209 UT_PSetNetworkWrapper::t_getNetworkSelectionMode |
194 /*! |
231 /*! |
195 UT_PSetNetworkWrapper::t_selectNetwork |
232 UT_PSetNetworkWrapper::t_selectNetwork |
196 */ |
233 */ |
197 void UT_PSetNetworkWrapper::t_selectNetwork() |
234 void UT_PSetNetworkWrapper::t_selectNetwork() |
198 { |
235 { |
199 expect("CPsetNetwork::SelectNetworkL"); |
236 expect("CPsetNetwork::SelectNetworkL") |
200 |
237 .willOnce(invokeWithoutArguments(SimulateLeaveL)); |
|
238 |
201 PSetNetworkWrapper::NetworkInfo info; |
239 PSetNetworkWrapper::NetworkInfo info; |
202 m_wrapper->selectNetwork(info); |
240 EXPECT_EXCEPTION( |
|
241 m_wrapper->selectNetwork(info); |
|
242 ) |
203 |
243 |
204 QVERIFY(true == verify()); |
244 QVERIFY(true == verify()); |
205 } |
245 } |
206 |
246 |
207 /*! |
247 /*! |
235 { |
278 { |
236 expect("CPsetNetwork::SetNetworkModeSelectionL"). |
279 expect("CPsetNetwork::SetNetworkModeSelectionL"). |
237 with(RMmCustomAPI::KCapsNetworkModeDual); |
280 with(RMmCustomAPI::KCapsNetworkModeDual); |
238 expect("CPsetNetwork::SetNetworkModeSelectionL"). |
281 expect("CPsetNetwork::SetNetworkModeSelectionL"). |
239 with(RMmCustomAPI::KCapsNetworkModeUmts); |
282 with(RMmCustomAPI::KCapsNetworkModeUmts); |
240 expect("CPsetNetwork::SetNetworkModeSelectionL"). |
283 expect("CPsetNetwork::SetNetworkModeSelectionL") |
241 with(RMmCustomAPI::KCapsNetworkModeGsm); |
284 .with(RMmCustomAPI::KCapsNetworkModeGsm) |
|
285 .willOnce(invokeWithoutArguments(SimulateLeaveL)); |
242 |
286 |
243 m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeDual); |
287 m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeDual); |
244 m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeUmts); |
288 m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeUmts); |
245 m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeGsm); |
289 EXPECT_EXCEPTION( |
|
290 m_wrapper->setNetworkAccessMode(PSetNetworkWrapper::AccessModeGsm); |
|
291 ) |
246 |
292 |
247 const int invalidMode = -1; |
293 const int invalidMode = -1; |
248 m_wrapper->setNetworkAccessMode( |
294 m_wrapper->setNetworkAccessMode( |
249 reinterpret_cast<const PSetNetworkWrapper::NetworkAccessMode&> |
295 reinterpret_cast<const PSetNetworkWrapper::NetworkAccessMode&> |
250 (invalidMode)); |
296 (invalidMode)); |
261 |
307 |
262 TRAPD(result, m_wrapper->m_privateImpl-> |
308 TRAPD(result, m_wrapper->m_privateImpl-> |
263 HandleNetworkInfoReceivedL(infos, KErrNone)); |
309 HandleNetworkInfoReceivedL(infos, KErrNone)); |
264 QVERIFY(KErrArgument == result); |
310 QVERIFY(KErrArgument == result); |
265 |
311 |
266 infos = reinterpret_cast<CNetworkInfoArray*>(this); |
312 const TInt KGranularity = 2; |
|
313 infos = new CNetworkInfoArray(KGranularity); |
|
314 QScopedPointer<CNetworkInfoArray> infoArrayGuard(infos); |
|
315 MPsetNetworkSelect::TNetworkInfo info1; |
|
316 MPsetNetworkSelect::TNetworkInfo info2; |
|
317 infos->AppendL(info1); |
|
318 infos->AppendL(info2); |
267 TRAP(result, m_wrapper->m_privateImpl-> |
319 TRAP(result, m_wrapper->m_privateImpl-> |
268 HandleNetworkInfoReceivedL(infos, KErrNone)); |
320 HandleNetworkInfoReceivedL(infos, KErrNone)); |
269 QVERIFY(KErrNone == result); |
321 QVERIFY(KErrNone == result); |
270 } |
322 } |
271 |
323 |
335 } |
387 } |
336 |
388 |
337 /*! |
389 /*! |
338 UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver |
390 UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver |
339 */ |
391 */ |
|
392 Q_DECLARE_METATYPE(PSetNetworkWrapper::RequestType) |
|
393 Q_DECLARE_METATYPE(PSetNetworkWrapper::ErrorCode) |
340 void UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver() |
394 void UT_PSetNetworkWrapper::t_handleNetworkErrorFromInfoObserver() |
341 { |
395 { |
|
396 qRegisterMetaType<PSetNetworkWrapper::RequestType> |
|
397 ("PSetNetworkWrapper::RequestType"); |
|
398 qRegisterMetaType<PSetNetworkWrapper::ErrorCode> |
|
399 ("PSetNetworkWrapper::ErrorCode"); |
|
400 QSignalSpy spy(m_wrapper, SIGNAL(networkReqestFailed( |
|
401 PSetNetworkWrapper::ErrorCode, PSetNetworkWrapper::RequestType))); |
|
402 |
342 MPsetNetworkInfoObserver::TServiceRequest request = |
403 MPsetNetworkInfoObserver::TServiceRequest request = |
343 MPsetNetworkInfoObserver::EServiceRequestNone; |
404 MPsetNetworkInfoObserver::EServiceRequestNone; |
344 QT_TRAP_THROWING(m_wrapper->m_privateImpl-> |
405 QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL( |
345 HandleNetworkErrorL(request, KErrNone)); |
406 request, KErrGsmNetCauseCallActive)); |
|
407 QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL( |
|
408 request, KErrGsm0707NoNetworkService)); |
|
409 QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL( |
|
410 request, KErrGsmOfflineOpNotAllowed)); |
|
411 QT_TRAP_THROWING(m_wrapper->m_privateImpl->HandleNetworkErrorL( |
|
412 request, KErrGeneral)); |
|
413 |
|
414 QCOMPARE(spy.count(), 4); |
|
415 QVERIFY(PSetNetworkWrapper::ErrCauseCallActive == |
|
416 qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(0).at(0))); |
|
417 QVERIFY(PSetNetworkWrapper::ErrNoNetworkService == |
|
418 qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(1).at(0))); |
|
419 QVERIFY(PSetNetworkWrapper::ErrOfflineOpNotAllowed == |
|
420 qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(2).at(0))); |
|
421 QVERIFY(PSetNetworkWrapper::ErrNoNetworkAccess == |
|
422 qvariant_cast<PSetNetworkWrapper::ErrorCode>(spy.at(3).at(0))); |
346 } |
423 } |
347 |
424 |
348 |
425 |
349 /*! |
426 /*! |
350 UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents |
427 UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents |
351 */ |
428 */ |
352 Q_DECLARE_METATYPE(PSetNetworkWrapper::NetworkAccessMode) |
|
353 void UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents() |
429 void UT_PSetNetworkWrapper::t_handleNetworkSystemModeEvents() |
354 { |
430 { |
355 qRegisterMetaType<PSetNetworkWrapper::NetworkAccessMode> |
431 QSignalSpy spy(m_wrapper, SIGNAL(networkAccessModeGot(int))); |
356 ("PSetNetworkWrapper::NetworkAccessMode"); |
|
357 QSignalSpy spy(m_wrapper, |
|
358 SIGNAL(networkAccessModeGot(PSetNetworkWrapper::NetworkAccessMode))); |
|
359 |
432 |
360 MPsetNetworkModeObserver::TServiceRequest serviceRequest = |
433 MPsetNetworkModeObserver::TServiceRequest serviceRequest = |
361 MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode; |
434 MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode; |
362 RMmCustomAPI::TNetworkModeCaps modeCaps = |
435 RMmCustomAPI::TNetworkModeCaps modeCaps = |
363 RMmCustomAPI::KCapsNetworkModeDual; |
436 RMmCustomAPI::KCapsNetworkModeDual; |
373 m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL( |
446 m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL( |
374 serviceRequest, modeCaps)); |
447 serviceRequest, modeCaps)); |
375 |
448 |
376 QCOMPARE(spy.count(), 3); |
449 QCOMPARE(spy.count(), 3); |
377 const QList<QVariant> &arguments0 = spy.at(0); |
450 const QList<QVariant> &arguments0 = spy.at(0); |
378 QVERIFY(PSetNetworkWrapper::AccessModeDual |
451 QVERIFY(PSetNetworkWrapper::AccessModeDual == arguments0.at(0).toInt()); |
379 == arguments0.at(0).value<PSetNetworkWrapper::NetworkAccessMode>()); |
|
380 const QList<QVariant> &arguments1 = spy.at(1); |
452 const QList<QVariant> &arguments1 = spy.at(1); |
381 QVERIFY(PSetNetworkWrapper::AccessModeUmts |
453 QVERIFY(PSetNetworkWrapper::AccessModeUmts == arguments1.at(0).toInt()); |
382 == arguments1.at(0).value<PSetNetworkWrapper::NetworkAccessMode>()); |
|
383 const QList<QVariant> &arguments2 = spy.at(2); |
454 const QList<QVariant> &arguments2 = spy.at(2); |
384 QVERIFY(PSetNetworkWrapper::AccessModeGsm |
455 QVERIFY(PSetNetworkWrapper::AccessModeGsm == arguments2.at(0).toInt()); |
385 == arguments2.at(0).value<PSetNetworkWrapper::NetworkAccessMode>()); |
|
386 |
456 |
387 // TODO: test skeleton for switch cases not yet implemented |
457 // TODO: test skeleton for switch cases not yet implemented |
388 serviceRequest = MPsetNetworkModeObserver::EServiceRequestNone; |
458 serviceRequest = MPsetNetworkModeObserver::EServiceRequestNone; |
389 QT_TRAP_THROWING( |
459 QT_TRAP_THROWING( |
390 m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL( |
460 m_wrapper->m_privateImpl->HandleNetworkSystemModeEventsL( |