openkylin
/
qtbase-opensource-src
mirror of https://gitee.com/openkylin/qtbase-opensource-src.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
qtbase-opensource-src/tests/manual/network_stresstest/tst_network_stresstest.cpp

767 lines
25 KiB
C++
Raw Permalink Blame History

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <QtCore/QThread>
#include <QtCore/QSemaphore>
#include <QtCore/QElapsedTimer>
#include <QtCore/QSharedPointer>
#include <QtCore/QVector>
#include <QtNetwork/QTcpSocket>
#include <QtNetwork/QNetworkReply>
#include <QtNetwork/QNetworkAccessManager>
#ifdef QT_BUILD_INTERNAL
# include <private/qnetworkaccessmanager_p.h>
#endif
#include "minihttpserver.h"
#include "../../auto/network-settings.h"
#include <qplatformdefs.h>
#ifdef Q_OS_UNIX
# include <sys/types.h>
# include <sys/socket.h>
# include <sys/select.h>
# include <netinet/in.h>
# include <errno.h>
# include <netdb.h>
# include <signal.h>
# include <unistd.h>
# include <fcntl.h>
typedef int SOCKET;
# define INVALID_SOCKET -1
# define SOCKET_ERROR -1
#elif defined(Q_OS_WIN)
# include <winsock2.h>
#endif
class tst_NetworkStressTest : public QObject
{
Q_OBJECT
public:
enum { AttemptCount = 100 };
tst_NetworkStressTest();
MiniHttpServer server;
qint64 byteCounter;
QNetworkAccessManager manager;
bool intermediateDebug;
private:
void clearManager();
public slots:
void initTestCase_data();
void initTestCase();
void init();
void slotReadAll() { byteCounter += static_cast<QIODevice *>(sender())->readAll().size(); }
private Q_SLOTS:
void nativeBlockingConnectDisconnect();
void nativeNonBlockingConnectDisconnect();
void blockingConnectDisconnect();
void blockingPipelined();
void blockingMultipleRequests();
void connectDisconnect();
void parallelConnectDisconnect_data();
void parallelConnectDisconnect();
void namGet_data();
void namGet();
};
tst_NetworkStressTest::tst_NetworkStressTest()
: intermediateDebug(qgetenv("STRESSDEBUG").toInt() > 0)
{
#ifdef Q_OS_WIN
WSAData wsadata;
// IPv6 requires Winsock v2.0 or better.
WSAStartup(MAKEWORD(2,0), &wsadata);
#elif defined(Q_OS_UNIX)
::signal(SIGALRM, SIG_IGN);
#endif
}
void tst_NetworkStressTest::initTestCase_data()
{
QTest::addColumn<bool>("isLocalhost");
QTest::addColumn<QString>("hostname");
QTest::addColumn<int>("port");
QTest::newRow("localhost") << true << "localhost" << server.port();
QTest::newRow("remote") << false << QtNetworkSettings::serverName() << 80;
}
void tst_NetworkStressTest::initTestCase()
{
if (!QtNetworkSettings::verifyTestNetworkSettings())
QSKIP("No network test server available");
}
void tst_NetworkStressTest::init()
{
// clear the internal cache
#ifndef QT_BUILD_INTERNAL
if (strncmp(QTest::currentTestFunction(), "nam", 3) == 0)
QSKIP("QNetworkAccessManager tests disabled");
#endif
}
void tst_NetworkStressTest::clearManager()
{
#ifdef QT_BUILD_INTERNAL
QNetworkAccessManagerPrivate::clearAuthenticationCache(&manager);
QNetworkAccessManagerPrivate::clearConnectionCache(&manager);
manager.setProxy(QNetworkProxy());
manager.setCache(0);
#endif
}
bool nativeLookup(const char *hostname, int port, QByteArray &buf)
{
#if 0
addrinfo *res = 0;
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
int result = getaddrinfo(QUrl::toAce(hostname).constData(), QByteArray::number(port).constData(), &hints, &res);
if (!result)
return false;
for (addrinfo *node = res; node; node = node->ai_next) {
if (node->ai_family == AF_INET) {
buf = QByteArray((char *)node->ai_addr, node->ai_addrlen);
break;
}
}
freeaddrinfo(res);
#else
hostent *result = gethostbyname(hostname);
if (!result || result->h_addrtype != AF_INET)
return false;
struct sockaddr_in s;
s.sin_family = AF_INET;
s.sin_port = htons(port);
s.sin_addr = *(struct in_addr *) result->h_addr_list[0];
buf = QByteArray((char *)&s, sizeof s);
#endif
return !buf.isEmpty();
}
bool nativeSelect(int fd, int timeout, bool selectForWrite)
{
if (timeout < 0)
return false;
// wait for connected
fd_set fds, fde;
FD_ZERO(&fds);
FD_ZERO(&fde);
FD_SET(fd, &fds);
FD_SET(fd, &fde);
int ret;
do {
struct timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec = timeout % 1000;
if (selectForWrite)
ret = ::select(fd + 1, 0, &fds, &fde, &tv);
else
ret = ::select(fd + 1, &fds, 0, &fde, &tv);
} while (ret == -1 && errno == EINTR);
return ret != 0;
}
void tst_NetworkStressTest::nativeBlockingConnectDisconnect()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < AttemptCount; ++i) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
#if defined(Q_OS_UNIX)
alarm(10);
#endif
// look up the host
QByteArray addr;
if (!nativeLookup(QUrl::toAce(hostname).constData(), port, addr))
QFAIL("Lookup failed");
// connect
SOCKET fd = ::socket(AF_INET, SOCK_STREAM, 0);
QVERIFY(fd != INVALID_SOCKET);
QVERIFY(::connect(fd, (sockaddr *)addr.data(), addr.size()) != SOCKET_ERROR);
// send request
{
QByteArray request = "GET /qtest/bigfile HTTP/1.1\r\n"
"Connection: close\r\n"
"User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
"Host: " + hostname.toLatin1() + "\r\n"
"\r\n";
qint64 bytesWritten = 0;
while (bytesWritten < request.size()) {
qint64 ret = ::send(fd, request.constData() + bytesWritten, request.size() - bytesWritten, 0);
if (ret == -1) {
::close(fd);
QFAIL("Timeout");
}
bytesWritten += ret;
}
}
// receive reply
char buf[16384];
while (true) {
qint64 ret = ::recv(fd, buf, sizeof buf, 0);
if (ret == -1) {
::close(fd);
QFAIL("Timeout");
} else if (ret == 0) {
break; // EOF
}
byteCounter += ret;
}
::close(fd);
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
#if defined(Q_OS_UNIX)
alarm(0);
#endif
}
void tst_NetworkStressTest::nativeNonBlockingConnectDisconnect()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < AttemptCount; ++i) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
// look up the host
QByteArray addr;
if (!nativeLookup(QUrl::toAce(hostname).constData(), port, addr))
QFAIL("Lookup failed");
SOCKET fd;
{
#if defined(Q_OS_UNIX)
fd = ::socket(AF_INET, SOCK_STREAM, 0);
QVERIFY(fd != INVALID_SOCKET);
// set the socket to non-blocking and start connecting
# if !defined(Q_OS_VXWORKS)
int flags = ::fcntl(fd, F_GETFL, 0);
QVERIFY(flags != -1);
QVERIFY(::fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1);
# else // Q_OS_VXWORKS
int onoff = 1;
QVERIFY(::ioctl(socketDescriptor, FIONBIO, &onoff) >= 0);
# endif // Q_OS_VXWORKS
while (true) {
if (::connect(fd, (sockaddr *)addr.data(), addr.size()) == -1) {
QVERIFY2(errno == EINPROGRESS, QByteArray("Error connecting: ").append(strerror(errno)).constData());
QVERIFY2(nativeSelect(fd, 10000 - timeout.elapsed(), true), "Timeout");
} else {
break; // connected
}
}
#elif defined(Q_OS_WIN)
fd = ::WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
QVERIFY(fd != INVALID_SOCKET);
// set the socket to non-blocking and start connecting
unsigned long buf = 0;
unsigned long outBuf;
DWORD sizeWritten = 0;
QVERIFY(::WSAIoctl(fd, FIONBIO, &buf, sizeof(unsigned long), &outBuf, sizeof(unsigned long), &sizeWritten, 0,0) != SOCKET_ERROR);
while (true) {
int connectResult = ::WSAConnect(fd, (sockaddr *)addr.data(), addr.size(), 0,0,0,0);
if (connectResult == 0 || WSAGetLastError() == WSAEISCONN) {
break; // connected
} else {
QVERIFY2(WSAGetLastError() == WSAEINPROGRESS, "Unexpected error");
QVERIFY2(nativeSelect(fd, 10000 - timeout.elapsed(), true), "Timeout");
}
}
#endif
}
// send request
{
QByteArray request = "GET /qtest/bigfile HTTP/1.1\r\n"
"Connection: close\r\n"
"User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
"Host: " + hostname.toLatin1() + "\r\n"
"\r\n";
qint64 bytesWritten = 0;
while (bytesWritten < request.size()) {
qint64 ret = ::send(fd, request.constData() + bytesWritten, request.size() - bytesWritten, 0);
if (ret == -1 && errno != EWOULDBLOCK) {
::close(fd);
QFAIL(QByteArray("Error writing: ").append(strerror(errno)).constData());
} else if (ret == -1) {
// wait for writing
QVERIFY2(nativeSelect(fd, 10000 - timeout.elapsed(), true), "Timeout");
continue;
}
bytesWritten += ret;
}
}
// receive reply
char buf[16384];
while (true) {
qint64 ret = ::recv(fd, buf, sizeof buf, 0);
if (ret == -1 && errno != EWOULDBLOCK) {
::close(fd);
QFAIL("Timeout");
} else if (ret == -1) {
// wait for reading
QVERIFY2(nativeSelect(fd, 10000 - timeout.elapsed(), false), "Timeout");
} else if (ret == 0) {
break; // EOF
}
byteCounter += ret;
}
::close(fd);
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
}
void tst_NetworkStressTest::blockingConnectDisconnect()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < AttemptCount; ++i) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
QTcpSocket socket;
socket.connectToHost(hostname, port);
QVERIFY2(socket.waitForConnected(), "Timeout");
socket.write("GET /qtest/bigfile HTTP/1.1\r\n"
"Connection: close\r\n"
"User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
"Host: " + hostname.toLatin1() + "\r\n"
"\r\n");
while (socket.bytesToWrite())
QVERIFY2(socket.waitForBytesWritten(), "Timeout");
while (socket.state() == QAbstractSocket::ConnectedState && !timeout.hasExpired(10000)) {
socket.waitForReadyRead();
byteCounter += socket.readAll().size(); // discard
}
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
}
void tst_NetworkStressTest::blockingPipelined()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < AttemptCount / 2; ++i) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
QTcpSocket socket;
socket.connectToHost(hostname, port);
QVERIFY2(socket.waitForConnected(), "Timeout");
for (int j = 0 ; j < 3; ++j) {
if (intermediateDebug)
qDebug("Attempt %d%c", i, 'a' + j);
socket.write("GET /qtest/bigfile HTTP/1.1\r\n"
"Connection: " + QByteArray(j == 2 ? "close" : "keep-alive") + "\r\n"
"User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
"Host: " + hostname.toLatin1() + "\r\n"
"\r\n");
while (socket.bytesToWrite())
QVERIFY2(socket.waitForBytesWritten(), "Timeout");
}
while (socket.state() == QAbstractSocket::ConnectedState && !timeout.hasExpired(10000)) {
socket.waitForReadyRead();
byteCounter += socket.readAll().size(); // discard
}
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
}
void tst_NetworkStressTest::blockingMultipleRequests()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < AttemptCount / 5; ++i) {
QTcpSocket socket;
socket.connectToHost(hostname, port);
QVERIFY2(socket.waitForConnected(), "Timeout");
for (int j = 0 ; j < 5; ++j) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
socket.write("GET /qtest/bigfile HTTP/1.1\r\n"
"Connection: keep-alive\r\n"
"User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
"Host: " + hostname.toLatin1() + "\r\n"
"\r\n");
while (socket.bytesToWrite())
QVERIFY2(socket.waitForBytesWritten(), "Timeout");
qint64 bytesRead = 0;
qint64 bytesExpected = -1;
QByteArray buffer;
while (socket.state() == QAbstractSocket::ConnectedState && !timeout.hasExpired(10000)) {
socket.waitForReadyRead();
buffer += socket.readAll();
byteCounter += buffer.size();
int pos = buffer.indexOf("\r\n\r\n");
if (pos == -1)
continue;
bytesRead = buffer.length() - pos - 4;
buffer.truncate(pos + 2);
buffer = buffer.toLower();
pos = buffer.indexOf("\r\ncontent-length: ");
if (pos == -1) {
qWarning() << "no content-length:" << QString(buffer);
break;
}
pos += int(strlen("\r\ncontent-length: "));
int eol = buffer.indexOf("\r\n", pos + 2);
if (eol == -1) {
qWarning() << "invalid header";
break;
}
bytesExpected = buffer.mid(pos, eol - pos).toLongLong();
break;
}
QVERIFY(bytesExpected > 0);
QVERIFY2(!timeout.hasExpired(10000), "Timeout");
while (socket.state() == QAbstractSocket::ConnectedState && !timeout.hasExpired(10000) && bytesExpected > bytesRead) {
socket.waitForReadyRead();
int blocklen = socket.read(bytesExpected - bytesRead).length(); // discard
bytesRead += blocklen;
byteCounter += blocklen;
}
QVERIFY2(!timeout.hasExpired(10000), "Timeout");
QCOMPARE(bytesRead, bytesExpected);
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
socket.disconnectFromHost();
QVERIFY(socket.state() == QAbstractSocket::UnconnectedState);
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
}
void tst_NetworkStressTest::connectDisconnect()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < AttemptCount; ++i) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
QTcpSocket socket;
socket.connectToHost(hostname, port);
socket.write("GET /qtest/bigfile HTTP/1.1\r\n"
"Connection: close\r\n"
"User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
"Host: " + hostname.toLatin1() + "\r\n"
"\r\n");
connect(&socket, SIGNAL(readyRead()), SLOT(slotReadAll()));
QTestEventLoop::instance().connect(&socket, SIGNAL(disconnected()), SLOT(exitLoop()));
QTestEventLoop::instance().enterLoop(30);
QVERIFY2(!QTestEventLoop::instance().timeout(), "Timeout");
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
}
void tst_NetworkStressTest::parallelConnectDisconnect_data()
{
QTest::addColumn<int>("parallelAttempts");
QTest::newRow("1") << 1;
QTest::newRow("2") << 2;
QTest::newRow("4") << 4;
QTest::newRow("5") << 5;
QTest::newRow("6") << 6;
QTest::newRow("8") << 8;
QTest::newRow("10") << 10;
QTest::newRow("25") << 25;
QTest::newRow("100") << 100;
QTest::newRow("500") << 500;
}
void tst_NetworkStressTest::parallelConnectDisconnect()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
QFETCH(int, parallelAttempts);
if (parallelAttempts > 100) {
QFETCH_GLOBAL(bool, isLocalhost);
if (!isLocalhost)
QSKIP("Localhost-only test");
}
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < qMax(2, AttemptCount/qMax(2, parallelAttempts/4)); ++i) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
QTcpSocket *socket = new QTcpSocket[parallelAttempts];
for (int j = 0; j < parallelAttempts; ++j) {
socket[j].connectToHost(hostname, port);
socket[j].write("GET /qtest/bigfile HTTP/1.1\r\n"
"Connection: close\r\n"
"User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
"Host: " + hostname.toLatin1() + "\r\n"
"\r\n");
connect(&socket[j], SIGNAL(readyRead()), SLOT(slotReadAll()));
QTestEventLoop::instance().connect(&socket[j], SIGNAL(disconnected()), SLOT(exitLoop()));
}
while (!timeout.hasExpired(30000)) {
QTestEventLoop::instance().enterLoop(10);
int done = 0;
for (int j = 0; j < parallelAttempts; ++j)
done += socket[j].state() == QAbstractSocket::UnconnectedState ? 1 : 0;
if (done == parallelAttempts)
break;
}
delete[] socket;
QVERIFY2(!timeout.hasExpired(30000), "Timeout");
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
}
void tst_NetworkStressTest::namGet_data()
{
QTest::addColumn<int>("parallelAttempts");
QTest::addColumn<bool>("pipelineAllowed");
QTest::newRow("1") << 1 << false;
QTest::newRow("1p") << 1 << true;
QTest::newRow("2") << 2 << false;
QTest::newRow("2p") << 2 << true;
QTest::newRow("4") << 4 << false;
QTest::newRow("4p") << 4 << true;
QTest::newRow("5") << 5 << false;
QTest::newRow("5p") << 5 << true;
QTest::newRow("6") << 6 << false;
QTest::newRow("6p") << 6 << true;
QTest::newRow("8") << 8 << false;
QTest::newRow("8p") << 8 << true;
QTest::newRow("10") << 10 << false;
QTest::newRow("10p") << 10 << true;
QTest::newRow("25") << 25 << false;
QTest::newRow("25p") << 25 << true;
QTest::newRow("100") << 100 << false;
QTest::newRow("100p") << 100 << true;
QTest::newRow("500") << 500 << false;
QTest::newRow("500p") << 500 << true;
}
void tst_NetworkStressTest::namGet()
{
QFETCH_GLOBAL(QString, hostname);
QFETCH_GLOBAL(int, port);
QFETCH(int, parallelAttempts);
QFETCH(bool, pipelineAllowed);
if (parallelAttempts > 100) {
QFETCH_GLOBAL(bool, isLocalhost);
if (!isLocalhost)
QSKIP("Localhost-only test");
}
qint64 totalBytes = 0;
QElapsedTimer outerTimer;
outerTimer.start();
for (int i = 0; i < qMax(2, AttemptCount/qMax(2, parallelAttempts/4)); ++i) {
QElapsedTimer timeout;
byteCounter = 0;
timeout.start();
QUrl url;
url.setScheme("http");
url.setHost(hostname);
url.setPort(port);
url.setEncodedPath("/qtest/bigfile");
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, pipelineAllowed);
QVector<QSharedPointer<QNetworkReply> > replies;
replies.resize(parallelAttempts);
for (int j = 0; j < parallelAttempts; ++j) {
QNetworkReply *r = manager.get(req);
connect(r, SIGNAL(readyRead()), SLOT(slotReadAll()));
QTestEventLoop::instance().connect(r, SIGNAL(finished()), SLOT(exitLoop()));
replies[j] = QSharedPointer<QNetworkReply>(r);
}
while (!timeout.hasExpired(30000)) {
QTestEventLoop::instance().enterLoop(10);
int done = 0;
for (int j = 0; j < parallelAttempts; ++j)
done += replies[j]->isFinished() ? 1 : 0;
if (done == parallelAttempts)
break;
}
replies.clear();
QVERIFY2(!timeout.hasExpired(30000), "Timeout");
totalBytes += byteCounter;
if (intermediateDebug) {
double rate = (byteCounter * 1.0 / timeout.elapsed());
qDebug() << i << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
<< (rate / 1024.0 / 1024 * 1000) << "MB/s";
}
}
qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 / 1024 * 1000 / outerTimer.elapsed()) << "MB/s";
}
QTEST_MAIN(tst_NetworkStressTest);
#include "tst_network_stresstest.moc"
Reference in New Issue View Git Blame Copy Permalink