2 files changed, 84 insertions, 12 deletions

diff --git a/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp b/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
index 25301feee4..125eab2f8c 100644
--- a/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
+++ b/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
@@ -77,30 +77,43 @@ void tst_QNetworkAccessManager::networkAccessible()
     QSignalSpy spy(&manager,
                    SIGNAL(networkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility)));
 
-    QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::UnknownAccessibility);
+    // if there is no session, we cannot know in which state we are in
+    QNetworkAccessManager::NetworkAccessibility initialAccessibility =
+            manager.networkAccessible();
+    QCOMPARE(manager.networkAccessible(), initialAccessibility);
 
     manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
 
-    QCOMPARE(spy.count(), 1);
-    QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
-             QNetworkAccessManager::NotAccessible);
+    int expectedCount = (initialAccessibility == QNetworkAccessManager::Accessible) ? 1 : 0;
+    QCOMPARE(spy.count(), expectedCount);
+    if (expectedCount > 0)
+        QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
+                 QNetworkAccessManager::NotAccessible);
     QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::NotAccessible);
 
     manager.setNetworkAccessible(QNetworkAccessManager::Accessible);
 
-    QCOMPARE(spy.count(), 1);
-    QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
-             QNetworkAccessManager::UnknownAccessibility);
-    QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::UnknownAccessibility);
+    QCOMPARE(spy.count(), expectedCount);
+    if (expectedCount > 0)
+        QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
+                 initialAccessibility);
+    QCOMPARE(manager.networkAccessible(), initialAccessibility);
 
     QNetworkConfigurationManager configManager;
+    bool sessionRequired = (configManager.capabilities()
+                            & QNetworkConfigurationManager::NetworkSessionRequired);
     QNetworkConfiguration defaultConfig = configManager.defaultConfiguration();
     if (defaultConfig.isValid()) {
         manager.setConfiguration(defaultConfig);
 
-        QCOMPARE(spy.count(), 1);
-        QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
-                 QNetworkAccessManager::Accessible);
+        // the accessibility has not changed if no session is required
+        if (sessionRequired) {
+            QCOMPARE(spy.count(), 1);
+            QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
+                     QNetworkAccessManager::Accessible);
+        } else {
+            QCOMPARE(spy.count(), 0);
+        }
         QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::Accessible);
 
         manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
diff --git a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
index ce8293edbc..eb9ad81101 100644
--- a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
@@ -368,6 +368,8 @@ private Q_SLOTS:
 #ifdef QT_BUILD_INTERNAL
     void sslSessionSharing_data();
     void sslSessionSharing();
+    void sslSessionSharingFromPersistentSession_data();
+    void sslSessionSharingFromPersistentSession();
 #endif
 #endif
 
@@ -5964,7 +5966,7 @@ void tst_QNetworkReply::sslSessionSharing()
     warmupRequest.setAttribute(QNetworkRequest::User, sessionSharingEnabled); // so we can read it from the slot
     if (! sessionSharingEnabled) {
         QSslConfiguration configuration(QSslConfiguration::defaultConfiguration());
-        configuration.setSslOption(QSsl::SslOptionDisableSessionTickets, true);
+        configuration.setSslOption(QSsl::SslOptionDisableSessionSharing, true);
         warmupRequest.setSslConfiguration(configuration);
     }
     QNetworkReply *reply = manager.get(warmupRequest);
@@ -6010,6 +6012,63 @@ void tst_QNetworkReply::sslSessionSharingHelperSlot()
     }
 }
 
+void tst_QNetworkReply::sslSessionSharingFromPersistentSession_data()
+{
+    QTest::addColumn<bool>("sessionPersistenceEnabled");
+    QTest::newRow("enabled") << true;
+    QTest::newRow("disabled") << false;
+}
+
+void tst_QNetworkReply::sslSessionSharingFromPersistentSession()
+{
+    QString urlString("https://" + QtNetworkSettings::serverName());
+
+    // warm up SSL session cache to get a working session
+    QNetworkRequest warmupRequest(urlString);
+    QFETCH(bool, sessionPersistenceEnabled);
+    if (sessionPersistenceEnabled) {
+        QSslConfiguration warmupConfiguration(QSslConfiguration::defaultConfiguration());
+        warmupConfiguration.setSslOption(QSsl::SslOptionDisableSessionPersistence, false);
+        warmupRequest.setSslConfiguration(warmupConfiguration);
+    }
+    QNetworkReply *warmupReply = manager.get(warmupRequest);
+    warmupReply->ignoreSslErrors();
+    connect(warmupReply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    QTestEventLoop::instance().enterLoop(20);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+    QCOMPARE(warmupReply->error(), QNetworkReply::NoError);
+    QByteArray sslSession = warmupReply->sslConfiguration().session();
+    QCOMPARE(!sslSession.isEmpty(), sessionPersistenceEnabled);
+
+    // test server sends a life time hint of 0, which is not common
+    // practice; however it is good enough because the default is -1
+    int expectedSessionTicketLifeTimeHint = sessionPersistenceEnabled ? 0 : -1;
+    QCOMPARE(warmupReply->sslConfiguration().sessionTicketLifeTimeHint(),
+             expectedSessionTicketLifeTimeHint);
+
+    warmupReply->deleteLater();
+
+    // now send another request with a new QNAM and the persisted session,
+    // to verify it can be resumed without any internal state
+    QNetworkRequest request(warmupRequest);
+    if (sessionPersistenceEnabled) {
+        QSslConfiguration configuration = request.sslConfiguration();
+        configuration.setSession(sslSession);
+        request.setSslConfiguration(configuration);
+    }
+    QNetworkAccessManager newManager;
+    QNetworkReply *reply = newManager.get(request);
+    reply->ignoreSslErrors();
+    connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    QTestEventLoop::instance().enterLoop(20);
+    QVERIFY(!QTestEventLoop::instance().timeout());
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
+
+    bool sslSessionSharingWasUsedInReply = QSslConfigurationPrivate::peerSessionWasShared(
+                reply->sslConfiguration());
+    QCOMPARE(sessionPersistenceEnabled, sslSessionSharingWasUsedInReply);
+}
+
 #endif // QT_BUILD_INTERNAL
 #endif // QT_NO_SSL