FCL/sf/mw/qtextensions: comparison qtmobility/tests/auto/qnetworksession/tst_qnetworksession/tst

equal deleted inserted replaced

-:cfcbf08528c4
+:5822d84012fb
 ****************************************************************************/
 #include <QtTest/QtTest>
 #include <QLocalServer>
 #include <QLocalSocket>
+#include <QTimer>
 #include "../../qbearertestcommon.h"
 #include <qnetworkconfigmanager.h>
 #include <qnetworksession.h>
-#ifdef Q_WS_MAEMO_6
+#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)
 #include <stdio.h>
 #include <iapconf.h>
 #endif
 QTM_USE_NAMESPACE
+// Can be used to configure tests that require manual attention (such as roaming)
+//#define QNETWORKSESSION_MANUAL_TESTS 1
 Q_DECLARE_METATYPE(QNetworkConfiguration)
 Q_DECLARE_METATYPE(QNetworkConfiguration::Type);
 Q_DECLARE_METATYPE(QNetworkSession::State);
 Q_DECLARE_METATYPE(QNetworkSession::SessionError);
 void repeatedOpenClose_data();
 void repeatedOpenClose();
 void roamingErrorCodes();
+void sessionStop_data();
+void sessionStop();
 void sessionProperties_data();
 void sessionProperties();
 void userChoiceSession_data();
 private:
 QNetworkConfigurationManager manager;
 uint inProcessSessionManagementCount;
-#ifdef Q_WS_MAEMO_6
+#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)
 Maemo::IAPConf *iapconf;
 Maemo::IAPConf *iapconf2;
 Maemo::IAPConf *gprsiap;
 #define MAX_IAPS 10
 Maemo::IAPConf *iaps[MAX_IAPS];
 };
 // Helper functions
 bool openSession(QNetworkSession *session);
 bool closeSession(QNetworkSession *session, bool lastSessionOnConfiguration = true);
+void updateConfigurations();
 QNetworkConfiguration suitableConfiguration(QString bearerType, QNetworkConfiguration::Type configType);
 void tst_QNetworkSession::initTestCase()
 {
 qRegisterMetaType<QNetworkSession::State>("QNetworkSession::State");
 qRegisterMetaType<QNetworkSession::SessionError>("QNetworkSession::SessionError");
 qRegisterMetaType<QNetworkConfiguration>("QNetworkConfiguration");
 qRegisterMetaType<QNetworkConfiguration::Type>("QNetworkConfiguration::Type");
-#ifdef Q_WS_MAEMO_6
+#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)
 iapconf = new Maemo::IAPConf("007");
 iapconf->setValue("ipv4_type", "AUTO");
 iapconf->setValue("wlan_wepkey1", "connt");
 iapconf->setValue("wlan_wepdefkey", 1);
 iapconf->setValue("wlan_ssid", QByteArray("JamesBond"));
 inProcessSessionManagementCount == 0) {
 QFAIL("No usable configurations found to complete all possible "
 "tests in inProcessSessionManagement()");
 }
