58 static const QPoint connectionNameLabel(175, 70);

    62 static const QPoint scrollMiddle(350, 280);

    59 

    63 static const QPoint scrollTop(350, 50);

    60 static const QPoint connectionNameLineEdit(330, 110);

    64 static const QPoint scrollBottom(350, 520);

    61 

    65 

    62 static const QPoint wlanNetworkNameLineEdit(330, 190);

    66 // Use positive offset if dropdown opens under the combobox

    63 

    67 static const QPoint comboBoxItemOffset(0, 55);

    64 static const QPoint networkStatusComboBox(175, 270);

    68 // Use negative offset if dropdown opens above the combobox

    65 static const QPoint networkStatusPublic(175, 325);

    69 static const QPoint comboBoxItemNegativeOffset(0, -50);

    66 static const QPoint networkStatusHidden(175, 375);

    70 

    67 

    71 static const QPoint exitEditorOffset(-10, -20);

    68 static const QPoint networkModeComboBox(175, 365);

    72 

    69 static const QPoint networkModeIntrastructure(175, 415);

    73 static const QPoint messageBoxOkButtonOffset(160, 140);

    70 static const QPoint networkModeAdHoc(175, 465);

    74 

    71 

    75 // Advanced settings groups

    72 static const QPoint securityModeComboBox(175, 460);

    76 static const QPoint ipv4Group(160, 10);

    73 #ifndef WLAN_SECURITY_PLUGINS_AVAILABLE

    77 static const QPoint ipv6Group(160, 60);

    74 static const QPoint securityModeOpen(175, 510);

    78 static const QPoint proxyGroup(160, 110);

    75 #else

    76 static const QPoint securityModeOpen(175, 260);

    77 static const QPoint securityModeWep(175, 305);

    78 static const QPoint securityModeWpaWpa2(175, 355);

    79 static const QPoint securityModeWpa2(175, 405);

    80 #endif

    81 

    82 static const QPoint homepageLineEdit(330, 545);

    83 

    84 static const QPoint messageBoxOkButton(170, 320);

   124     QPluginLoader loader(dir.absoluteFilePath(pluginName));

   118     mPluginLoader = new QPluginLoader(dir.absoluteFilePath(pluginName));

   125     mPlugin = qobject_cast<CpBearerApPluginInterface *>(loader.instance());

   119     mPlugin = qobject_cast<CpBearerApPluginInterface *>(mPluginLoader->instance());

   171     HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLineEdit);

   172     HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget);

   172     

   173     

   173     // Erase old string

   174     // Erase old string

   174     subClearLineEdit(CMManagerShim::CmNameLength);

   175     QString text = mTestView->mConnectionNameItem->contentWidgetData("text").toString();

   176     subClearLineEdit(text.size());

   179     HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLabel);

   181     HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget, exitEditorOffset);

   215     HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLineEdit);    

   217     HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget);

   216     // Erase old string

   218 

   217     subClearLineEdit(CMManagerShim::CmNameLength);

   219     // Erase old string

   218     

   220     QString text = mTestView->mConnectionNameItem->contentWidgetData("text").toString();

   219     HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLabel);

   221     subClearLineEdit(text.size());

   222     

   223     HbAutoTest::mouseClick(mMainWindow, mConnectionNameWidget, exitEditorOffset);

   223     HbAutoTest::mouseClick(mMainWindow, mTestView, messageBoxOkButton);

   227     HbAutoTest::mouseClick(

   228         mMainWindow,

   229         mTestView->mMessageBox.data(),

   230         messageBoxOkButtonOffset);

   240     HbAutoTest::mouseClick(mMainWindow, mTestView, wlanNetworkNameLineEdit);

   247     HbAutoTest::mouseClick(mMainWindow, mWlanNetworkNameWidget);

   241     

   248     

   242     // Erase old string

   249     // Erase old string

   243     subClearLineEdit(CMManagerShim::WlanSSIDLength);

   250     QString text = mTestView->mWlanNetworkNameItem->contentWidgetData("text").toString();

   251     subClearLineEdit(text.size());

   248     HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLabel);

   256     HbAutoTest::mouseClick(mMainWindow, mWlanNetworkNameWidget, exitEditorOffset);

   284     HbAutoTest::mouseClick(mMainWindow, mTestView, wlanNetworkNameLineEdit);

   292     HbAutoTest::mouseClick(mMainWindow, mWlanNetworkNameWidget);

   285     

   293     

   286     // Erase old string

   294     // Erase old string

   287     subClearLineEdit(CMManagerShim::WlanSSIDLength);

   295     QString text = mTestView->mWlanNetworkNameItem->contentWidgetData("text").toString();

   288     

   296     subClearLineEdit(text.size());

   289     HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLabel);

   297     

   298     HbAutoTest::mouseClick(mMainWindow, mWlanNetworkNameWidget, exitEditorOffset);

   293     HbAutoTest::mouseClick(mMainWindow, mTestView, messageBoxOkButton);

   302     HbAutoTest::mouseClick(

   303         mMainWindow,

   304         mTestView->mMessageBox.data(),

   305         messageBoxOkButtonOffset);

   308     HbAutoTest::mouseClick(mMainWindow, mTestView, networkStatusComboBox, 100);

   323     HbAutoTest::mouseClick(mMainWindow, mNetworkStatusWidget);

   309     HbAutoTest::mouseClick(mMainWindow, mTestView, networkStatusHidden, 100);

   324     HbAutoTest::mouseClick(mMainWindow, mNetworkStatusWidget, hiddenPointOffset, 100);

   313     HbAutoTest::mouseClick(mMainWindow, mTestView, networkStatusComboBox, 100);

   328     HbAutoTest::mouseClick(mMainWindow, mNetworkStatusWidget);

   314     HbAutoTest::mouseClick(mMainWindow, mTestView, networkStatusPublic, 100);

   329     HbAutoTest::mouseClick(mMainWindow, mNetworkStatusWidget, publicPointOffset, 100);

   324     HbAutoTest::mouseClick(mMainWindow, mTestView, networkModeComboBox, 100);

   342     HbAutoTest::mouseClick(mMainWindow, mNetworkModeWidget);

   325     HbAutoTest::mouseClick(mMainWindow, mTestView, networkModeAdHoc, 100);

   343     HbAutoTest::mouseClick(mMainWindow, mNetworkModeWidget, adHocPointOffset, 100);

   329     HbAutoTest::mouseClick(mMainWindow, mTestView, networkModeComboBox, 100);

   347     HbAutoTest::mouseClick(mMainWindow, mNetworkModeWidget);

   330     HbAutoTest::mouseClick(mMainWindow, mTestView, networkModeIntrastructure, 100);

   348     HbAutoTest::mouseClick(mMainWindow, mNetworkModeWidget, infraPointOffset, 100);

   340     // Ensure security mode is open

   358     QPointF openPointOffset = comboBoxItemNegativeOffset * 4;

   341     HbAutoTest::mouseClick(mMainWindow, mTestView, securityModeComboBox, 100);

   359     QPointF wepPointOffset = comboBoxItemNegativeOffset * 3;

   342     QTest::qWait(100);

   360     QPointF wpaPointOffset = comboBoxItemNegativeOffset * 2;

   343     HbAutoTest::mouseClick(mMainWindow, mTestView, securityModeOpen, 100);

   361     QPointF wpa2PointOffset = comboBoxItemNegativeOffset;

   362 #else

   363     QPointF openPointOffset = comboBoxItemNegativeOffset;

   364 #endif

   365     

   366 #ifdef WLAN_SECURITY_PLUGINS_AVAILABLE

   367     // Set security mode to WEP

   368     HbAutoTest::mouseClick(mMainWindow, mSecurityModeWidget);

   369     QTest::qWait(100);

   370     HbAutoTest::mouseClick(mMainWindow, mSecurityModeWidget, wepPointOffset, 100);

   371     subVerifyUint(

   372         CMManagerShim::WlanSecurityMode,

   373         CMManagerShim::WlanSecModeWep);

   374     

   375     QTest::qWait(1000);

   376 #endif

   377     // Set security mode to open

   378     HbAutoTest::mouseClick(mMainWindow, mSecurityModeWidget);

   379     QTest::qWait(100);

   380     HbAutoTest::mouseClick(mMainWindow, mSecurityModeWidget, openPointOffset, 100);

   347 

   384 }

   348     QTest::qWait(1000);

   385 

   349 

   386 /**

   350     // Set security mode to WEP

   387  * Scrolls the tested view to the bottom.

   351     HbAutoTest::mouseClick(mMainWindow, mTestView, securityModeComboBox, 100);

   388  */

   352     QTest::qWait(100);

   389 void TestCpWlanApPlugin::tcScrollToBottom()

   353     HbAutoTest::mouseClick(mMainWindow, mTestView, securityModeWep, 100);

   390 {

   354     subVerifyUint(

   391     subScrollToBottom();

   355         CMManagerShim::WlanSecurityMode,

   392 }

   356         CMManagerShim::WlanSecModeWep);

   393 

   357     

   394 /**

   358     QTest::qWait(1000);

   395  * Gets UI widget pointers because homepage view item may have been

   359 #endif

   396  * created before it was visible on the UI.

   360     

   397  */

   361     // Set security mode to open

   398 void TestCpWlanApPlugin::tcGetUiWidgets()

   362     HbAutoTest::mouseClick(mMainWindow, mTestView, securityModeComboBox, 100);

   399 {

   363     QTest::qWait(100);

   400     subGetUiWidgets();

   364     HbAutoTest::mouseClick(mMainWindow, mTestView, securityModeOpen, 100);

   365     subVerifyUint(

   366         CMManagerShim::WlanSecurityMode,

   367         CMManagerShim::WlanSecModeOpen);

   378     HbAutoTest::mouseClick(mMainWindow, mTestView, homepageLineEdit);

   411     HbAutoTest::mouseClick(mMainWindow, mHomepageWidget);

   387     HbAutoTest::mouseClick(mMainWindow, mTestView, connectionNameLabel);

   420     HbAutoTest::mouseClick(mMainWindow, mHomepageWidget, exitEditorOffset);

   404 // Doesn't work always, view goes blank sometimes, Orbit bug?

   437     QTest::newRow("long")

   405 //    QTest::newRow("long")

   438         << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html"

   406 //        << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html"

   439         << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html";

   407 //        << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html";

   417  * Tests advanced settings view (which is currently empty).

   449  * Opens advanced settings view.

   418  */

   450  */

   419 void TestCpWlanApPlugin::tcAdvancedSettings()

   451 void TestCpWlanApPlugin::tcOpenAdvancedSettingsView()

   429 

   461     

   430     QTest::qWait(2000);

   462     QTest::qWait(1000);

   431     

   463     

   464     mTestViewAdvanced = static_cast<CpWlanApAdvancedView *>(mMainWindow->currentView());

   465 }

   466 

   467 /**

   468  * Expands the IPv4 settings group and gets UI widget pointers.

   469  */

   470 void TestCpWlanApPlugin::tcExpandIpv4SettingsAndGetUiWidgets()

   471 {

   472     HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, ipv4Group);

   473     

   474     QTest::qWait(500);

   475 

   476     subGetAdvancedUiWidgets(0);

   477 }

   478 

   479 /**

   480  * Tests enabling of automatic phone IP address.

   481  */

   482 void TestCpWlanApPlugin::tcEnableAutomaticIpv4Address()

   483 {

   484     Qt::CheckState state = static_cast<Qt::CheckState>

   485         (mTestViewAdvanced->mIpv4Automatic->contentWidgetData("checkState").toInt());

   486     if (state == Qt::Checked) {

   487         // Disable automatic IP address

   488         HbAutoTest::mouseClick(mMainWindow, mIpv4AddressAutomaticWidget);

   489     }

   490     // Enable automatic IP address

   491     HbAutoTest::mouseClick(mMainWindow, mIpv4AddressAutomaticWidget);

   492     subVerifyBool(

   493         CMManagerShim::CmIPAddrFromServer,

   494         true);

   495     

   496     // Ensure that editing the IP address is not allowed

   497     HbAutoTest::mouseClick(mMainWindow, mIpv4AddressWidget);

   498     HbAutoTest::mouseClick(mMainWindow, mIpv4SubnetMaskWidget);

   499     HbAutoTest::mouseClick(mMainWindow, mIpv4GatewayWidget);

   500 }

   501 

   502 /**

   503  * Tests disabling of automatic phone IP address.

   504  */

   505 void TestCpWlanApPlugin::tcEnableUserDefinedIpv4Address()

   506 {

   507     Qt::CheckState state = static_cast<Qt::CheckState>

   508         (mTestViewAdvanced->mIpv4Automatic->contentWidgetData("checkState").toInt());

   509     if (state == Qt::Checked) {

   510         // Disable automatic IP address

   511         HbAutoTest::mouseClick(mMainWindow, mIpv4AddressAutomaticWidget);

   512     }

   513     // Can't verify the setting from CommsDat here, because CMManager will

   514     // set it back to true if no valid IP address is yet defined. The flag

   515     // is verified in tcChangeIpAddress().

   516 }

   517 

   518 /**

   519  * Tests changing of IP address.

   520  */

   521 void TestCpWlanApPlugin::tcChangeIpAddress()

   522 {

   523     QFETCH(QString, string);

   524     QFETCH(QString, result);

   525     

   526     HbAutoTest::mouseClick(mMainWindow, mIpv4AddressWidget);

   527     

   528     // Erase old string

   529     QString text = mTestViewAdvanced->mIpv4Address->contentWidgetData("text").toString();

   530     subClearLineEdit(text.size());

   531     

   532     // Enter new string

   533     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

   534 

   535     HbAutoTest::mouseClick(mMainWindow, mIpv4AddressWidget, exitEditorOffset);

   536 

   537     // Verify both commsdat and UI widget

   538     subVerifyString(

   539         CMManagerShim::CmIPAddress,

   540         mTestViewAdvanced->mIpv4Address,

   541         result);

   542     subVerifyBool(

   543         CMManagerShim::CmIPAddrFromServer,

   544         false);

   545 }

   546 

   547 /**

   548  * Test data for IP address change test case.

   549  */

   550 void TestCpWlanApPlugin::tcChangeIpAddress_data()

   551 {

   552     QTest::addColumn<QString>("string");

   553     QTest::addColumn<QString>("result");

   554   

   555     QTest::newRow("too long")

   556         << "255.255.255.2551234"

   557         << "255.255.255.255";

   558     QTest::newRow("normal")

   559         << "192.168.0.1"

   560         << "192.168.0.1";

   561 }

   562 

   563 /**

   564  * Tests changing of subnet mask.

   565  */

   566 void TestCpWlanApPlugin::tcChangeSubnetMask()

   567 {

   568     QFETCH(QString, string);

   569     QFETCH(QString, result);

   570     

   571     HbAutoTest::mouseClick(mMainWindow, mIpv4SubnetMaskWidget);

   572     

   573     // Erase old string

   574     QString text = mTestViewAdvanced->mIpv4SubnetMask->contentWidgetData("text").toString();

   575     subClearLineEdit(text.size());

   576     

   577     // Enter new string

   578     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

   579 

   580     HbAutoTest::mouseClick(mMainWindow, mIpv4SubnetMaskWidget, exitEditorOffset);

   581 

   582     // Verify both commsdat and UI widget

   583     subVerifyString(

   584         CMManagerShim::CmIPNetmask,

   585         mTestViewAdvanced->mIpv4SubnetMask,

   586         result);

   587 }

   588 

   589 /**

   590  * Test data for subnet mask change test case.

   591  */

   592 void TestCpWlanApPlugin::tcChangeSubnetMask_data()

   593 {

   594     QTest::addColumn<QString>("string");

   595     QTest::addColumn<QString>("result");

   596   

   597     QTest::newRow("empty")

   598         << ""

   599         << "0.0.0.0";

   600     QTest::newRow("zero")

   601         << "0.0.0.0"

   602         << "0.0.0.0";

   603     QTest::newRow("too long")

   604         << "255.255.255.2551234"

   605         << "255.255.255.255";

   606     QTest::newRow("normal")

   607         << "192.168.0.1"

   608         << "192.168.0.1";

   609 }

   610 

   611 /**

   612  * Tests invalid subnet mask.

   613  */

   614 void TestCpWlanApPlugin::tcInvalidSubnetMask()

   615 {

   616     QString previous = 

   617         mTestViewAdvanced->mIpv4SubnetMask->contentWidgetData("text").toString();

   618     

   619     HbAutoTest::mouseClick(mMainWindow, mIpv4SubnetMaskWidget);

   620     

   621     // Erase old string

   622     QString text = mTestViewAdvanced->mIpv4SubnetMask->contentWidgetData("text").toString();

   623     subClearLineEdit(text.size());

   624     

   625     // Enter new string

   626     HbAutoTest::keyClicks(mMainWindow, "999.999.999.999", 0, waitTime);

   627 

   628     HbAutoTest::mouseClick(mMainWindow, mIpv4SubnetMaskWidget, exitEditorOffset);

   629 

   630     QTest::qWait(100);

   631     // Dismiss messagebox

   632     HbAutoTest::mouseClick(

   633         mMainWindow,

   634         mTestViewAdvanced->mMessageBox.data(),

   635         messageBoxOkButtonOffset);

   636     

   637     // Verify both commsdat and UI widget

   638     subVerifyString(

   639         CMManagerShim::CmIPNetmask,

   640         mTestViewAdvanced->mIpv4SubnetMask,

   641         previous);

   642 }

   643 

   644 /**

   645  * Tests changing of gateway.

   646  */

   647 void TestCpWlanApPlugin::tcChangeGateway()

   648 {

   649     QFETCH(QString, string);

   650     QFETCH(QString, result);

   651     

   652     HbAutoTest::mouseClick(mMainWindow, mIpv4GatewayWidget);

   653     

   654     // Erase old string

   655     QString text = mTestViewAdvanced->mIpv4Gateway->contentWidgetData("text").toString();

   656     subClearLineEdit(text.size());

   657     

   658     // Enter new string

   659     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

   660 

   661     HbAutoTest::mouseClick(mMainWindow, mIpv4GatewayWidget, exitEditorOffset);

   662 

   663     // Verify both commsdat and UI widget

   664     subVerifyString(

   665         CMManagerShim::CmIPGateway,

   666         mTestViewAdvanced->mIpv4Gateway,

   667         result);

   668 }

   669 

   670 /**

   671  * Test data for gateway change test case.

   672  */

   673 void TestCpWlanApPlugin::tcChangeGateway_data()

   674 {

   675     QTest::addColumn<QString>("string");

   676     QTest::addColumn<QString>("result");

   677   

   678     QTest::newRow("empty")

   679         << ""

   680         << "0.0.0.0";

   681     QTest::newRow("zero")

   682         << "0.0.0.0"

   683         << "0.0.0.0";

   684     QTest::newRow("too long")

   685         << "255.255.255.2551234"

   686         << "255.255.255.255";

   687     QTest::newRow("normal")

   688         << "192.168.0.1"

   689         << "192.168.0.1";

   690 }

   691 

   692 /**

   693  * Tests invalid gateway address.

   694  */

   695 void TestCpWlanApPlugin::tcInvalidGateway()

   696 {

   697     QString previous = 

   698         mTestViewAdvanced->mIpv4Gateway->contentWidgetData("text").toString();

   699     

   700     HbAutoTest::mouseClick(mMainWindow, mIpv4GatewayWidget);

   701     

   702     // Erase old string

   703     QString text = mTestViewAdvanced->mIpv4Gateway->contentWidgetData("text").toString();

   704     subClearLineEdit(text.size());

   705     

   706     // Enter new string

   707     HbAutoTest::keyClicks(mMainWindow, "999.999.999.999", 0, waitTime);

   708 

   709     HbAutoTest::mouseClick(mMainWindow, mIpv4GatewayWidget, exitEditorOffset);

   710 

   711     QTest::qWait(100);

   712     // Dismiss messagebox

   713     HbAutoTest::mouseClick(

   714         mMainWindow,

   715         mTestViewAdvanced->mMessageBox.data(),

   716         messageBoxOkButtonOffset);

   717     

   718     // Verify both commsdat and UI widget

   719     subVerifyString(

   720         CMManagerShim::CmIPGateway,

   721         mTestViewAdvanced->mIpv4Gateway,

   722         previous);

   723 }

   724 

   725 /**

   726  * Scrolls the tested view to the bottom.

   727  */

   728 void TestCpWlanApPlugin::tcScrollToBottom2()

   729 {

   730     subScrollToBottom();

   731 }

   732 

   733 /**

   734  * Tests enabling of automatic IPv4 DNS addresses.

   735  */

   736 void TestCpWlanApPlugin::tcEnableAutomaticIpv4DnsAddress()

   737 {

   738     Qt::CheckState state = static_cast<Qt::CheckState>

   739         (mTestViewAdvanced->mIpv4DnsAutomatic->contentWidgetData("checkState").toInt());

   740     if (state == Qt::Checked) {

   741         // Disable automatic IPv4 DNS address

   742         HbAutoTest::mouseClick(mMainWindow, mIpv4DnsAddressAutomaticWidget);

   743     }

   744     // Enable automatic IPv4 DNS address

   745     HbAutoTest::mouseClick(mMainWindow, mIpv4DnsAddressAutomaticWidget);

   746     subVerifyBool(

   747         CMManagerShim::CmIPDNSAddrFromServer,

   748         true);

   749     

   750     // Ensure that editing the IP address is not allowed

   751     HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget);

   752     HbAutoTest::mouseClick(mMainWindow, mIpv4SecondaryDnsAddressWidget);

   753 }

   754 

   755 /**

   756  * Tests disabling of automatic IPv4 DNS addresses.

   757  */

   758 void TestCpWlanApPlugin::tcEnableUserDefinedIpv4DnsAddress()

   759 {

   760     Qt::CheckState state = static_cast<Qt::CheckState>

   761         (mTestViewAdvanced->mIpv4DnsAutomatic->contentWidgetData("checkState").toInt());

   762     if (state == Qt::Checked) {

   763         // Disable automatic IPv4 DNS address

   764         HbAutoTest::mouseClick(mMainWindow, mIpv4DnsAddressAutomaticWidget);

   765     }

   766     // Can't verify the setting from CommsDat here, because CMManager will

   767     // set it back to true if no valid IP address is yet defined. The flag

   768     // is verified in tcChangeIpv4DnsAddress().

   769 }

   770 

   771 /**

   772  * Tests changing of IPv4 DNS addresses.

   773  */

   774 void TestCpWlanApPlugin::tcChangeIpv4DnsAddress()

   775 {

   776     QFETCH(QString, string);

   777     QFETCH(QString, result);

   778     

   779     // Primary DNS address

   780     HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget);

   781     

   782     // Erase old string

   783     QString text = mTestViewAdvanced->mIpv4DnsAddress1->contentWidgetData("text").toString();

   784     subClearLineEdit(text.size());

   785     

   786     // Enter new string

   787     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

   788 

   789     HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget, exitEditorOffset);

   790 

   791     // Verify both commsdat and UI widget

   792     subVerifyString(

   793         CMManagerShim::CmIPNameServer1,

   794         mTestViewAdvanced->mIpv4DnsAddress1,

   795         result);

   796     

   797     // Secondary DNS address

   798     HbAutoTest::mouseClick(mMainWindow, mIpv4SecondaryDnsAddressWidget);

   799     

   800     // Erase old string

   801     text = mTestViewAdvanced->mIpv4DnsAddress2->contentWidgetData("text").toString();

   802     subClearLineEdit(text.size());

   803     

   804     // Enter new string

   805     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

   806 

   807     HbAutoTest::mouseClick(mMainWindow, mIpv4SecondaryDnsAddressWidget, exitEditorOffset);

   808 

   809     // Verify both commsdat and UI widget

   810     subVerifyString(

   811         CMManagerShim::CmIPNameServer2,

   812         mTestViewAdvanced->mIpv4DnsAddress2,

   813         result);

   814     

   815     // Verify user defined address is in use

   816     subVerifyBool(

   817         CMManagerShim::CmIPDNSAddrFromServer,

   818         false);

   819 }

   820 

   821 /**

   822  * Test data for IPv4 DNS address change test case.

   823  */

   824 void TestCpWlanApPlugin::tcChangeIpv4DnsAddress_data()

   825 {

   826     QTest::addColumn<QString>("string");

   827     QTest::addColumn<QString>("result");

   828   

   829     QTest::newRow("too long")

   830         << "255.255.255.2551234"

   831         << "255.255.255.255";

   832     QTest::newRow("normal")

   833         << "192.168.0.1"

   834         << "192.168.0.1";

   835 }

   836 

   837 /**

   838  * Tests invalid IPv4 DNS address.

   839  */

   840 void TestCpWlanApPlugin::tcInvalidIpv4DnsAddress()

   841 {

   842     QString previous = 

   843         mTestViewAdvanced->mIpv4DnsAddress1->contentWidgetData("text").toString();

   844     

   845     HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget);

   846     

   847     // Erase old string

   848     QString text = mTestViewAdvanced->mIpv4DnsAddress1->contentWidgetData("text").toString();

   849     subClearLineEdit(text.size());

   850     

   851     // Enter new string

   852     HbAutoTest::keyClicks(mMainWindow, "999.999.999.999", 0, waitTime);

   853 

   854     HbAutoTest::mouseClick(mMainWindow, mIpv4PrimaryDnsAddressWidget, exitEditorOffset);

   855 

   856     QTest::qWait(100);

   857     // Dismiss messagebox

   858     HbAutoTest::mouseClick(

   859         mMainWindow,

   860         mTestViewAdvanced->mMessageBox.data(),

   861         messageBoxOkButtonOffset);

   862     

   863     // Verify both commsdat and UI widget

   864     subVerifyString(

   865         CMManagerShim::CmIPNameServer1,

   866         mTestViewAdvanced->mIpv4DnsAddress1,

   867         previous);

   868 }

   869 

   870 /**

   871  * Scrolls the tested view to the top.

   872  */

   873 void TestCpWlanApPlugin::tcScrollToTop()

   874 {

   875     subScrollToTop();

   876 }

   877 

   878 /**

   879  * Collapses the IPv4 settings group.

   880  */

   881 void TestCpWlanApPlugin::tcCollapseIpv4Settings()

   882 {

   883     HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, ipv4Group);

   884 }

   885 

   886 /**

   887  * Expands the IPv6 settings group and gets UI widget pointers.

   888  */

   889 void TestCpWlanApPlugin::tcExpandIpv6SettingsAndGetUiWidgets()

   890 {

   891     HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, ipv6Group);

   892 

   893     QTest::qWait(500);

   894     

   895     subGetAdvancedUiWidgets(1);

   896 }

   897 

   898 /**

   899  * Tests enabling of automatic IPv6 DNS addresses.

   900  */

   901 void TestCpWlanApPlugin::tcEnableAutomaticIpv6DnsAddress()

   902 {

   903     // Enable automatic IPv6 DNS address

   904     QPointF automaticPointOffset = comboBoxItemOffset;

   905     HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget);

   906     QTest::qWait(100);

   907     HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget, automaticPointOffset, 100);

   908     QTest::qWait(100);

   909     subVerifyBool(

   910         CMManagerShim::CmIP6DNSAddrFromServer,

   911         true);

   912     

   913     // Ensure that editing the IP address is not allowed

   914     HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget);

   915     HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget);

   916 }

   917 

   918 /**

   919  * Tests enabling of well-known IPv6 DNS addresses.

   920  */

   921 void TestCpWlanApPlugin::tcEnableWellKnownIpv6DnsAddress()

   922 {

   923     // Enable well-known IPv6 DNS address

   924     QPointF wellKnownPointOffset = comboBoxItemOffset * 2;

   925     HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget);

   926     QTest::qWait(100);

   927     HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget, wellKnownPointOffset, 100);

   928     QTest::qWait(100);

   929     subVerifyBool(

   930         CMManagerShim::CmIP6DNSAddrFromServer,

   931         false);

   932     subVerifyString(

   933         CMManagerShim::CmIP6NameServer1,

   934         mTestViewAdvanced->mIpv6DnsAddress1,

   935         "fec0:000:0000:ffff::1");

   936     subVerifyString(

   937         CMManagerShim::CmIP6NameServer2,

   938         mTestViewAdvanced->mIpv6DnsAddress2,

   939         "fec0:000:0000:ffff::2");

   940     

   941     // Ensure that editing the IP address is not allowed

   942     HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget);

   943     HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget);

   944 }

   945 

   946 /**

   947  * Tests enabling of user defined IPv6 DNS addresses.

   948  */

   949 void TestCpWlanApPlugin::tcEnableUserDefinedIpv6DnsAddress()

   950 {

   951     // Select user defined IPv6 DNS address

   952     QPointF userDefinedPointOffset = comboBoxItemOffset * 3;

   953     //QPointF userDefinedPointOffset(0, 160);

   954     HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget);

   955     QTest::qWait(100);

   956     HbAutoTest::mouseClick(mMainWindow, mIpv6DnsAddressAutomaticWidget, userDefinedPointOffset, 100);

   957     QTest::qWait(100);

   958     // Can't verify the setting from CommsDat here, because CMManager will

   959     // set it back to true if no valid IP address is yet defined. The flag

   960     // is verified in tcChangeIpv4DnsAddress().

   961 }

   962 

   963 /**

   964  * Tests changing of IPv6 DNS addresses.

   965  */

   966 void TestCpWlanApPlugin::tcChangeIpv6DnsAddress()

   967 {

   968     QFETCH(QString, string);

   969     QFETCH(QString, result);

   970     

   971     // Primary DNS address

   972     HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget);

   973     

   974     // Erase old string

   975     QString text = mTestViewAdvanced->mIpv6DnsAddress1->contentWidgetData("text").toString();

   976     subClearLineEdit(text.size());

   977     

   978     // Enter new string

   979     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

   980 

   981     HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget, exitEditorOffset);

   982 

   983     // Verify both commsdat and UI widget

   984     subVerifyString(

   985         CMManagerShim::CmIP6NameServer1,

   986         mTestViewAdvanced->mIpv6DnsAddress1,

   987         result);

   988     

   989     // Secondary DNS address

   990     HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget);

   991     

   992     // Erase old string

   993     text = mTestViewAdvanced->mIpv6DnsAddress2->contentWidgetData("text").toString();

   994     subClearLineEdit(text.size());

   995     

   996     // Enter new string

   997     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

   998 

   999     HbAutoTest::mouseClick(mMainWindow, mIpv6SecondaryDnsAddressWidget, exitEditorOffset);

  1000 

  1001     // Verify both commsdat and UI widget

  1002     subVerifyString(

  1003         CMManagerShim::CmIP6NameServer2,

  1004         mTestViewAdvanced->mIpv6DnsAddress2,

  1005         result);

  1006     

  1007     // Verify user defined address is in use

  1008     subVerifyBool(

  1009         CMManagerShim::CmIP6DNSAddrFromServer,

  1010         false);

  1011 }

  1012 

  1013 /**

  1014  * Test data for IPv6 DNS address change test case.

  1015  */

  1016 void TestCpWlanApPlugin::tcChangeIpv6DnsAddress_data()

  1017 {

  1018     QTest::addColumn<QString>("string");

  1019     QTest::addColumn<QString>("result");

  1020   

  1021     QTest::newRow("normal")

  1022         << "2001:db8:85a3::8a2e:370:7334"

  1023         << "2001:db8:85a3:0:0:8a2e:370:7334";

  1024 }

  1025 

  1026 /**

  1027  * Tests invalid IPv6 DNS address.

  1028  */

  1029 void TestCpWlanApPlugin::tcInvalidIpv6DnsAddress()

  1030 {

  1031     QString previous = 

  1032         mTestViewAdvanced->mIpv6DnsAddress1->contentWidgetData("text").toString();

  1033     

  1034     HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget);

  1035     

  1036     // Erase old string

  1037     QString text = mTestViewAdvanced->mIpv6DnsAddress1->contentWidgetData("text").toString();

  1038     subClearLineEdit(text.size());

  1039     

  1040     // Enter new string

  1041     HbAutoTest::keyClicks(mMainWindow, "abcdef:fedcba", 0, waitTime);

  1042 

  1043     HbAutoTest::mouseClick(mMainWindow, mIpv6PrimaryDnsAddressWidget, exitEditorOffset);

  1044 

  1045     QTest::qWait(100);

  1046     // Dismiss messagebox

  1047     HbAutoTest::mouseClick(

  1048         mMainWindow,

  1049         mTestViewAdvanced->mMessageBox.data(),

  1050         messageBoxOkButtonOffset);

  1051     

  1052     // Verify both commsdat and UI widget

  1053     subVerifyString(

  1054         CMManagerShim::CmIP6NameServer1,

  1055         mTestViewAdvanced->mIpv6DnsAddress1,

  1056         previous);

  1057 }

  1058 

  1059 /**

  1060  * Collapses the IPv6 settings group.

  1061  */

  1062 void TestCpWlanApPlugin::tcCollapseIpv6Settings()

  1063 {

  1064     HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, ipv6Group);

  1065 }

  1066 

  1067 /**

  1068  * Expands the proxy settings group and gets UI widget pointers.

  1069  */

  1070 void TestCpWlanApPlugin::tcExpandProxySettingsAndGetUiWidgets()

  1071 {

  1072     HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, proxyGroup);

  1073 

  1074     QTest::qWait(500);

  1075     

  1076     subGetAdvancedUiWidgets(2);

  1077 }

  1078 

  1079 /**

  1080  * Tests changing of proxy server address.

  1081  */

  1082 void TestCpWlanApPlugin::tcChangeProxyServerAddress()

  1083 {

  1084     QFETCH(QString, string);

  1085     QFETCH(QString, result);

  1086     

  1087     HbAutoTest::mouseClick(mMainWindow, mProxyServerAddressWidget);

  1088     

  1089     // Erase old string

  1090     QString text = mTestViewAdvanced->mProxyServer->contentWidgetData("text").toString();

  1091     subClearLineEdit(text.size());

  1092     

  1093     // Enter new string

  1094     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

  1095 

  1096     HbAutoTest::mouseClick(mMainWindow, mProxyServerAddressWidget, exitEditorOffset);

  1097 

  1098     QTest::qWait(100);

  1099     

  1100     // Verify both commsdat and UI widget

  1101     subVerifyString(

  1102         CMManagerShim::CmProxyServerName,

  1103         mTestViewAdvanced->mProxyServer,

  1104         result);

  1105     // Verify user defined address flag is set correctly

  1106     if (result.isEmpty()) {

  1107         subVerifyBool(

  1108             CMManagerShim::CmProxyUsageEnabled,

  1109             false);

  1110     } else {

  1111         subVerifyBool(

  1112             CMManagerShim::CmProxyUsageEnabled,

  1113             true);

  1114     }

  1115 }

  1116 

  1117 /**

  1118  * Test data for proxy server address change test case.

  1119  */

  1120 void TestCpWlanApPlugin::tcChangeProxyServerAddress_data()

  1121 {

  1122     QTest::addColumn<QString>("string");

  1123     QTest::addColumn<QString>("result");

  1124   

  1125     QTest::newRow("long")

  1126         << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html"

  1127         << "http://developer.symbian.org/main/documentation/reference/s^3/doc_source/AboutSymbianOSLibrary9.6/index.html";

  1128     QTest::newRow("empty")

  1129         << ""

  1130         << "";

  1131     QTest::newRow("basic") // last one should always fit on one line in UI

  1132         << "http://www.symbian.org/"

  1133         << "http://www.symbian.org/";

  1134 }

  1135 

  1136 /**

  1137  * Tests changing of proxy port number.

  1138  */

  1139 void TestCpWlanApPlugin::tcChangeProxyPortNumber()

  1140 {

  1141     QFETCH(QString, string);

  1142     QFETCH(QString, result);

  1143     

  1144     HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget);

  1145     

  1146     // Erase old string

  1147     QString text = mTestViewAdvanced->mProxyPort->contentWidgetData("text").toString();

  1148     subClearLineEdit(text.size());

  1149     

  1150     // Enter new string

  1151     HbAutoTest::keyClicks(mMainWindow, string, 0, waitTime);

  1152 

  1153     HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget, exitEditorOffset);

  1154 

  1155     QTest::qWait(100);

  1156 

  1157     // Verify both commsdat and UI widget

  1158     subVerifyUint(

  1159         CMManagerShim::CmProxyPortNumber,

  1160         result.toInt());

  1161     QCOMPARE(

  1162         mTestViewAdvanced->mProxyPort->contentWidgetData("text").toInt(),

  1163         result.toInt());

  1164 }

  1165 

  1166 /**

  1167  * Test data for proxy port number change test case.

  1168  */

  1169 void TestCpWlanApPlugin::tcChangeProxyPortNumber_data()

  1170 {

  1171     QTest::addColumn<QString>("string");

  1172     QTest::addColumn<QString>("result");

  1173   

  1174     QTest::newRow("basic")

  1175         << "8080"

  1176         << "8080";

  1177     QTest::newRow("too long")

  1178         << "1234567890"

  1179         << "12345";

  1180     QTest::newRow("zero")

  1181         << "0"

  1182         << "";

  1183     QTest::newRow("empty")

  1184         << ""

  1185         << "";

  1186 }

  1187 

  1188 /**

  1189  * Tests invalid proxy port number.

  1190  */

  1191 void TestCpWlanApPlugin::tcInvalidProxyPortNumber()

  1192 {

  1193     int previous = 

  1194         mTestViewAdvanced->mProxyPort->contentWidgetData("text").toInt();

  1195     

  1196     HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget);

  1197     

  1198     // Erase old string

  1199     QString text = mTestViewAdvanced->mProxyPort->contentWidgetData("text").toString();

  1200     subClearLineEdit(text.size());

  1201     

  1202     // Enter new string

  1203     HbAutoTest::keyClicks(mMainWindow, "65536", 0, waitTime);

  1204 

  1205     HbAutoTest::mouseClick(mMainWindow, mProxyPortNumberWidget, exitEditorOffset);

  1206 

  1207     QTest::qWait(100);

  1208     // Dismiss messagebox

  1209     HbAutoTest::mouseClick(

  1210         mMainWindow,

  1211         mTestViewAdvanced->mMessageBox.data(),

  1212         messageBoxOkButtonOffset);

  1213     

  1214     // Verify both commsdat and UI widget

  1215     subVerifyUint(

  1216         CMManagerShim::CmProxyPortNumber,

  1217         previous);

  1218     QCOMPARE(

  1219         mTestViewAdvanced->mProxyPort->contentWidgetData("text").toInt(),

  1220         previous);

  1221 }

  1222 

  1223 /**

  1224  * Collapses the proxy settings group.

  1225  */

  1226 void TestCpWlanApPlugin::tcCollapseProxySettings()

  1227 {

  1228     HbAutoTest::mouseClick(mMainWindow, mTestViewAdvanced, proxyGroup);

  1229 }

  1230 

  1231 /**

  1232  * Returns from advanced settings view.

  1233  */

  1234 void TestCpWlanApPlugin::tcCloseAdvancedSettingsView()

  1235 {