| branch | GCC_SURGE |
| changeset 49 | faa5ef4f80da |
| parent 47 | cb7afde124a3 |
| 39:f10336de0cd6 | 49:faa5ef4f80da |
|---|---|
22 #include <HbRadioButtonList> |
22 #include <HbRadioButtonList> |
23 #include <HbAction> |
23 #include <HbAction> |
24 #include <HbDataForm> |
24 #include <HbDataForm> |
25 #include <HbDataFormModel> |
25 #include <HbDataFormModel> |
26 #include <HbDataFormModelItem> |
26 #include <HbDataFormModelItem> |
27 #include <HbDataFormViewItem> |
|
28 #include <HbModelIterator> |
|
29 #include <HbComboBox> |
|
27 #include <QtTest/QtTest> |
30 #include <QtTest/QtTest> |
31 #include <etelpckt.h> |
|
28 #include <cpbearerapplugininterface.h> |
32 #include <cpbearerapplugininterface.h> |
29 #include <cmmanager_shim.h> |
33 #include <cmmanager_shim.h> |
30 #include <cmconnectionmethod_shim.h> |
34 #include <cmconnectionmethod_shim.h> |
31 |
35 |
32 #include "cppacketdataapview.h" |
36 #include "cppacketdataapview.h" |
37 #include "cppacketdataapadvancedview.h" |
|
33 |
38 |
34 #include "hbautotest.h" |
39 #include "hbautotest.h" |
35 #include "testcppacketdataapplugin.h" |
40 #include "testcppacketdataapplugin.h" |
36 |
41 |
37 // ----------------------------------------------------------------------------- |
42 // ----------------------------------------------------------------------------- |
48 |
53 |
49 // Time to wait before continuing after an UI step |
54 // Time to wait before continuing after an UI step |
50 static const int waitTime = 10; |
55 static const int waitTime = 10; |
51 |
56 |
52 // UI coordinates |
57 // UI coordinates |
53 static const QPoint sideTop(350, 60); |
58 static const QPoint scrollMiddle(350, 280); |
54 static const QPoint scrollStart(350, 300); |
59 static const QPoint scrollTop(350, 30); |
55 static const QPoint scrollStop(350, 240); |
60 static const QPoint scrollBottom(350, 540); |
56 |
61 |
57 static const QPoint messageBoxOkButton(170, 320); |
62 // Use positive offset if dropdown opens under the combobox |
58 |
63 static const QPoint comboBoxFirstItemOffset(80, 75); |
59 // These are measured when view is scrolled to top |
64 static const QPoint comboBoxItemOffset(0, 51); |
60 static const QPoint connectionNameLineEdit(330, 110); |
65 // Use negative offset if dropdown opens above the combobox |
61 |
66 static const QPoint comboBoxFirstItemNegativeOffset(80, -29); |
62 static const QPoint accessPointNameLineEdit(330, 190); |
67 static const QPoint comboBoxItemNegativeOffset(0, -51); |
63 |
68 |
64 static const QPoint userNameLineEdit(330, 265); |
69 static const QPoint exitEditorOffset(-10, -20); |
65 |
70 |
66 // These are measured when view is scrolled to bottom |
71 static const QPoint messageBoxOkButtonOffset(160, 140); |
67 static const QPoint passwordPromptCheckbox(50, 295); |
72 |
68 static const QPoint passwordLineEdit(330, 380); |
73 // Advanced settings groups |
69 |
74 static const QPoint ipGroup(160, 10); |
70 static const QPoint authenticationComboBox(175, 470); |
75 static const QPoint proxyGroup(160, 60); |
71 static const QPoint authenticationSecure(100, 420); |
76 |
72 static const QPoint authenticationNormal(100, 365); |
77 // Test strings |
73 |
78 static const QString tooLongUserName = |
74 static const QPoint homepageLineEdit(330, 555); |
79 "too long name 123456789012345678901234567890123456THISISEXTRA"; |
80 static const QString truncatedUserName = |
|
81 "too long name 123456789012345678901234567890123456"; |
|
75 |
82 |
76 // ----------------------------------------------------------------------------- |
83 // ----------------------------------------------------------------------------- |
77 // FRAMEWORK FUNCTIONS |
84 // FRAMEWORK FUNCTIONS |
78 // ----------------------------------------------------------------------------- |
85 // ----------------------------------------------------------------------------- |
79 |
86 |
109 //mMainWindow = new HbMainWindow; |
116 //mMainWindow = new HbMainWindow; |
110 mMainWindow->show(); |
117 mMainWindow->show(); |
111 |
118 |
112 // Load plugin |
119 // Load plugin |
113 QDir dir(pluginDir); |
120 QDir dir(pluginDir); |
114 QPluginLoader loader(dir.absoluteFilePath(pluginName)); |
121 mPluginLoader = new QPluginLoader(dir.absoluteFilePath(pluginName)); |
115 mPlugin = qobject_cast<CpBearerApPluginInterface *>(loader.instance()); |
122 mPlugin = qobject_cast<CpBearerApPluginInterface *>(mPluginLoader->instance()); |
116 QVERIFY(mPlugin != NULL); |
123 QVERIFY(mPlugin != NULL); |
117 |
124 |
118 // Verify plugin bearer type |
125 // Verify plugin bearer type |
119 QVERIFY(mPlugin->bearerType() == CMManagerShim::BearerTypePacketData); |
126 QVERIFY(mPlugin->bearerType() == CMManagerShim::BearerTypePacketData); |
120 |
127 |
128 // Write initial settings to CommsDat |
|
129 subInitializeCommsDat(); |
|
130 |
|
121 // Create packet data settings view (connection method ID given) |
131 // Create packet data settings view (connection method ID given) |
122 subCreateSettingsView(testApId); |
132 subCreateSettingsView(testApId); |
133 |
|
134 subGetUiWidgets(); |
|
123 } |
135 } |
124 |
136 |
125 /** |
137 /** |
126 * This function is be called after the last test case was executed. |
138 * This function is be called after the last test case was executed. |
127 */ |
139 */ |
128 void TestCpPacketDataApPlugin::cleanupTestCase() |
140 void TestCpPacketDataApPlugin::cleanupTestCase() |
129 { |
141 { |
130 delete mMainWindow; |
142 delete mMainWindow; |
131 mMainWindow = 0; |
143 mMainWindow = 0; |
144 |
|
145 // Force unloading of plugin |
|
146 mPluginLoader->unload(); |
|
147 delete mPluginLoader; |
|
148 mPluginLoader = 0; |
|
132 } |
149 } |
133 |
150 |
134 /** |
151 /** |
135 * This function is be called before each test case is executed. |
152 * This function is be called before each test case is executed. |
136 */ |
153 */ |
156 void TestCpPacketDataApPlugin::tcChangeConnectionName() |
173 void TestCpPacketDataApPlugin::tcChangeConnectionName() |
157 { |
174 { |
158 QFETCH(QString, string); |
175 QFETCH(QString, string); |
159 QFETCH(QString, result); |
176 QFETCH(QString, result); |
160 |
177 |
161 HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLineEdit); |
178 HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget); |
162 |
179 |
163 // Erase old string |
180 // Erase old string |
164 subClearLineEdit(CMManagerShim::CmNameLength); |
181 QString text = mTestView->mConnectionNameItem->contentWidgetData("text").toString(); |
182 subClearLineEdit(text.size()); |
|
165 |
183 |
166 // Enter new string |
184 // Enter new string |
167 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
185 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
168 |
186 |
169 HbAutoTest::mouseClick(mMainWindow, mTestView, sideTop); |
187 HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget, exitEditorOffset); |
170 |
188 |
171 // Verify both commsdat and UI widget |
189 // Verify both commsdat and UI widget |
172 subVerifyString( |
190 subVerifyString( |
173 CMManagerShim::CmName, |
191 CMManagerShim::CmName, |
174 mTestView->mConnectionNameItem, |
192 mTestView->mConnectionNameItem, |
182 { |
200 { |
183 QTest::addColumn<QString>("string"); |
201 QTest::addColumn<QString>("string"); |
184 QTest::addColumn<QString>("result"); |
202 QTest::addColumn<QString>("result"); |
185 |
203 |
186 QTest::newRow("maximum length") |
204 QTest::newRow("maximum length") |
187 << "really long name 1234567890123" |
205 << "really long name 123456789012345678901234567890123" |
188 << "really long name 1234567890123"; |
206 << "really long name 123456789012345678901234567890123"; |
189 QTest::newRow("too long") |
207 QTest::newRow("too long") |
190 << "too long name 123456789012345678901234567890" |
208 << "too long name 12345678901234567890123456789012345678901234" |
191 << "too long name 1234567890123456"; |
209 << "too long name 123456789012345678901234567890123456"; |
192 QTest::newRow("basic") // last one must always fit on one line in UI |
210 QTest::newRow("basic") // last one must always fit on one line in UI |
193 << "test packet AP" |
211 << "test packet AP" |
194 << "test packet AP"; |
212 << "test packet AP"; |
195 } |
213 } |
196 |
214 |
200 void TestCpPacketDataApPlugin::tcConnectionNameEmpty() |
218 void TestCpPacketDataApPlugin::tcConnectionNameEmpty() |
201 { |
219 { |
202 QString previous = |
220 QString previous = |
203 mTestView->mConnectionNameItem->contentWidgetData("text").toString(); |
221 mTestView->mConnectionNameItem->contentWidgetData("text").toString(); |
204 |
222 |
205 HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLineEdit); |
223 HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget); |
206 |
224 |
207 // Erase old string |
225 // Erase old string |
208 subClearLineEdit(CMManagerShim::CmNameLength); |
226 QString text = mTestView->mConnectionNameItem->contentWidgetData("text").toString(); |
209 |
227 subClearLineEdit(text.size()); |
210 HbAutoTest::mouseClick(mMainWindow, mTestView, sideTop); |
228 |
229 HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget, exitEditorOffset); |
|
211 |
230 |
212 QTest::qWait(100); |
231 QTest::qWait(100); |
213 // Dismiss messagebox |
232 // Dismiss messagebox |
214 HbAutoTest::mouseClick(mMainWindow, mTestView, messageBoxOkButton); |
233 HbAutoTest::mouseClick( |
234 mMainWindow, |
|
235 mTestView->mMessageBox.data(), |
|
236 messageBoxOkButtonOffset); |
|
215 |
237 |
216 // Verify both commsdat and UI widget |
238 // Verify both commsdat and UI widget |
217 subVerifyString( |
239 subVerifyString( |
218 CMManagerShim::CmName, |
240 CMManagerShim::CmName, |
219 mTestView->mConnectionNameItem, |
241 mTestView->mConnectionNameItem, |
226 void TestCpPacketDataApPlugin::tcChangeAccessPointName() |
248 void TestCpPacketDataApPlugin::tcChangeAccessPointName() |
227 { |
249 { |
228 QFETCH(QString, string); |
250 QFETCH(QString, string); |
229 QFETCH(QString, result); |
251 QFETCH(QString, result); |
230 |
252 |
231 HbAutoTest::mouseClick(mMainWindow, mTestView, accessPointNameLineEdit); |
253 HbAutoTest::mouseClick(mMainWindow, mAccessPointNameWidget); |
232 |
254 |
233 // Erase old string |
255 // Erase old string |
234 subClearLineEdit(CMManagerShim::PacketDataAPNameLength); |
256 QString text = mTestView->mAccessPointNameItem->contentWidgetData("text").toString(); |
257 subClearLineEdit(text.size()); |
|
235 |
258 |
236 // Enter new string |
259 // Enter new string |
237 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
260 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
238 |
261 |
239 HbAutoTest::mouseClick(mMainWindow, mTestView, sideTop); |
262 HbAutoTest::mouseClick(mMainWindow, mAccessPointNameWidget, exitEditorOffset); |
240 |
263 |
241 // Verify both commsdat and UI widget |
264 // Verify both commsdat and UI widget |
242 subVerifyString( |
265 subVerifyString( |
243 CMManagerShim::PacketDataAPName, |
266 CMManagerShim::PacketDataAPName, |
244 mTestView->mAccessPointNameItem, |
267 mTestView->mAccessPointNameItem, |
270 void TestCpPacketDataApPlugin::tcAccessPointNameEmpty() |
293 void TestCpPacketDataApPlugin::tcAccessPointNameEmpty() |
271 { |
294 { |
272 QString previous = |
295 QString previous = |
273 mTestView->mAccessPointNameItem->contentWidgetData("text").toString(); |
296 mTestView->mAccessPointNameItem->contentWidgetData("text").toString(); |
274 |
297 |
275 HbAutoTest::mouseClick(mMainWindow, mTestView, accessPointNameLineEdit); |
298 HbAutoTest::mouseClick(mMainWindow, mAccessPointNameWidget); |
276 |
299 |
277 // Erase old string |
300 // Erase old string |
278 subClearLineEdit(CMManagerShim::PacketDataAPNameLength); |
301 QString text = mTestView->mAccessPointNameItem->contentWidgetData("text").toString(); |
279 |
302 subClearLineEdit(text.size()); |
280 HbAutoTest::mouseClick(mMainWindow, mTestView, sideTop); |
303 |
304 HbAutoTest::mouseClick(mMainWindow, mAccessPointNameWidget, exitEditorOffset); |
|
281 |
305 |
282 QTest::qWait(100); |
306 QTest::qWait(100); |
283 // Dismiss messagebox |
307 // Dismiss messagebox |
284 HbAutoTest::mouseClick(mMainWindow, mTestView, messageBoxOkButton); |
308 HbAutoTest::mouseClick( |
309 mMainWindow, |
|
310 mTestView->mMessageBox.data(), |
|
311 messageBoxOkButtonOffset); |
|
285 |
312 |
286 // Verify both commsdat and UI widget |
313 // Verify both commsdat and UI widget |
287 subVerifyString( |
314 subVerifyString( |
288 CMManagerShim::PacketDataAPName, |
315 CMManagerShim::PacketDataAPName, |
289 mTestView->mAccessPointNameItem, |
316 mTestView->mAccessPointNameItem, |
290 previous); |
317 previous); |
291 } |
318 } |
292 |
319 |
320 |
|
321 /** |
|
322 * Tests handling of too long string from CommsDat (longer than UI accepts). |
|
323 */ |
|
324 void TestCpPacketDataApPlugin::tcTooLongUserNameInCommsDat() |
|
325 { |
|
326 // Verify UI text, the widget contains the too long string, even though |
|
327 // it is not shown completely on UI |
|
328 QString text = mTestView->mUserNameItem->contentWidgetData("text").toString(); |
|
329 QCOMPARE(tooLongUserName, text); |
|
330 |
|
331 QTest::qWait(1000); |
|
332 |
|
333 // Visit editing state, truncated string should be saved to CommsDat |
|
334 HbAutoTest::mouseClick(mMainWindow, mUserNameWidget); |
|
335 |
|
336 QTest::qWait(1000); |
|
337 |
|
338 HbAutoTest::mouseClick(mMainWindow, mUserNameWidget, exitEditorOffset); |
|
339 |
|
340 // Verify both commsdat and UI widget |
|
341 subVerifyString( |
|
342 CMManagerShim::PacketDataIFAuthName, |
|
343 mTestView->mUserNameItem, |
|
344 truncatedUserName); |
|
345 } |
|
346 |
|
293 /** |
347 /** |
294 * Tests changing of user name. |
348 * Tests changing of user name. |
295 */ |
349 */ |
296 void TestCpPacketDataApPlugin::tcChangeUserName() |
350 void TestCpPacketDataApPlugin::tcChangeUserName() |
297 { |
351 { |
298 QFETCH(QString, string); |
352 QFETCH(QString, string); |
299 QFETCH(QString, result); |
353 QFETCH(QString, result); |
300 |
354 |
301 HbAutoTest::mouseClick(mMainWindow, mTestView, userNameLineEdit); |
355 HbAutoTest::mouseClick(mMainWindow, mUserNameWidget); |
302 |
356 |
303 // Erase old string |
357 // Erase old string |
304 subClearLineEdit(CMManagerShim::PacketDataIFAuthNameLength); |
358 QString text = mTestView->mUserNameItem->contentWidgetData("text").toString(); |
359 subClearLineEdit(text.size()); |
|
305 |
360 |
306 // Enter new string |
361 // Enter new string |
307 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
362 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
308 |
363 |
309 HbAutoTest::mouseClick(mMainWindow, mTestView, sideTop); |
364 HbAutoTest::mouseClick(mMainWindow, mUserNameWidget, exitEditorOffset); |
310 |
365 |
311 // Verify both commsdat and UI widget |
366 // Verify both commsdat and UI widget |
312 subVerifyString( |
367 subVerifyString( |
313 CMManagerShim::PacketDataIFAuthName, |
368 CMManagerShim::PacketDataIFAuthName, |
314 mTestView->mUserNameItem, |
369 mTestView->mUserNameItem, |
321 void TestCpPacketDataApPlugin::tcChangeUserName_data() |
376 void TestCpPacketDataApPlugin::tcChangeUserName_data() |
322 { |
377 { |
323 QTest::addColumn<QString>("string"); |
378 QTest::addColumn<QString>("string"); |
324 QTest::addColumn<QString>("result"); |
379 QTest::addColumn<QString>("result"); |
325 |
380 |
326 // Long strings don't work, Orbit bug? Screen goes blank |
381 QTest::newRow("maximum length") |
327 // QTest::newRow("maximum length") |
382 << "really long name 123456789012345678901234567890123" |
328 // << "really long name 123456789012345678901234567890123" |
383 << "really long name 123456789012345678901234567890123"; |
329 // << "really long name 123456789012345678901234567890123"; |
384 QTest::newRow("too long") |
330 // QTest::newRow("too long") |
385 << "too long name 1234567890123456789012345678901234567890123" |
331 // << "too long name 1234567890123456789012345678901234567890123" |
386 << "too long name 123456789012345678901234567890123456"; |
332 // << "too long name 123456789012345678901234567890123456"; |
|
333 QTest::newRow("basic") |
387 QTest::newRow("basic") |
334 << "username" |
388 << "username" |
335 << "username"; |
389 << "username"; |
336 QTest::newRow("empty") // last one must always fit on one line in UI |
390 QTest::newRow("empty") // last one must always fit on one line in UI |
337 << "" |
391 << "" |
341 /** |
395 /** |
342 * Scrolls the tested view to the bottom. |
396 * Scrolls the tested view to the bottom. |
343 */ |
397 */ |
344 void TestCpPacketDataApPlugin::tcScrollToBottom() |
398 void TestCpPacketDataApPlugin::tcScrollToBottom() |
345 { |
399 { |
346 // Scroll to the bottom of the view |
400 subScrollToBottom(); |
347 HbAutoTest::mousePress(mMainWindow, mTestView, scrollStart); |
|
348 QTest::qWait(500); |
|
349 HbAutoTest::mouseMove(mMainWindow, mTestView, scrollStop); |
|
350 HbAutoTest::mouseRelease(mMainWindow, mTestView, scrollStop); |
|
351 } |
|
352 |
|
353 /** |
|
354 * Tests "prompt" password checkbox. |
|
355 */ |
|
356 void TestCpPacketDataApPlugin::tcChangePromptPassword() |
|
357 { |
|
358 // Ensure prompt for password is unchecked |
|
359 bool prompt = subGetBool(CMManagerShim::PacketDataIFPromptForAuth); |
|
360 if (prompt) { |
|
361 // Disable prompt for password |
|
362 HbAutoTest::mouseClick( |
|
363 mMainWindow, |
|
364 mTestView, |
|
365 passwordPromptCheckbox); |
|
366 } |
|
367 |
|
368 // Enable prompt for password and verify |
|
369 HbAutoTest::mouseClick(mMainWindow, mTestView, passwordPromptCheckbox); |
|
370 subVerifyBool( |
|
371 CMManagerShim::PacketDataIFPromptForAuth, |
|
372 true); |
|
373 |
|
374 // Verify that password lineedit is disabled, following steps will |
|
375 // fail if editing is allowed |
|
376 HbAutoTest::mouseClick(mMainWindow, mTestView, passwordLineEdit); |
|
377 QTest::qWait(waitTime); |
|
378 |
|
379 // Disable prompt for password and verify |
|
380 HbAutoTest::mouseClick(mMainWindow, mTestView, passwordPromptCheckbox); |
|
381 subVerifyBool( |
|
382 CMManagerShim::PacketDataIFPromptForAuth, |
|
383 false); |
|
384 } |
401 } |
385 |
402 |
386 /** |
403 /** |
387 * Tests changing of password. |
404 * Tests changing of password. |
388 */ |
405 */ |
389 void TestCpPacketDataApPlugin::tcChangePassword() |
406 void TestCpPacketDataApPlugin::tcChangePassword() |
390 { |
407 { |
391 QFETCH(QString, string); |
408 QFETCH(QString, string); |
392 QFETCH(QString, result); |
409 QFETCH(QString, result); |
393 |
410 |
394 HbAutoTest::mouseClick(mMainWindow, mTestView, passwordLineEdit); |
411 HbAutoTest::mouseClick(mMainWindow, mPasswordWidget); |
395 |
412 |
396 // Erase old string |
413 // Erase old string |
397 subClearLineEdit(CMManagerShim::PacketDataIFAuthPassLength); |
414 QString text = mTestView->mPasswordItem->contentWidgetData("text").toString(); |
415 subClearLineEdit(text.size()); |
|
398 |
416 |
399 // Enter new string |
417 // Enter new string |
400 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
418 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
401 |
419 |
402 HbAutoTest::mouseClick(mMainWindow, mTestView, sideTop); |
420 HbAutoTest::mouseClick(mMainWindow, mPasswordWidget, exitEditorOffset); |
403 |
421 |
404 // Verify both commsdat and UI widget |
422 // Verify both commsdat and UI widget |
405 subVerifyString( |
423 subVerifyString( |
406 CMManagerShim::PacketDataIFAuthPass, |
424 CMManagerShim::PacketDataIFAuthPass, |
407 mTestView->mPasswordItem, |
425 mTestView->mPasswordItem, |
414 void TestCpPacketDataApPlugin::tcChangePassword_data() |
432 void TestCpPacketDataApPlugin::tcChangePassword_data() |
415 { |
433 { |
416 QTest::addColumn<QString>("string"); |
434 QTest::addColumn<QString>("string"); |
417 QTest::addColumn<QString>("result"); |
435 QTest::addColumn<QString>("result"); |
418 |
436 |
419 // Long strings don't work, Orbit bug? Screen goes blank |
437 QTest::newRow("maximum length") |
420 // QTest::newRow("maximum length") |
438 << "really long name 123456789012345678901234567890123" |
421 // << "really long name 123456789012345678901234567890123" |
439 << "really long name 123456789012345678901234567890123"; |
422 // << "really long name 123456789012345678901234567890123"; |
440 QTest::newRow("too long") |
423 // QTest::newRow("too long") |
441 << "too long name 1234567890123456789012345678901234567890123" |
424 // << "too long name 1234567890123456789012345678901234567890123" |
442 << "too long name 123456789012345678901234567890123456"; |
425 // << "too long name 123456789012345678901234567890123456"; |
|
426 QTest::newRow("basic") |
443 QTest::newRow("basic") |
427 << "password" |
444 << "password" |
428 << "password"; |
445 << "password"; |
429 QTest::newRow("empty") // last one must always fit on one line in UI |
446 QTest::newRow("empty") // last one must always fit on one line in UI |
430 << "" |
447 << "" |
434 /** |
451 /** |
435 * Tests changing of authentication mode. |
452 * Tests changing of authentication mode. |
436 */ |
453 */ |
437 void TestCpPacketDataApPlugin::tcChangeAuthenticationMode() |
454 void TestCpPacketDataApPlugin::tcChangeAuthenticationMode() |
438 { |
455 { |
456 QPointF normalPointOffset = comboBoxFirstItemOffset; |
|
457 QPointF securePointOffset = comboBoxFirstItemOffset + comboBoxItemOffset; |
|
458 |
|
439 // Set authentication mode to secure |
459 // Set authentication mode to secure |
440 HbAutoTest::mouseClick(mMainWindow, mTestView, authenticationComboBox, 100); |
460 HbAutoTest::mouseClick(mMainWindow, mAuthenticationWidget); |
441 QTest::qWait(100); |
461 QTest::qWait(100); |
442 HbAutoTest::mouseClick(mMainWindow, mTestView, authenticationSecure, 100); |
462 HbAutoTest::mouseClick(mMainWindow, mAuthenticationWidget, securePointOffset); |
443 |
463 |
444 subVerifyBool( |
464 subVerifyBool( |
445 CMManagerShim::PacketDataDisablePlainTextAuth, |
465 CMManagerShim::PacketDataDisablePlainTextAuth, |
446 true); |
466 true); |
447 |
467 |
448 // Set authentication mode to normal |
468 // Set authentication mode to normal |
449 HbAutoTest::mouseClick(mMainWindow, mTestView, authenticationComboBox, 100); |
469 HbAutoTest::mouseClick(mMainWindow, mAuthenticationWidget); |
450 QTest::qWait(100); |
470 QTest::qWait(100); |
451 HbAutoTest::mouseClick(mMainWindow, mTestView, authenticationNormal, 100); |
471 HbAutoTest::mouseClick(mMainWindow, mAuthenticationWidget, normalPointOffset); |
452 |
472 |
453 subVerifyBool( |
473 subVerifyBool( |
454 CMManagerShim::PacketDataDisablePlainTextAuth, |
474 CMManagerShim::PacketDataDisablePlainTextAuth, |
455 false); |
475 false); |
456 } |
476 } |
461 void TestCpPacketDataApPlugin::tcChangeHomepage() |
481 void TestCpPacketDataApPlugin::tcChangeHomepage() |
462 { |
482 { |
463 QFETCH(QString, string); |
483 QFETCH(QString, string); |
464 QFETCH(QString, result); |
484 QFETCH(QString, result); |
465 |
485 |
466 HbAutoTest::mouseClick(mMainWindow, mTestView, homepageLineEdit); |
486 HbAutoTest::mouseClick(mMainWindow, mHomepageWidget); |
467 |
487 |
468 // Erase old string |
488 // Erase old string |
469 QString text = mTestView->mHomepageItem->contentWidgetData("text").toString(); |
489 QString text = mTestView->mHomepageItem->contentWidgetData("text").toString(); |
470 subClearLineEdit(text.size()); |
490 subClearLineEdit(text.size()); |
471 |
491 |
472 // Enter new string |
492 // Enter new string |
473 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
493 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
474 |
494 |
475 HbAutoTest::mouseClick(mMainWindow, mTestView, sideTop); |
495 HbAutoTest::mouseClick(mMainWindow, mHomepageWidget, exitEditorOffset); |
476 |
496 |
477 // Verify both commsdat and UI widget |
497 // Verify both commsdat and UI widget |
478 subVerifyString( |
498 subVerifyString( |
479 CMManagerShim::CmStartPage, |
499 CMManagerShim::CmStartPage, |
480 mTestView->mHomepageItem, |
500 mTestView->mHomepageItem, |
487 void TestCpPacketDataApPlugin::tcChangeHomepage_data() |
507 void TestCpPacketDataApPlugin::tcChangeHomepage_data() |
488 { |
508 { |
489 QTest::addColumn<QString>("string"); |
509 QTest::addColumn<QString>("string"); |
490 QTest::addColumn<QString>("result"); |
510 QTest::addColumn<QString>("result"); |
491 |
511 |
492 // Doesn't work always, view goes blank sometimes, Orbit bug? |
512 QTest::newRow("long") |
493 // QTest::newRow("long") |
513 << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html" |
494 // << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html" |
514 << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html"; |
495 // << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html"; |
|
496 QTest::newRow("basic") // last one should always fit on one line in UI |
515 QTest::newRow("basic") // last one should always fit on one line in UI |
497 << "http://www.symbian.org/" |
516 << "http://www.symbian.org/" |
498 << "http://www.symbian.org/"; |
517 << "http://www.symbian.org/"; |
499 QTest::newRow("empty") |
518 QTest::newRow("empty") |
500 << "" |
519 << "" |
501 << ""; |
520 << ""; |
502 } |
521 } |
503 |
522 |
504 /** |
523 /** |
505 * Tests advanced settings view (which is currently empty). |
524 * Opens advanced settings view. |
506 */ |
525 */ |
507 void TestCpPacketDataApPlugin::tcAdvancedSettings() |
526 void TestCpPacketDataApPlugin::tcOpenAdvancedSettingsView() |
508 { |
527 { |
509 // Launch advanced settings view |
528 // Launch advanced settings view |
510 bool status = connect( |
529 bool status = connect( |
511 this, |
530 this, |
512 SIGNAL(menuActionTriggered(HbAction *)), |
531 SIGNAL(menuActionTriggered(HbAction *)), |
513 mTestView, |
532 mTestView, |
514 SLOT(menuActionTriggered(HbAction *))); |
533 SLOT(menuActionTriggered(HbAction *))); |
515 Q_ASSERT(status); |
534 Q_ASSERT(status); |
516 emit menuActionTriggered(mTestView->mAdvancedSettingsAction); |
535 emit menuActionTriggered(mTestView->mAdvancedSettingsAction); |
517 |
536 |
518 QTest::qWait(2000); |
537 QTest::qWait(1000); |
519 |
538 |
539 mTestViewAdvanced = static_cast<CpPacketDataApAdvancedView *>(mMainWindow->currentView()); |
|
540 } |
|
541 |
|
542 /** |
|
543 * Expands the IP settings group. |
|
544 */ |
|
545 void TestCpPacketDataApPlugin::tcExpandIpSettings() |
|
546 { |
|
547 HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, ipGroup); |
|
548 |
|
549 subGetAdvancedUiWidgets(0); |
|
550 } |
|
551 |
|
552 /** |
|
553 * Sets the network type to IPv4 and gets UI widget pointers. |
|
554 */ |
|
555 void TestCpPacketDataApPlugin::tcSetIpv4NetworkType() |
|
556 { |
|
557 QPointF ipv4PointOffset = comboBoxFirstItemOffset; |
|
558 |
|
559 // Set network type to IPv4 |
|
560 HbAutoTest::mouseClick(mMainWindow, mNetworkTypeWidget); |
|
561 HbAutoTest::mouseClick(mMainWindow, mNetworkTypeWidget, ipv4PointOffset, 100); |
|
562 subVerifyUint(CMManagerShim::PacketDataPDPType, RPacketContext::EPdpTypeIPv4); |
|
563 |
|
564 subGetAdvancedUiWidgets(0); |
|
565 } |
|
566 |
|
567 /** |
|
568 * Tests enabling of automatic phone IP address. |
|
569 */ |
|
570 void TestCpPacketDataApPlugin::tcEnableAutomaticIpv4Address() |
|
571 { |
|
572 Qt::CheckState state = static_cast<Qt::CheckState> |
|
573 (mTestViewAdvanced->mIpv4Automatic->contentWidgetData("checkState").toInt()); |
|
574 if (state == Qt::Checked) { |
|
575 // Disable automatic IP address |
|
576 HbAutoTest::mouseClick(mMainWindow, mIpv4AddressAutomaticWidget); |
|
577 } |
|
578 // Enable automatic IP address |
|
579 HbAutoTest::mouseClick(mMainWindow, mIpv4AddressAutomaticWidget); |
|
580 subVerifyBool( |
|
581 CMManagerShim::PacketDataIPAddrFromServer, |
|
582 true); |
|
583 |
|
584 // Ensure that editing the IP address is not allowed |
|
585 HbAutoTest::mouseClick(mMainWindow, mIpv4AddressWidget); |
|
586 } |
|
587 |
|
588 /** |
|
589 * Tests disabling of automatic phone IP address. |
|
590 */ |
|
591 void TestCpPacketDataApPlugin::tcEnableUserDefinedIpv4Address() |
|
592 { |
|
593 Qt::CheckState state = static_cast<Qt::CheckState> |
|
594 (mTestViewAdvanced->mIpv4Automatic->contentWidgetData("checkState").toInt()); |
|
595 if (state == Qt::Checked) { |
|
596 // Disable automatic IP address |
|
597 HbAutoTest::mouseClick(mMainWindow, mIpv4AddressAutomaticWidget); |
|
598 } |
|
599 // Can't verify the setting from CommsDat here, because CMManager will |
|
600 // set it back to true if no valid IP address is yet defined. The flag |
|
601 // is verified in tcChangeIpAddress(). |
|
602 } |
|
603 |
|
604 /** |
|
605 * Tests changing of IP address. |
|
606 */ |
|
607 void TestCpPacketDataApPlugin::tcChangeIpAddress() |
|
608 { |
|
609 QFETCH(QString, string); |
|
610 QFETCH(QString, result); |
|
611 |
|
612 HbAutoTest::mouseClick(mMainWindow, mIpv4AddressWidget); |
|
613 |
|
614 // Erase old string |
|
615 QString text = mTestViewAdvanced->mIpv4Address->contentWidgetData("text").toString(); |
|
616 subClearLineEdit(text.size()); |
|
617 |
|
618 // Enter new string |
|
619 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
|
620 |
|
621 HbAutoTest::mouseClick(mMainWindow, mIpv4AddressWidget, exitEditorOffset); |
|
622 |
|
623 // Verify both commsdat and UI widget |
|
624 subVerifyString( |
|
625 CMManagerShim::PacketDataIPAddr, |
|
626 mTestViewAdvanced->mIpv4Address, |
|
627 result); |
|
628 subVerifyBool( |
|
629 CMManagerShim::PacketDataIPAddrFromServer, |
|
630 false); |
|
631 } |
|
632 |
|
633 /** |
|
634 * Test data for IP address change test case. |
|
635 */ |
|
636 void TestCpPacketDataApPlugin::tcChangeIpAddress_data() |
|
637 { |
|
638 QTest::addColumn<QString>("string"); |
|
639 QTest::addColumn<QString>("result"); |
|
640 |
|
641 QTest::newRow("too long") |
|
642 << "255.255.255.2551234" |
|
643 << "255.255.255.255"; |
|
644 QTest::newRow("normal") |
|
645 << "192.168.0.1" |
|
646 << "192.168.0.1"; |
|
647 } |
|
648 |
|
649 /** |
|
650 * Scrolls the tested view to the bottom. |
|
651 */ |
|
652 void TestCpPacketDataApPlugin::tcScrollToBottom2() |
|
653 { |
|
654 subScrollToBottom(); |
|
655 |
|
656 subGetAdvancedUiWidgets(0); |
|
657 } |
|
658 |
|
659 /** |
|
660 * Tests enabling of automatic IPv4 DNS addresses. |
|
661 */ |
|
662 void TestCpPacketDataApPlugin::tcEnableAutomaticIpv4DnsAddress() |
|
663 { |
|
664 Qt::CheckState state = static_cast<Qt::CheckState> |
|
665 (mTestViewAdvanced->mIpv4DnsAutomatic->contentWidgetData("checkState").toInt()); |
|
666 if (state == Qt::Checked) { |
|
667 // Disable automatic IPv4 DNS address |
|
668 HbAutoTest::mouseClick(mMainWindow, mIpv4DnsAddressAutomaticWidget); |
|
669 } |
|
670 // Enable automatic IPv4 DNS address |
|
671 HbAutoTest::mouseClick(mMainWindow, mIpv4DnsAddressAutomaticWidget); |
|
672 subVerifyBool( |
|
673 CMManagerShim::PacketDataIPDNSAddrFromServer, |
|
674 true); |
|
675 |
|
676 // Ensure that editing the IP address is not allowed |
|
677 HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget); |
|
678 HbAutoTest::mouseClick(mMainWindow, mIpv4SecondaryDnsAddressWidget); |
|
679 } |
|
680 |
|
681 /** |
|
682 * Tests disabling of automatic IPv4 DNS addresses. |
|
683 */ |
|
684 void TestCpPacketDataApPlugin::tcEnableUserDefinedIpv4DnsAddress() |
|
685 { |
|
686 Qt::CheckState state = static_cast<Qt::CheckState> |
|
687 (mTestViewAdvanced->mIpv4DnsAutomatic->contentWidgetData("checkState").toInt()); |
|
688 if (state == Qt::Checked) { |
|
689 // Disable automatic IPv4 DNS address |
|
690 HbAutoTest::mouseClick(mMainWindow, mIpv4DnsAddressAutomaticWidget); |
|
691 } |
|
692 // Can't verify the setting from CommsDat here, because CMManager will |
|
693 // set it back to true if no valid IP address is yet defined. The flag |
|
694 // is verified in tcChangeIpv4DnsAddress(). |
|
695 } |
|
696 |
|
697 /** |
|
698 * Tests changing of IPv4 DNS addresses. |
|
699 */ |
|
700 void TestCpPacketDataApPlugin::tcChangeIpv4DnsAddress() |
|
701 { |
|
702 QFETCH(QString, string); |
|
703 QFETCH(QString, result); |
|
704 |
|
705 // Primary DNS address |
|
706 HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget); |
|
707 |
|
708 // Erase old string |
|
709 QString text = mTestViewAdvanced->mIpv4DnsAddress1->contentWidgetData("text").toString(); |
|
710 subClearLineEdit(text.size()); |
|
711 |
|
712 // Enter new string |
|
713 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
|
714 |
|
715 HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget, exitEditorOffset); |
|
716 |
|
717 // Verify both commsdat and UI widget |
|
718 subVerifyString( |
|
719 CMManagerShim::PacketDataIPNameServer1, |
|
720 mTestViewAdvanced->mIpv4DnsAddress1, |
|
721 result); |
|
722 |
|
723 // Secondary DNS address |
|
724 HbAutoTest::mouseClick(mMainWindow, mIpv4SecondaryDnsAddressWidget); |
|
725 |
|
726 // Erase old string |
|
727 text = mTestViewAdvanced->mIpv4DnsAddress2->contentWidgetData("text").toString(); |
|
728 subClearLineEdit(text.size()); |
|
729 |
|
730 // Enter new string |
|
731 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
|
732 |
|
733 HbAutoTest::mouseClick(mMainWindow, mIpv4SecondaryDnsAddressWidget, exitEditorOffset); |
|
734 |
|
735 // Verify both commsdat and UI widget |
|
736 subVerifyString( |
|
737 CMManagerShim::PacketDataIPNameServer2, |
|
738 mTestViewAdvanced->mIpv4DnsAddress2, |
|
739 result); |
|
740 |
|
741 // Verify user defined address is in use |
|
742 subVerifyBool( |
|
743 CMManagerShim::PacketDataIPDNSAddrFromServer, |
|
744 false); |
|
745 } |
|
746 |
|
747 /** |
|
748 * Test data for IPv4 DNS address change test case. |
|
749 */ |
|
750 void TestCpPacketDataApPlugin::tcChangeIpv4DnsAddress_data() |
|
751 { |
|
752 QTest::addColumn<QString>("string"); |
|
753 QTest::addColumn<QString>("result"); |
|
754 |
|
755 QTest::newRow("too long") |
|
756 << "255.255.255.2551234" |
|
757 << "255.255.255.255"; |
|
758 QTest::newRow("normal") |
|
759 << "192.168.0.1" |
|
760 << "192.168.0.1"; |
|
761 } |
|
762 |
|
763 /** |
|
764 * Tests invalid IPv4 DNS address. |
|
765 */ |
|
766 void TestCpPacketDataApPlugin::tcInvalidIpv4DnsAddress() |
|
767 { |
|
768 QString previous = |
|
769 mTestViewAdvanced->mIpv4DnsAddress1->contentWidgetData("text").toString(); |
|
770 |
|
771 HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget); |
|
772 |
|
773 // Erase old string |
|
774 QString text = mTestViewAdvanced->mIpv4DnsAddress1->contentWidgetData("text").toString(); |
|
775 subClearLineEdit(text.size()); |
|
776 |
|
777 // Enter new string |
|
778 HbAutoTest::keyClicks(mMainWindow, "999.999.999.999", 0, waitTime); |
|
779 |
|
780 HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget, exitEditorOffset); |
|
781 |
|
782 QTest::qWait(100); |
|
783 // Dismiss messagebox |
|
784 HbAutoTest::mouseClick( |
|
785 mMainWindow, |
|
786 mTestViewAdvanced->mMessageBox.data(), |
|
787 messageBoxOkButtonOffset); |
|
788 |
|
789 // Verify both commsdat and UI widget |
|
790 subVerifyString( |
|
791 CMManagerShim::PacketDataIPNameServer1, |
|
792 mTestViewAdvanced->mIpv4DnsAddress1, |
|
793 previous); |
|
794 } |
|
795 |
|
796 /** |
|
797 * Scrolls the tested view to the top. |
|
798 */ |
|
799 void TestCpPacketDataApPlugin::tcScrollToTop() |
|
800 { |
|
801 subScrollToTop(); |
|
802 } |
|
803 |
|
804 /** |
|
805 * Sets the network type to IPv6 and gets UI widget pointers. |
|
806 */ |
|
807 void TestCpPacketDataApPlugin::tcSetIpv6NetworkType() |
|
808 { |
|
809 QPointF ipv6PointOffset = comboBoxFirstItemOffset + comboBoxItemOffset; |
|
810 |
|
811 // Set network type to IPv6 |
|
812 HbAutoTest::mouseClick(mMainWindow, mNetworkTypeWidget); |
|
813 HbAutoTest::mouseClick(mMainWindow, mNetworkTypeWidget, ipv6PointOffset, 100); |
|
814 subVerifyUint(CMManagerShim::PacketDataPDPType, RPacketContext::EPdpTypeIPv6); |
|
815 |
|
816 subGetAdvancedUiWidgets(0); |
|
817 } |
|
818 |
|
819 /** |
|
820 * Tests enabling of automatic IPv6 DNS addresses. |
|
821 */ |
|
822 void TestCpPacketDataApPlugin::tcEnableAutomaticIpv6DnsAddress() |
|
823 { |
|
824 // Enable automatic IPv6 DNS address |
|
825 QPointF automaticPointOffset = comboBoxFirstItemOffset; |
|
826 HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget); |
|
827 QTest::qWait(100); |
|
828 HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget, automaticPointOffset, 100); |
|
829 QTest::qWait(100); |
|
830 subVerifyBool( |
|
831 CMManagerShim::PacketDataIPIP6DNSAddrFromServer, |
|
832 true); |
|
833 |
|
834 // Ensure that editing the IP address is not allowed |
|
835 HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget); |
|
836 HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget); |
|
837 } |
|
838 |
|
839 /** |
|
840 * Tests enabling of well-known IPv6 DNS addresses. |
|
841 */ |
|
842 void TestCpPacketDataApPlugin::tcEnableWellKnownIpv6DnsAddress() |
|
843 { |
|
844 // Enable well-known IPv6 DNS address |
|
845 QPointF wellKnownPointOffset = comboBoxFirstItemOffset + comboBoxItemOffset; |
|
846 HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget); |
|
847 QTest::qWait(100); |
|
848 HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget, wellKnownPointOffset, 100); |
|
849 QTest::qWait(100); |
|
850 subVerifyBool( |
|
851 CMManagerShim::PacketDataIPIP6DNSAddrFromServer, |
|
852 false); |
|
853 subVerifyString( |
|
854 CMManagerShim::PacketDataIPIP6NameServer1, |
|
855 mTestViewAdvanced->mIpv6DnsAddress1, |
|
856 "fec0:000:0000:ffff::1"); |
|
857 subVerifyString( |
|
858 CMManagerShim::PacketDataIPIP6NameServer2, |
|
859 mTestViewAdvanced->mIpv6DnsAddress2, |
|
860 "fec0:000:0000:ffff::2"); |
|
861 |
|
862 // Ensure that editing the IP address is not allowed |
|
863 HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget); |
|
864 HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget); |
|
865 } |
|
866 |
|
867 /** |
|
868 * Tests enabling of user defined IPv6 DNS addresses. |
|
869 */ |
|
870 void TestCpPacketDataApPlugin::tcEnableUserDefinedIpv6DnsAddress() |
|
871 { |
|
872 // Select user defined IPv6 DNS address |
|
873 QPointF userDefinedPointOffset = comboBoxFirstItemOffset + comboBoxItemOffset * 2; |
|
874 //QPointF userDefinedPointOffset(0, 160); |
|
875 HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget); |
|
876 QTest::qWait(100); |
|
877 HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget, userDefinedPointOffset, 100); |
|
878 QTest::qWait(100); |
|
879 // Can't verify the setting from CommsDat here, because CMManager will |
|
880 // set it back to true if no valid IP address is yet defined. The flag |
|
881 // is verified in tcChangeIpv4DnsAddress(). |
|
882 } |
|
883 |
|
884 /** |
|
885 * Tests changing of IPv6 DNS addresses. |
|
886 */ |
|
887 void TestCpPacketDataApPlugin::tcChangeIpv6DnsAddress() |
|
888 { |
|
889 QFETCH(QString, string); |
|
890 QFETCH(QString, result); |
|
891 |
|
892 // Primary DNS address |
|
893 HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget); |
|
894 |
|
895 // Erase old string |
|
896 QString text = mTestViewAdvanced->mIpv6DnsAddress1->contentWidgetData("text").toString(); |
|
897 subClearLineEdit(text.size()); |
|
898 |
|
899 // Enter new string |
|
900 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
|
901 |
|
902 HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget, exitEditorOffset); |
|
903 |
|
904 // Verify both commsdat and UI widget |
|
905 subVerifyString( |
|
906 CMManagerShim::PacketDataIPIP6NameServer1, |
|
907 mTestViewAdvanced->mIpv6DnsAddress1, |
|
908 result); |
|
909 |
|
910 // Secondary DNS address |
|
911 HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget); |
|
912 |
|
913 // Erase old string |
|
914 text = mTestViewAdvanced->mIpv6DnsAddress2->contentWidgetData("text").toString(); |
|
915 subClearLineEdit(text.size()); |
|
916 |
|
917 // Enter new string |
|
918 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
|
919 |
|
920 HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget, exitEditorOffset); |
|
921 |
|
922 // Verify both commsdat and UI widget |
|
923 subVerifyString( |
|
924 CMManagerShim::PacketDataIPIP6NameServer2, |
|
925 mTestViewAdvanced->mIpv6DnsAddress2, |
|
926 result); |
|
927 |
|
928 // Verify user defined address is in use |
|
929 subVerifyBool( |
|
930 CMManagerShim::PacketDataIPIP6DNSAddrFromServer, |
|
931 false); |
|
932 } |
|
933 |
|
934 /** |
|
935 * Test data for IPv6 DNS address change test case. |
|
936 */ |
|
937 void TestCpPacketDataApPlugin::tcChangeIpv6DnsAddress_data() |
|
938 { |
|
939 QTest::addColumn<QString>("string"); |
|
940 QTest::addColumn<QString>("result"); |
|
941 |
|
942 QTest::newRow("normal") |
|
943 << "2001:db8:85a3::8a2e:370:7334" |
|
944 << "2001:db8:85a3:0:0:8a2e:370:7334"; |
|
945 } |
|
946 |
|
947 /** |
|
948 * Tests invalid IPv6 DNS address. |
|
949 */ |
|
950 void TestCpPacketDataApPlugin::tcInvalidIpv6DnsAddress() |
|
951 { |
|
952 QString previous = |
|
953 mTestViewAdvanced->mIpv6DnsAddress1->contentWidgetData("text").toString(); |
|
954 |
|
955 HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget); |
|
956 |
|
957 // Erase old string |
|
958 QString text = mTestViewAdvanced->mIpv6DnsAddress1->contentWidgetData("text").toString(); |
|
959 subClearLineEdit(text.size()); |
|
960 |
|
961 // Enter new string |
|
962 HbAutoTest::keyClicks(mMainWindow, "abcdef:fedcba", 0, waitTime); |
|
963 |
|
964 HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget, exitEditorOffset); |
|
965 |
|
966 QTest::qWait(100); |
|
967 // Dismiss messagebox |
|
968 HbAutoTest::mouseClick( |
|
969 mMainWindow, |
|
970 mTestViewAdvanced->mMessageBox.data(), |
|
971 messageBoxOkButtonOffset); |
|
972 |
|
973 // Verify both commsdat and UI widget |
|
974 subVerifyString( |
|
975 CMManagerShim::PacketDataIPIP6NameServer1, |
|
976 mTestViewAdvanced->mIpv6DnsAddress1, |
|
977 previous); |
|
978 } |
|
979 |
|
980 /** |
|
981 * Collapses the IP settings group. |
|
982 */ |
|
983 void TestCpPacketDataApPlugin::tcCollapseIpSettings() |
|
984 { |
|
985 HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, ipGroup); |
|
986 } |
|
987 |
|
988 /** |
|
989 * Expands the proxy settings group and gets UI widget pointers. |
|
990 */ |
|
991 void TestCpPacketDataApPlugin::tcExpandProxySettingsAndGetUiWidgets() |
|
992 { |
|
993 HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, proxyGroup); |
|
994 |
|
995 QTest::qWait(500); |
|
996 |
|
997 subGetAdvancedUiWidgets(1); |
|
998 } |
|
999 |
|
1000 /** |
|
1001 * Tests changing of proxy server address. |
|
1002 */ |
|
1003 void TestCpPacketDataApPlugin::tcChangeProxyServerAddress() |
|
1004 { |
|
1005 QFETCH(QString, string); |
|
1006 QFETCH(QString, result); |
|
1007 |
|
1008 HbAutoTest::mouseClick(mMainWindow, mProxyServerAddressWidget); |
|
1009 |
|
1010 // Erase old string |
|
1011 QString text = mTestViewAdvanced->mProxyServer->contentWidgetData("text").toString(); |
|
1012 subClearLineEdit(text.size()); |
|
1013 |
|
1014 // Enter new string |
|
1015 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
|
1016 |
|
1017 HbAutoTest::mouseClick(mMainWindow, mProxyServerAddressWidget, exitEditorOffset); |
|
1018 |
|
1019 // Verify both commsdat and UI widget |
|
1020 subVerifyString( |
|
1021 CMManagerShim::CmProxyServerName, |
|
1022 mTestViewAdvanced->mProxyServer, |
|
1023 result); |
|
1024 // Verify user defined address flag is set correctly |
|
1025 if (result.isEmpty()) { |
|
1026 subVerifyBool( |
|
1027 CMManagerShim::CmProxyUsageEnabled, |
|
1028 false); |
|
1029 } else { |
|
1030 subVerifyBool( |
|
1031 CMManagerShim::CmProxyUsageEnabled, |
|
1032 true); |
|
1033 } |
|
1034 } |
|
1035 |
|
1036 /** |
|
1037 * Test data for proxy server address change test case. |
|
1038 */ |
|
1039 void TestCpPacketDataApPlugin::tcChangeProxyServerAddress_data() |
|
1040 { |
|
1041 QTest::addColumn<QString>("string"); |
|
1042 QTest::addColumn<QString>("result"); |
|
1043 |
|
1044 QTest::newRow("long") |
|
1045 << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html" |
|
1046 << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html"; |
|
1047 QTest::newRow("empty") |
|
1048 << "" |
|
1049 << ""; |
|
1050 QTest::newRow("basic") // last one should always fit on one line in UI |
|
1051 << "http://www.symbian.org/" |
|
1052 << "http://www.symbian.org/"; |
|
1053 } |
|
1054 |
|
1055 /** |
|
1056 * Tests changing of proxy port number. |
|
1057 */ |
|
1058 void TestCpPacketDataApPlugin::tcChangeProxyPortNumber() |
|
1059 { |
|
1060 QFETCH(QString, string); |
|
1061 QFETCH(QString, result); |
|
1062 |
|
1063 HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget); |
|
1064 |
|
1065 // Erase old string |
|
1066 QString text = mTestViewAdvanced->mProxyPort->contentWidgetData("text").toString(); |
|
1067 subClearLineEdit(text.size()); |
|
1068 |
|
1069 // Enter new string |
|
1070 HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime); |
|
1071 |
|
1072 HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget, exitEditorOffset); |
|
1073 |
|
1074 // Verify both commsdat and UI widget |
|
1075 subVerifyUint( |
|
1076 CMManagerShim::CmProxyPortNumber, |
|
1077 result.toInt()); |
|
1078 QCOMPARE( |
|
1079 mTestViewAdvanced->mProxyPort->contentWidgetData("text").toInt(), |
|
1080 result.toInt()); |
|
1081 } |
|
1082 |
|
1083 /** |
|
1084 * Test data for proxy port number change test case. |
|
1085 */ |
|
1086 void TestCpPacketDataApPlugin::tcChangeProxyPortNumber_data() |
|
1087 { |
|
1088 QTest::addColumn<QString>("string"); |
|
1089 QTest::addColumn<QString>("result"); |
|
1090 |
|
1091 QTest::newRow("basic") |
|
1092 << "8080" |
|
1093 << "8080"; |
|
1094 QTest::newRow("too long") |
|
1095 << "1234567890" |
|
1096 << "12345"; |
|
1097 QTest::newRow("zero") |
|
1098 << "0" |
|
1099 << ""; |
|
1100 QTest::newRow("empty") |
|
1101 << "" |
|
1102 << ""; |
|
1103 } |
|
1104 |
|
1105 /** |
|
1106 * Tests invalid proxy port number. |
|
1107 */ |
|
1108 void TestCpPacketDataApPlugin::tcInvalidProxyPortNumber() |
|
1109 { |
|
1110 int previous = |
|
1111 mTestViewAdvanced->mProxyPort->contentWidgetData("text").toInt(); |
|
1112 |
|
1113 HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget); |
|
1114 |
|
1115 // Erase old string |
|
1116 QString text = mTestViewAdvanced->mProxyPort->contentWidgetData("text").toString(); |
|
1117 subClearLineEdit(text.size()); |
|
1118 |
|
1119 // Enter new string |
|
1120 HbAutoTest::keyClicks(mMainWindow, "65536", 0, waitTime); |
|
1121 |
|
1122 HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget, exitEditorOffset); |
|
1123 |
|
1124 QTest::qWait(100); |
|
1125 // Dismiss messagebox |
|
1126 HbAutoTest::mouseClick( |
|
1127 mMainWindow, |
|
1128 mTestViewAdvanced->mMessageBox.data(), |
|
1129 messageBoxOkButtonOffset); |
|
1130 |
|
1131 // Verify both commsdat and UI widget |
|
1132 subVerifyUint( |
|
1133 CMManagerShim::CmProxyPortNumber, |
|
1134 previous); |
|
1135 QCOMPARE( |
|
1136 mTestViewAdvanced->mProxyPort->contentWidgetData("text").toInt(), |
|
1137 previous); |
|
1138 } |
|
1139 |
|
1140 /** |
|
1141 * Collapses the proxy settings group. |
|
1142 */ |
|
1143 void TestCpPacketDataApPlugin::tcCollapseProxySettings() |
|
1144 { |
|
1145 HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, proxyGroup); |
|
1146 } |
|
1147 |
|
1148 /** |
|
1149 * Returns from advanced settings view. |
|
1150 */ |
|
1151 void TestCpPacketDataApPlugin::tcCloseAdvancedSettingsView() |
|
1152 { |
|
520 // Return from advanced settings view |
1153 // Return from advanced settings view |
521 subClickWidget("HbNavigationButton"); |
1154 subClickWidget("HbNavigationButton"); |
522 } |
1155 } |
523 |
1156 |
524 // ----------------------------------------------------------------------------- |
1157 // ----------------------------------------------------------------------------- |
525 // SUB TEST CASES |
1158 // SUB TEST CASES |
526 // ----------------------------------------------------------------------------- |
1159 // ----------------------------------------------------------------------------- |
1160 |
|
1161 /** |
|
1162 * Gets UI widget pointers. |
|
1163 */ |
|
1164 void TestCpPacketDataApPlugin::subGetUiWidgets() |
|
1165 { |
|
1166 HbModelIterator iterator(mTestView->mModel); |
|
1167 |
|
1168 // Get "Access point settings" group item |
|
1169 QModelIndex apGroupIndex = iterator.index(0); |
|
1170 |
|
1171 // Get UI widgets |
|
1172 mConnectionNameWidget = subGetWidgetByIndex( |
|
1173 mTestView->mForm, |
|
1174 iterator.index(0, apGroupIndex)); |
|
1175 mAccessPointNameWidget = subGetWidgetByIndex( |
|
1176 mTestView->mForm, |
|
1177 iterator.index(1, apGroupIndex)); |
|
1178 mUserNameWidget = subGetWidgetByIndex( |
|
1179 mTestView->mForm, |
|
1180 iterator.index(2, apGroupIndex)); |
|
1181 mPasswordWidget = subGetWidgetByIndex( |
|
1182 mTestView->mForm, |
|
1183 iterator.index(4, apGroupIndex)); |
|
1184 mAuthenticationWidget = subGetWidgetByIndex( |
|
1185 mTestView->mForm, |
|
1186 iterator.index(5, apGroupIndex)); |
|
1187 mHomepageWidget = subGetWidgetByIndex( |
|
1188 mTestView->mForm, |
|
1189 iterator.index(6, apGroupIndex)); |
|
1190 } |
|
1191 |
|
1192 /** |
|
1193 * Gets advanced settings view UI widget pointers by group index. |
|
1194 */ |
|
1195 void TestCpPacketDataApPlugin::subGetAdvancedUiWidgets( |
|
1196 uint index) |
|
1197 { |
|
1198 // Get the group item |
|
1199 HbModelIterator iterator(mTestViewAdvanced->mModel); |
|
1200 QModelIndex groupIndex = iterator.index(index); |
|
1201 |
|
1202 // Get UI widgets |
|
1203 if (index == 0) { |
|
1204 // IP settings group |
|
1205 mNetworkTypeWidget = subGetWidgetByIndex( |
|
1206 mTestViewAdvanced->mForm, |
|
1207 iterator.index(0, groupIndex)); |
|
1208 if (qobject_cast<HbComboBox *>(mNetworkTypeWidget)->currentIndex() == 0) { |
|
1209 // IPv4 |
|
1210 mIpv4AddressAutomaticWidget = subGetWidgetByIndex( |
|
1211 mTestViewAdvanced->mForm, |
|
1212 iterator.index(1, groupIndex)); |
|
1213 mIpv4AddressWidget = subGetWidgetByIndex( |
|
1214 mTestViewAdvanced->mForm, |
|
1215 iterator.index(2, groupIndex)); |
|
1216 mIpv4DnsAddressAutomaticWidget = subGetWidgetByIndex( |
|
1217 mTestViewAdvanced->mForm, |
|
1218 iterator.index(3, groupIndex)); |
|
1219 mIpv4PrimaryDnsAddressWidget = subGetWidgetByIndex( |
|
1220 mTestViewAdvanced->mForm, |
|
1221 iterator.index(4, groupIndex)); |
|
1222 mIpv4SecondaryDnsAddressWidget = subGetWidgetByIndex( |
|
1223 mTestViewAdvanced->mForm, |
|
1224 iterator.index(5, groupIndex)); |
|
1225 } else { |
|
1226 // IPv6 |
|
1227 mIpv6DnsAddressAutomaticWidget = subGetWidgetByIndex( |
|
1228 mTestViewAdvanced->mForm, |
|
1229 iterator.index(1, groupIndex)); |
|
1230 mIpv6PrimaryDnsAddressWidget = subGetWidgetByIndex( |
|
1231 mTestViewAdvanced->mForm, |
|
1232 iterator.index(2, groupIndex)); |
|
1233 mIpv6SecondaryDnsAddressWidget = subGetWidgetByIndex( |
|
1234 mTestViewAdvanced->mForm, |
|
1235 iterator.index(3, groupIndex)); |
|
1236 } |
|
1237 } else { |
|
1238 // Proxy settings group |
|
1239 mProxyServerAddressWidget = subGetWidgetByIndex( |
|
1240 mTestViewAdvanced->mForm, |
|
1241 iterator.index(0, groupIndex)); |
|
1242 mProxyPortNumberWidget = subGetWidgetByIndex( |
|
1243 mTestViewAdvanced->mForm, |
|
1244 iterator.index(1, groupIndex)); |
|
1245 } |
|
1246 } |
|
1247 |
|
1248 /** |
|
1249 * Gets an UI widget from HbDataForm by index. |
|
1250 */ |
|
1251 HbWidget *TestCpPacketDataApPlugin::subGetWidgetByIndex( |
|
1252 HbDataForm *form, |
|
1253 const QModelIndex &index) |
|
1254 { |
|
1255 HbDataFormViewItem *viewItem = qobject_cast<HbDataFormViewItem *> |
|
1256 (form->itemByIndex(index)); |
|
1257 HbWidget *widget = viewItem->dataItemContentWidget(); |
|
1258 //QString widgetClassName(widget->metaObject()->className()); |
|
1259 //qDebug() << widgetClassName; |
|
1260 return widget; |
|
1261 } |
|
1262 |
|
1263 /** |
|
1264 * Writes initial settings to CommsDat needed by some test cases. |
|
1265 */ |
|
1266 void TestCpPacketDataApPlugin::subInitializeCommsDat() |
|
1267 { |
|
1268 QScopedPointer<CmManagerShim> cmManager(new CmManagerShim); |
|
1269 QScopedPointer<CmConnectionMethodShim> connectionMethod( |
|
1270 cmManager->connectionMethod(testApId)); |
|
1271 |
|
1272 // Initial settings |
|
1273 connectionMethod->setStringAttribute( |
|
1274 CMManagerShim::PacketDataIFAuthName, |
|
1275 tooLongUserName); |
|
1276 |
|
1277 connectionMethod->update(); |
|
1278 } |
|
527 |
1279 |
528 /** |
1280 /** |
529 * Creates the settings view and shows it. |
1281 * Creates the settings view and shows it. |
530 */ |
1282 */ |
531 void TestCpPacketDataApPlugin::subCreateSettingsView(uint connectionMethodId) |
1283 void TestCpPacketDataApPlugin::subCreateSettingsView(uint connectionMethodId) |
547 void TestCpPacketDataApPlugin::subVerifyString( |
1299 void TestCpPacketDataApPlugin::subVerifyString( |
548 CMManagerShim::ConnectionMethodAttribute attribute, |
1300 CMManagerShim::ConnectionMethodAttribute attribute, |
549 HbDataFormModelItem *item, |
1301 HbDataFormModelItem *item, |
550 QString expected) |
1302 QString expected) |
551 { |
1303 { |
1304 QTest::qWait(waitTime); |
|
1305 |
|
552 // Read attribute value from CommsDat |
1306 // Read attribute value from CommsDat |
553 QScopedPointer<CmManagerShim> cmManager(new CmManagerShim); |
1307 QScopedPointer<CmManagerShim> cmManager(new CmManagerShim); |
554 QScopedPointer<CmConnectionMethodShim> connectionMethod( |
1308 QScopedPointer<CmConnectionMethodShim> connectionMethod( |
555 cmManager->connectionMethod(testApId)); |
1309 cmManager->connectionMethod(testApId)); |
556 QString commsdat = connectionMethod->getStringAttribute(attribute); |
1310 QString commsdat = connectionMethod->getStringAttribute(attribute); |
567 * Clears a HbLineEdit. |
1321 * Clears a HbLineEdit. |
568 */ |
1322 */ |
569 void TestCpPacketDataApPlugin::subClearLineEdit( |
1323 void TestCpPacketDataApPlugin::subClearLineEdit( |
570 uint length) |
1324 uint length) |
571 { |
1325 { |
572 // Erase old string |
|
573 QTest::qWait(5000); // TODO: Remove this when item specific menu doesn't pop up anymore |
|
574 |
|
575 // Move cursor to end of string |
1326 // Move cursor to end of string |
576 //HbAutoTest::keyClick(mMainWindow, Qt::Key_End, 0, waitTime); // doesn't seem to do anything? |
1327 //HbAutoTest::keyClick(mMainWindow, Qt::Key_End, Qt::ControlModifier, waitTime); // doesn't seem to do anything? |
577 HbAutoTest::keyClick(mMainWindow, Qt::Key_Down, 0, waitTime); |
1328 HbAutoTest::keyClick(mMainWindow, Qt::Key_Down, 0, waitTime); |
578 HbAutoTest::keyClick(mMainWindow, Qt::Key_Down, 0, waitTime); |
1329 HbAutoTest::keyClick(mMainWindow, Qt::Key_Down, 0, waitTime); |
579 HbAutoTest::keyClick(mMainWindow, Qt::Key_Down, 0, waitTime); |
1330 HbAutoTest::keyClick(mMainWindow, Qt::Key_Down, 0, waitTime); |
580 for (int i=0; i<25; i++) { |
1331 for (int i=0; i<25; i++) { |
581 HbAutoTest::keyClick(mMainWindow, Qt::Key_Right, 0, waitTime); |
1332 HbAutoTest::keyClick(mMainWindow, Qt::Key_Right, 0, waitTime); |
582 } |
1333 } |
1334 // Erase string |
|
583 for (int i=0; i<length; i++) { |
1335 for (int i=0; i<length; i++) { |
584 HbAutoTest::keyClick(mMainWindow, Qt::Key_Backspace, 0, waitTime); |
1336 HbAutoTest::keyClick(mMainWindow, Qt::Key_Backspace, 0, waitTime); |
585 } |
1337 } |
586 } |
1338 } |
587 |
1339 |
602 */ |
1354 */ |
603 void TestCpPacketDataApPlugin::subVerifyBool( |
1355 void TestCpPacketDataApPlugin::subVerifyBool( |
604 CMManagerShim::ConnectionMethodAttribute attribute, |
1356 CMManagerShim::ConnectionMethodAttribute attribute, |
605 bool expected) |
1357 bool expected) |
606 { |
1358 { |
1359 QTest::qWait(waitTime); |
|
1360 |
|
607 // Read attribute value from CommsDat |
1361 // Read attribute value from CommsDat |
608 QScopedPointer<CmManagerShim> cmManager(new CmManagerShim); |
1362 QScopedPointer<CmManagerShim> cmManager(new CmManagerShim); |
609 QScopedPointer<CmConnectionMethodShim> connectionMethod( |
1363 QScopedPointer<CmConnectionMethodShim> connectionMethod( |
610 cmManager->connectionMethod(testApId)); |
1364 cmManager->connectionMethod(testApId)); |
611 bool commsdat = connectionMethod->getBoolAttribute(attribute); |
1365 bool commsdat = connectionMethod->getBoolAttribute(attribute); |
1366 |
|
1367 QCOMPARE(commsdat, expected); |
|
1368 } |
|
1369 |
|
1370 /** |
|
1371 * Verifies that given attribute contains expected integer value in CommsDat. |
|
1372 */ |
|
1373 void TestCpPacketDataApPlugin::subVerifyUint( |
|
1374 CMManagerShim::ConnectionMethodAttribute attribute, |
|
1375 uint expected) |
|
1376 { |
|
1377 QTest::qWait(waitTime); |
|
1378 |
|
1379 // Read attribute value from CommsDat |
|
1380 QScopedPointer<CmManagerShim> cmManager(new CmManagerShim); |
|
1381 QScopedPointer<CmConnectionMethodShim> connectionMethod( |
|
1382 cmManager->connectionMethod(testApId)); |
|
1383 uint commsdat = connectionMethod->getIntAttribute(attribute); |
|
612 |
1384 |
613 QCOMPARE(commsdat, expected); |
1385 QCOMPARE(commsdat, expected); |
614 } |
1386 } |
615 |
1387 |
616 /** |
1388 /** |
634 } |
1406 } |
635 |
1407 |
636 Q_ASSERT(target); |
1408 Q_ASSERT(target); |
637 HbAutoTest::mouseClick(mMainWindow, static_cast<HbWidget *>(target)); |
1409 HbAutoTest::mouseClick(mMainWindow, static_cast<HbWidget *>(target)); |
638 } |
1410 } |
1411 |
|
1412 /** |
|
1413 * Scrolls the tested view to the bottom. |
|
1414 */ |
|
1415 void TestCpPacketDataApPlugin::subScrollToBottom() |
|
1416 { |
|
1417 // Scroll to the bottom of the view |
|
1418 HbAutoTest::mousePress(mMainWindow, mTestView, scrollMiddle); |
|
1419 QTest::qWait(1000); |
|
1420 HbAutoTest::mouseMove(mMainWindow, mTestView, scrollTop); |
|
1421 HbAutoTest::mouseRelease(mMainWindow, mTestView, scrollTop); |
|
1422 } |
|
1423 |
|
1424 /** |
|
1425 * Scrolls the tested view to the top. |
|
1426 */ |
|
1427 void TestCpPacketDataApPlugin::subScrollToTop() |
|
1428 { |
|
1429 // Scroll to the top of the view |
|
1430 HbAutoTest::mousePress(mMainWindow, mTestView, scrollMiddle); |
|
1431 QTest::qWait(1000); |
|
1432 HbAutoTest::mouseMove(mMainWindow, mTestView, scrollBottom); |
|
1433 HbAutoTest::mouseRelease(mMainWindow, mTestView, scrollBottom); |
|
1434 } |