-#ifdef Q_WS_MAEMO_6
+#if defined(Q_WS_MAEMO_6) || defined(Q_WS_MAEMO_5)
 iapconf->clear();
 delete iapconf;
 iapconf2->clear();
 delete iapconf2;
 gprsiap->clear();
 #endif
 }
 void tst_QNetworkSession::invalidSession()
 {
-// Verify that session created with invalid configuration remains in invalid state
+// 1. Verify that session created with invalid configuration remains in invalid state
 QNetworkSession session(QNetworkConfiguration(), 0);
 QVERIFY(!session.isOpen());
 QVERIFY(session.state() == QNetworkSession::Invalid);
-// Verify that opening session with invalid configuration both 1) emits invalidconfigurationerror
+// 2. Verify that opening session with invalid configuration both 1) emits invalidconfigurationerror and 2) sets session's state as invalid.
-// and 2) sets session's state as invalid.
 QSignalSpy errorSpy(&session, SIGNAL(error(QNetworkSession::SessionError)));
 session.open();
 session.waitForOpened(1000); // Should bail out right away
 QVERIFY(errorSpy.count() == 1);
 QNetworkSession::SessionError error =
 qvariant_cast<QNetworkSession::SessionError> (errorSpy.first().at(0));
 QVERIFY(error == QNetworkSession::InvalidConfigurationError);
 QVERIFY(session.state() == QNetworkSession::Invalid);
-// Check same thing with a config from platform (there are subtle differences
+#ifdef QNETWORKSESSION_MANUAL_TESTS
-// because emtpy configuration does not have private pointer). Test with config
+QNetworkConfiguration definedConfig = suitableConfiguration("WLAN",QNetworkConfiguration::InternetAccessPoint);
-// in '(un)defined' state
+if (definedConfig.isValid()) {
-QList<QNetworkConfiguration> allConfigs = manager.allConfigurations();
+// 3. Verify that opening a session with defined configuration emits error and enters notavailable-state
-foreach(QNetworkConfiguration config, allConfigs) {
+// TODO these timer waits should be changed to waiting appropriate signals, now these wait excessively
-if ((config.state() & QNetworkConfiguration::Discovered) != QNetworkConfiguration::Discovered) {
+qDebug() << "Shutdown WLAN IAP (waiting 60 seconds): " << definedConfig.name();
-QNetworkSession session2(config);
+QTest::qWait(60000);
-QSignalSpy errorSpy2(&session2, SIGNAL(error(QNetworkSession::SessionError)));
+// Shutting down WLAN should bring back to defined -state.
-session2.open();
+QVERIFY((definedConfig.state() & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined);
-session2.waitForOpened(1000); // Should bail out right away
+QNetworkSession definedSession(definedConfig);
-QVERIFY(errorSpy2.count() == 1);
+QSignalSpy errorSpy(&definedSession, SIGNAL(error(QNetworkSession::SessionError)));
-QNetworkSession::SessionError error2 =
+QNetworkSession::SessionError sessionError;
-qvariant_cast<QNetworkSession::SessionError> (errorSpy2.first().at(0));
-QVERIFY(error2 == QNetworkSession::InvalidConfigurationError);
+definedSession.open();
-QVERIFY(session2.state() == QNetworkSession::Invalid);
-break; // Once is enough
+QVERIFY(definedConfig.isValid()); // Session remains valid
-}
+QVERIFY(definedSession.state() == QNetworkSession::NotAvailable); // State is not available because WLAN is not in coverage
-}
+QVERIFY(!errorSpy.isEmpty()); // Session tells with error about invalidated configuration
+sessionError = qvariant_cast<QNetworkSession::SessionError> (errorSpy.first().at(0));
+qDebug() << "Error code is: " << sessionError;
+QVERIFY(sessionError == QNetworkSession::InvalidConfigurationError);
+qDebug() << "Turn the WLAN IAP back on (waiting 60 seconds): " << definedConfig.name();
+QTest::qWait(60000);
+updateConfigurations();
+QVERIFY(definedConfig.state() == QNetworkConfiguration::Discovered);
+}
+QNetworkConfiguration invalidatedConfig = suitableConfiguration("WLAN",QNetworkConfiguration::InternetAccessPoint);
+if (invalidatedConfig.isValid()) {
+// 4. Verify that invalidating a session after its successfully configured works
+QNetworkSession invalidatedSession(invalidatedConfig);
+QSignalSpy errorSpy(&invalidatedSession, SIGNAL(error(QNetworkSession::SessionError)));
+QNetworkSession::SessionError sessionError;
+qDebug() << "Delete the WLAN IAP from phone now (waiting 60 seconds): " << invalidatedConfig.name();
+QTest::qWait(60000);
+invalidatedSession.open();
+QVERIFY(!invalidatedConfig.isValid());
+QVERIFY(invalidatedSession.state() == QNetworkSession::Invalid);
+QVERIFY(!errorSpy.isEmpty());
+sessionError = qvariant_cast<QNetworkSession::SessionError> (errorSpy.first().at(0));
+QVERIFY(sessionError == QNetworkSession::InvalidConfigurationError);
+qDebug() << "Add the WLAN IAP back (waiting 60 seconds): " << invalidatedConfig.name();
+QTest::qWait(60000);
+}
+#endif
 }
 void tst_QNetworkSession::sessionProperties_data()
 {
 QTest::addColumn<QNetworkConfiguration>("configuration");
 QVERIFY(closeSession(&permanentSession));
 }
 }
 void tst_QNetworkSession::roamingErrorCodes() {
 #ifndef Q_OS_SYMBIAN
 QSKIP("Roaming supported on Symbian.", SkipAll);
 #else
 QNetworkConfiguration wlanIapConfig = suitableConfiguration("WLAN", QNetworkConfiguration::InternetAccessPoint);
 if (!wlanIapConfig.isValid()) {
 QNetworkSession::SessionError error = qvariant_cast<QNetworkSession::SessionError>(errorSpy.first().at(0));
 QVERIFY(error == QNetworkSession::SessionAbortedError);
 QVERIFY(iapSession.state() == QNetworkSession::Disconnected);
 QVERIFY(adminIapSession.state() == QNetworkSession::Disconnected);
 #endif // Q_OS_SYMBIAN
-/*
-// Check for roaming error. Challenging to automate, therefore commented out.
+#ifdef QNETWORKSESSION_MANUAL_TESTS
+// Check for roaming error.
 // Case requires that you have controllable WLAN in Internet SNAP (only).
 QNetworkConfiguration snapConfig = suitableConfiguration("bearer_not_relevant_with_snaps", QNetworkConfiguration::ServiceNetwork);
 if (!snapConfig.isValid()) {
 QSKIP("No SNAP accessible, skipping test.", SkipAll);
 }
 QTRY_VERIFY(!errorSpy2.isEmpty()); // wait for error signals
 QVERIFY(errorSpy2.count() == 1);
 error = qvariant_cast<QNetworkSession::SessionError>(errorSpy2.first().at(0));
 QVERIFY(error == QNetworkSession::SessionAbortedError);
 QVERIFY(iapSession2.state() == QNetworkSession::Disconnected);
-*/
+#endif
+}
+void tst_QNetworkSession::sessionStop_data() {
+QTest::addColumn<QString>("bearerType");
+QTest::addColumn<QNetworkConfiguration::Type>("configurationType");
+QTest::newRow("SNAP") << "bearer_type_not_relevant_with_SNAPs" << QNetworkConfiguration::ServiceNetwork;
+QTest::newRow("WLAN_IAP") << "WLAN" << QNetworkConfiguration::InternetAccessPoint;
+QTest::newRow("Cellular_IAP") << "cellular" << QNetworkConfiguration::InternetAccessPoint;
+}
+void tst_QNetworkSession::sessionStop()
+{
+#ifndef Q_OS_SYMBIAN
+QSKIP("Testcase contains mainly Symbian specific checks, because it is only platform to really support interface (IAP-level) Stop.", SkipAll);
+#endif
+QFETCH(QString, bearerType);
+QFETCH(QNetworkConfiguration::Type, configurationType);
+int configWaitdelayInMs = 2000;
+QNetworkConfiguration config = suitableConfiguration(bearerType, configurationType);
+if (!config.isValid()) {
+QSKIP("No suitable configurations, skipping this round of session stop test.", SkipSingle);
+}
+qDebug() << "Using following configuration to open and stop a session: " << config.name();
+QNetworkSession openedSession(config);
+QNetworkSession closedSession(config);
+QNetworkSession innocentSession(config);
+QNetworkConfigurationManager mgr;
+QSignalSpy closedSessionOpenedSpy(&closedSession, SIGNAL(opened()));
+QSignalSpy closedSessionClosedSpy(&closedSession, SIGNAL(closed()));
+QSignalSpy closedSessionStateChangedSpy(&closedSession, SIGNAL(stateChanged(QNetworkSession::State)));
+QSignalSpy closedErrorSpy(&closedSession, SIGNAL(error(QNetworkSession::SessionError)));
+QSignalSpy innocentSessionClosedSpy(&innocentSession, SIGNAL(closed()));
+QSignalSpy innocentSessionStateChangedSpy(&innocentSession, SIGNAL(stateChanged(QNetworkSession::State)));
+QSignalSpy innocentErrorSpy(&innocentSession, SIGNAL(error(QNetworkSession::SessionError)));
+QNetworkSession::SessionError sessionError;
+// 1. Verify that stopping an opened session works (the simplest usecase).
+qDebug("----------1. Verify that stopping an opened session works (the simplest usecase)");
+QSignalSpy configChangeSpy(&mgr, SIGNAL(configurationChanged(QNetworkConfiguration)));
+QVERIFY(openSession(&openedSession));
+qDebug("Waiting for %d ms to get all configurationChange signals from platform.", configWaitdelayInMs);
+// Clear signals caused by opening
+closedSessionOpenedSpy.clear();
+closedSessionClosedSpy.clear();
+closedSessionStateChangedSpy.clear();
+closedErrorSpy.clear();
+openedSession.stop();
+QVERIFY(openedSession.state() == QNetworkSession::Disconnected);
+QTest::qWait(configWaitdelayInMs); // Wait to get all relevant configurationChange() signals
+QVERIFY(config.state() != QNetworkConfiguration::Active);
+// 2. Verify that stopping a session based on non-connected configuration does nothing
+qDebug("----------2. Verify that stopping a session based on non-connected configuration does nothing");
+QNetworkSession::State closedSessionOriginalState = closedSession.state();
+// Clear all possible signals
+configChangeSpy.clear();
+closedSessionOpenedSpy.clear();
+closedSessionClosedSpy.clear();
+closedSessionStateChangedSpy.clear();
+closedErrorSpy.clear();
+closedSession.stop();
+qDebug("Waiting for %d ms to get all configurationChange signals from platform.", configWaitdelayInMs);
+QTest::qWait(configWaitdelayInMs); // Wait to get all relevant configurationChange() signals
+QVERIFY(closedSessionOpenedSpy.isEmpty());
+QVERIFY(closedSessionClosedSpy.isEmpty());
+QVERIFY(closedSessionStateChangedSpy.isEmpty());
+QVERIFY(closedErrorSpy.isEmpty());
+QVERIFY(closedSession.state() == closedSessionOriginalState); // State remains
+// 3. Check that stopping a opened session affects also other opened session based on the same configuration.
+if (config.type() == QNetworkConfiguration::InternetAccessPoint) {
+qDebug("----------3. Check that stopping a opened session affects also other opened session based on the same configuration.");
+QVERIFY(openSession(&openedSession));
+QVERIFY(openSession(&innocentSession));
+configChangeSpy.clear();
+innocentSessionClosedSpy.clear();
+innocentSessionStateChangedSpy.clear();
+innocentErrorSpy.clear();
+openedSession.stop();
+qDebug("Waiting for %d ms to get all configurationChange signals from platform.", configWaitdelayInMs);
+QTest::qWait(configWaitdelayInMs); // Wait to get all relevant configurationChange() signals
+QVERIFY(!innocentSessionClosedSpy.isEmpty());
+QVERIFY(!innocentSessionStateChangedSpy.isEmpty());
+QVERIFY(!innocentErrorSpy.isEmpty());
+QVERIFY(innocentSession.state() == QNetworkSession::Disconnected);
+QVERIFY(openedSession.state() == QNetworkSession::Disconnected);
+sessionError = qvariant_cast<QNetworkSession::SessionError>(innocentErrorSpy.first().at(0));
+QVERIFY(sessionError == QNetworkSession::SessionAbortedError);
+innocentSessionClosedSpy.clear();
+innocentSessionStateChangedSpy.clear();
+innocentErrorSpy.clear();
+} else {
+qDebug("----------3. Skip for SNAP configuration.");
+}
+// 4. Check that stopping a non-opened session stops the other session based on the
+// same configuration if configuration is IAP. Stopping closed SNAP session has no impact on other opened SNAP session.
+if (config.type() == QNetworkConfiguration::ServiceNetwork) {
+qDebug("----------4. Skip for SNAP configuration.");
+} else if (config.type() == QNetworkConfiguration::InternetAccessPoint) {
+qDebug("----------4. Check that stopping a non-opened session stops the other session based on the same configuration");
+QVERIFY(openSession(&innocentSession));
+qDebug("Waiting for %d ms after open to make sure all platform indications are propagated", configWaitdelayInMs);
+QTest::qWait(configWaitdelayInMs);
+closedSession.stop();
+qDebug("Waiting for %d ms to get all configurationChange signals from platform..", configWaitdelayInMs);
+QTest::qWait(configWaitdelayInMs); // Wait to get all relevant configurationChange() signals
+QVERIFY(!innocentSessionClosedSpy.isEmpty());
+QVERIFY(!innocentSessionStateChangedSpy.isEmpty());
+QVERIFY(!innocentErrorSpy.isEmpty());
+QVERIFY(innocentSession.state() == QNetworkSession::Disconnected);
+QVERIFY(closedSession.state() == QNetworkSession::Disconnected);
+sessionError = qvariant_cast<QNetworkSession::SessionError>(innocentErrorSpy.first().at(0));
+QVERIFY(sessionError == QNetworkSession::SessionAbortedError);
+QVERIFY(config.state() == QNetworkConfiguration::Discovered);
+}
+// 5. Sanity check that stopping invalid session does not crash
+qDebug("----------5. Sanity check that stopping invalid session does not crash");
+QNetworkSession invalidSession(QNetworkConfiguration(), 0);
+QVERIFY(invalidSession.state() == QNetworkSession::Invalid);
+invalidSession.stop();
+QVERIFY(invalidSession.state() == QNetworkSession::Invalid);
 }
 void tst_QNetworkSession::userChoiceSession_data()
 {
 QTest::addColumn<QNetworkConfiguration>("configuration");
 // A convinience / helper function for testcases. Return the first matching configuration.
 // Ignores configurations in other than 'discovered' -state. Returns invalid (QNetworkConfiguration())
 // if none found.
 QNetworkConfiguration suitableConfiguration(QString bearerType, QNetworkConfiguration::Type configType) {
 // Refresh configurations and derive configurations matching given parameters.
 QNetworkConfigurationManager mgr;
 QSignalSpy updateSpy(&mgr, SIGNAL(updateCompleted()));
 mgr.updateConfigurations();
 QTRY_NOOP(updateSpy.count() == 1);
 } else {
 return discoveredConfigs.first();
 }
 }
+// A convinience-function: updates configurations and waits that they are updated.
+void updateConfigurations()
+{
+QNetworkConfigurationManager mgr;
+QSignalSpy updateSpy(&mgr, SIGNAL(updateCompleted()));
+mgr.updateConfigurations();
+QTRY_NOOP(updateSpy.count() == 1);
+}
 // A convinience function for test-cases: opens the given configuration and return
 // true if it was done gracefully.
 bool openSession(QNetworkSession *session) {
 QNetworkConfigurationManager mgr;
 QSignalSpy openedSpy(session, SIGNAL(opened()));
 configChangeSpy.isEmpty()) {
 qDebug("tst_QNetworkSession::closeSession() failure: QNetworkConfigurationManager::configurationChanged() - signal not detected.");
 return false;
 }
 if (lastSessionOnConfiguration &&
-session->configuration().state() != QNetworkConfiguration::Discovered) {
+session->configuration().state() == QNetworkConfiguration::Active) {
-qDebug("tst_QNetworkSession::closeSession() failure: session's configuration is not back in 'Discovered' -state.");
+qDebug("tst_QNetworkSession::closeSession() failure: session's configuration is still in active state.");
 return false;
 }
 return true;
 }
 QTEST_MAIN(tst_QNetworkSession)
 #include "tst_qnetworksession.moc"

branch	RCL_3
changeset 2	5822d84012fb
parent 0	cfcbf08528c4
child 3	87be51aa5b5b