Merge branch 'master' of git@scm.dev.nokia.troll.no:qt/qt into kinetic-declarativeui

Conflicts:
	mkspecs/features/qt.prf
	src/corelib/animation/qanimationgroup.cpp
	src/corelib/animation/qparallelanimationgroup.cpp
	src/corelib/animation/qpauseanimation.cpp
	src/corelib/animation/qpropertyanimation.cpp
	src/corelib/animation/qsequentialanimationgroup.cpp
	src/corelib/kernel/kernel.pri
	src/corelib/kernel/qvariant_p.h
	src/corelib/tools/qeasingcurve.cpp
	src/gui/graphicsview/qgraphicsitem.cpp
	src/opengl/opengl.pro
	src/opengl/qgl_x11egl.cpp
	tests/auto/auto.pro

28 files changed, 2171 insertions, 314 deletions

diff --git a/tests/auto/_networkselftest/_networkselftest.pro b/tests/auto/_networkselftest/_networkselftest.pro
new file mode 100644
index 0000000..9e2ad0e
--- /dev/null
+++ b/tests/auto/_networkselftest/_networkselftest.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+
+SOURCES += tst_networkselftest.cpp
+QT = core network
+DEFINES += SRCDIR=\\\"$$PWD\\\"
+
diff --git a/tests/auto/_networkselftest/tst_networkselftest.cpp b/tests/auto/_networkselftest/tst_networkselftest.cpp
new file mode 100644
index 0000000..dab4433
--- /dev/null
+++ b/tests/auto/_networkselftest/tst_networkselftest.cpp
@@ -0,0 +1,592 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QtNetwork/QtNetwork>
+#include "../network-settings.h"
+
+class tst_NetworkSelfTest: public QObject
+{
+    Q_OBJECT
+private slots:
+    void hostTest();
+    void dnsResolution_data();
+    void dnsResolution();
+    void serverReachability();
+    void remotePortsOpen_data();
+    void remotePortsOpen();
+
+    // specific protocol tests
+    void ftpServer();
+    void imapServer();
+    void httpServer();
+    void httpsServer();
+    void httpProxy();
+    void httpProxyBasicAuth();
+    void httpProxyNtlmAuth();
+    void socks5Proxy();
+    void socks5ProxyAuth();
+};
+
+class Chat
+{
+public:
+    enum Type {
+        Reconnect,
+        Send,
+        Expect,
+        SkipBytes,
+        DiscardUntil,
+        DiscardUntilDisconnect,
+        Disconnect,
+        RemoteDisconnect,
+        StartEncryption
+    };
+    Chat(Type t, const QByteArray &d)
+        : data(d), type(t)
+    {
+    }
+    Chat(Type t, int val = 0)
+        : value(val), type(t)
+    {
+    }
+
+    static inline Chat send(const QByteArray &data)
+    { return Chat(Send, data); }
+    static inline Chat expect(const QByteArray &data)
+    { return Chat(Expect, data); }
+    static inline Chat discardUntil(const QByteArray &data)
+    { return Chat(DiscardUntil, data); }
+    static inline Chat skipBytes(int count)
+    { return Chat(SkipBytes, count); }
+
+    QByteArray data;
+    int value;
+    Type type;
+};
+
+static QString prettyByteArray(const QByteArray &array)
+{
+    // any control chars?
+    QString result;
+    result.reserve(array.length() + array.length() / 3);
+    for (int i = 0; i < array.length(); ++i) {
+        char c = array.at(i);
+        switch (c) {
+        case '\n':
+            result += "\\n";
+            continue;
+        case '\r':
+            result += "\\r";
+            continue;
+        case '\t':
+            result += "\\t";
+            continue;
+        case '"':
+            result += "\\\"";
+            continue;
+        default:
+            break;
+        }
+
+        if (c < 0x20 || uchar(c) >= 0x7f) {
+            result += '\\';
+            result += QString::number(uchar(c), 8);
+        } else {
+            result += c;
+        }
+    }
+    return result;
+}
+
+static bool doSocketRead(QTcpSocket *socket, int minBytesAvailable, int timeout = 2000)
+{
+    QTime timer;
+    timer.start();
+    forever {
+        if (socket->bytesAvailable() >= minBytesAvailable)
+            return true;
+        if (socket->state() == QAbstractSocket::UnconnectedState
+            || timer.elapsed() >= timeout)
+            return false;
+        if (!socket->waitForReadyRead(timeout - timer.elapsed()))
+            return false;
+    }
+}
+
+static bool doSocketFlush(QTcpSocket *socket, int timeout = 2000)
+{
+#ifndef QT_NO_OPENSSL
+    QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
+#endif
+    QTime timer;
+    timer.start();
+    forever {
+        if (socket->bytesToWrite() == 0
+#ifndef QT_NO_OPENSSL
+            && sslSocket->encryptedBytesToWrite() == 0
+#endif
+            )
+            return true;
+        if (socket->state() == QAbstractSocket::UnconnectedState
+            || timer.elapsed() >= timeout)
+            return false;
+        if (!socket->waitForBytesWritten(timeout - timer.elapsed()))
+            return false;
+    }
+}
+
+static void netChat(int port, const QList<Chat> &chat)
+{
+#ifndef QT_NO_OPENSSL
+    QSslSocket socket;
+#else
+    QTcpSocket socket;
+#endif
+
+    socket.connectToHost(QtNetworkSettings::serverName(), port);
+    qDebug() << 0 << "Connecting to server on port" << port;
+    QVERIFY2(socket.waitForConnected(10000),
+             QString("Failed to connect to server in step 0: %1").arg(socket.errorString()).toLocal8Bit());
+
+    // now start the chat
+    QList<Chat>::ConstIterator it = chat.constBegin();
+    for (int i = 1; it != chat.constEnd(); ++it, ++i) {
+        if (it->type != Chat::Reconnect
+            && socket.state() != QAbstractSocket::ConnectedState
+            && socket.state() != QAbstractSocket::ClosingState)
+            QFAIL(QString("Internal error: socket is in invalid state %1 in step %2")
+                  .arg(socket.state()).arg(i).toLocal8Bit());
+
+        switch (it->type) {
+            case Chat::Expect: {
+                    qDebug() << i << "Expecting" << prettyByteArray(it->data);
+                    if (!doSocketRead(&socket, it->data.length()))
+                        QFAIL(QString("Failed to receive data in step %1: timeout").arg(i).toLocal8Bit());
+
+                    // pop that many bytes off the socket
+                    QByteArray received = socket.read(it->data.length());
+
+                    // is it what we expected?
+                    QVERIFY2(received == it->data,
+                             QString("Did not receive expected data in step %1: data received was:\n%2")
+                             .arg(i).arg(prettyByteArray(received)).toLocal8Bit());
+
+                    break;
+                }
+
+            case Chat::DiscardUntil:
+                qDebug() << i << "Discarding until" << prettyByteArray(it->data);
+                while (true) {
+                    // scan the buffer until we have our string
+                    if (!doSocketRead(&socket, it->data.length()))
+                        QFAIL(QString("Failed to receive data in step %1: timeout").arg(i).toLocal8Bit());
+
+                    QByteArray buffer;
+                    buffer.resize(socket.bytesAvailable());
+                    socket.peek(buffer.data(), socket.bytesAvailable());
+
+                    int pos = buffer.indexOf(it->data);
+                    if (pos == -1) {
+                        // data not found, keep trying
+                        continue;
+                    }
+
+                    buffer = socket.read(pos + it->data.length());
+                    qDebug() << i << "Discarded" << prettyByteArray(buffer);
+                    break;
+                }
+                break;
+
+            case Chat::SkipBytes: {
+                    qDebug() << i << "Skipping" << it->value << "bytes";
+                    if (!doSocketRead(&socket, it->value))
+                        QFAIL(QString("Failed to receive data in step %1: timeout").arg(i).toLocal8Bit());
+
+                    // now discard the bytes
+                    QByteArray buffer = socket.read(it->value);
+                    qDebug() << i << "Skipped" << prettyByteArray(buffer);
+                    break;
+                }
+
+            case Chat::Send: {
+                    qDebug() << i << "Sending" << prettyByteArray(it->data);
+                    socket.write(it->data);
+                    if (!doSocketFlush(&socket)) {
+                        QVERIFY2(socket.state() == QAbstractSocket::ConnectedState,
+                                 QString("Socket disconnected while sending data in step %1").arg(i).toLocal8Bit());
+                        QFAIL(QString("Failed to send data in step %1: timeout").arg(i).toLocal8Bit());
+                    }
+                    break;
+                }
+
+            case Chat::Disconnect:
+                qDebug() << i << "Disconnecting from host";
+                socket.disconnectFromHost();
+
+                // is this the last command?
+                if (it + 1 != chat.constEnd())
+                    break;
+
+                // fall through:
+            case Chat::RemoteDisconnect:
+            case Chat::DiscardUntilDisconnect:
+                qDebug() << i << "Waiting for remote disconnect";
+                if (socket.state() != QAbstractSocket::UnconnectedState)
+                    socket.waitForDisconnected(10000);
+                QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState,
+                         QString("Socket did not disconnect as expected in step %1").arg(i).toLocal8Bit());
+
+                // any data left?
+                if (it->type == Chat::DiscardUntilDisconnect) {
+                    QByteArray buffer = socket.readAll();
+                    qDebug() << i << "Discarded in the process:" << prettyByteArray(buffer);
+                }
+
+                if (socket.bytesAvailable() != 0)
+                    QFAIL(QString("Unexpected bytes still on buffer when disconnecting in step %1:\n%2")
+                          .arg(i).arg(prettyByteArray(socket.readAll())).toLocal8Bit());
+                break;
+
+            case Chat::Reconnect:
+                qDebug() << i << "Reconnecting to server on port" << port;
+                socket.connectToHost(QtNetworkSettings::serverName(), port);
+                QVERIFY2(socket.waitForConnected(10000),
+                         QString("Failed to reconnect to server in step %1: %2").arg(i).arg(socket.errorString()).toLocal8Bit());
+                break;
+
+            case Chat::StartEncryption:
+#ifdef QT_NO_OPENSSL
+                QFAIL("Internal error: SSL required for this test");
+#else
+                qDebug() << i << "Starting client encryption";
+                socket.ignoreSslErrors();
+                socket.startClientEncryption();
+                QVERIFY2(socket.waitForEncrypted(5000),
+                         QString("Failed to start client encryption in step %1: %2").arg(i)
+                         .arg(socket.errorString()).toLocal8Bit());
+                break;
+#endif
+            }
+    }
+}
+
+void tst_NetworkSelfTest::hostTest()
+{
+    // this is a localhost self-test
+    QHostInfo localhost = QHostInfo::fromName("localhost");
+    QCOMPARE(localhost.error(), QHostInfo::NoError);
+    QVERIFY(!localhost.addresses().isEmpty());
+
+    QTcpServer server;
+    QVERIFY(server.listen());
+
+    QTcpSocket socket;
+    socket.connectToHost("127.0.0.1", server.serverPort());
+    QVERIFY(socket.waitForConnected(10000));
+}
+
+void tst_NetworkSelfTest::dnsResolution_data()
+{
+    QTest::addColumn<QString>("hostName");
+    QTest::newRow("local-name") << QtNetworkSettings::serverLocalName();
+    QTest::newRow("fqdn") << QtNetworkSettings::serverName();
+}
+
+void tst_NetworkSelfTest::dnsResolution()
+{
+    QFETCH(QString, hostName);
+    QHostInfo resolved = QHostInfo::fromName(hostName);
+    QVERIFY2(resolved.error() == QHostInfo::NoError,
+             QString("Failed to resolve hostname %1: %2").arg(hostName, resolved.errorString()).toLocal8Bit());
+}
+
+void tst_NetworkSelfTest::serverReachability()
+{
+    // check that we get a proper error connecting to port 1
+    QTcpSocket socket;
+    socket.connectToHost(QtNetworkSettings::serverName(), 1);
+    socket.waitForConnected(10000);
+    QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState, "Socket connected unexpectedly!");
+    QVERIFY2(socket.error() == QAbstractSocket::ConnectionRefusedError,
+             QString("Could not reach server: %1").arg(socket.errorString()).toLocal8Bit());
+}
+
+void tst_NetworkSelfTest::remotePortsOpen_data()
+{
+    QTest::addColumn<int>("portNumber");
+    QTest::newRow("ftp") << 21;
+    QTest::newRow("ssh") << 22;
+    QTest::newRow("imap") << 143;
+    QTest::newRow("http") << 80;
+    QTest::newRow("https") << 443;
+    QTest::newRow("http-proxy") << 3128;
+    QTest::newRow("http-proxy-auth-basic") << 3129;
+    QTest::newRow("http-proxy-auth-ntlm") << 3130;
+    QTest::newRow("socks5-proxy") << 1080;
+    QTest::newRow("socks5-proxy-auth") << 1081;
+}
+
+void tst_NetworkSelfTest::remotePortsOpen()
+{
+    QFETCH(int, portNumber);
+    QTcpSocket socket;
+    socket.connectToHost(QtNetworkSettings::serverName(), portNumber);
+
+    if (!socket.waitForConnected(10000)) {
+        if (socket.error() == QAbstractSocket::SocketTimeoutError)
+            QFAIL(QString("Network timeout connecting to the server on port %1").arg(portNumber).toLocal8Bit());
+        else
+            QFAIL(QString("Error connecting to server on port %1: %2").arg(portNumber).arg(socket.errorString()).toLocal8Bit());
+    }
+    QVERIFY(socket.state() == QAbstractSocket::ConnectedState);
+}
+
+static QList<Chat> ftpChat()
+{
+    return QList<Chat>() << Chat::expect("220")
+            << Chat::discardUntil("\r\n")
+            << Chat::send("USER anonymous\r\n")
+            << Chat::expect("331")
+            << Chat::discardUntil("\r\n")
+            << Chat::send("PASS user@hostname\r\n")
+            << Chat::expect("230")
+            << Chat::discardUntil("\r\n")
+            << Chat::send("QUIT\r\n")
+            << Chat::expect("221")
+            << Chat::discardUntil("\r\n")
+            << Chat::RemoteDisconnect;
+}
+
+void tst_NetworkSelfTest::ftpServer()
+{
+    netChat(21, ftpChat());
+}
+
+void tst_NetworkSelfTest::imapServer()
+{
+    netChat(143, QList<Chat>()
+            << Chat::expect("* OK ")
+            << Chat::discardUntil("\r\n")
+            << Chat::send("1 CAPABILITY\r\n")
+            << Chat::expect("* CAPABILITY ")
+            << Chat::discardUntil("1 OK")
+            << Chat::discardUntil("\r\n")
+            << Chat::send("2 LOGOUT\r\n")
+            << Chat::discardUntil("2 OK")
+            << Chat::discardUntil("\r\n")
+            << Chat::RemoteDisconnect);
+}
+
+void tst_NetworkSelfTest::httpServer()
+{
+    netChat(80, QList<Chat>()
+            // HTTP/0.9 chat:
+            << Chat::send("GET /\r\n")
+            << Chat::DiscardUntilDisconnect
+
+            // HTTP/1.0 chat:
+            << Chat::Reconnect
+            << Chat::send("GET / HTTP/1.0\r\n"
+                          "Host: " + QtNetworkSettings::serverName().toLatin1() + "\r\n"
+                          "Connection: close\r\n"
+                          "\r\n")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("200 ")
+            << Chat::DiscardUntilDisconnect
+
+            // HTTP/1.0 POST:
+            << Chat::Reconnect
+            << Chat::send("POST / HTTP/1.0\r\n"
+                          "Content-Length: 5\r\n"
+                          "Host: " + QtNetworkSettings::serverName().toLatin1() + "\r\n"
+                          "Connection: close\r\n"
+                          "\r\n"
+                          "Hello")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("200 ")
+            << Chat::DiscardUntilDisconnect
+            );
+}
+
+void tst_NetworkSelfTest::httpsServer()
+{
+#ifndef QT_NO_OPENSSL
+    netChat(443, QList<Chat>()
+            << Chat::StartEncryption
+            << Chat::send("GET / HTTP/1.0\r\n"
+                          "Host: " + QtNetworkSettings::serverName().toLatin1() + "\r\n"
+                          "Connection: close\r\n"
+                          "\r\n")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("200 ")
+            << Chat::DiscardUntilDisconnect);
+#else
+    QSKIP("SSL not enabled, cannot test");
+#endif
+}
+
+void tst_NetworkSelfTest::httpProxy()
+{
+    netChat(3128, QList<Chat>()
+            // proxy GET
+            << Chat::send("GET http://" + QtNetworkSettings::serverName().toLatin1() + "/ HTTP/1.0\r\n"
+                          "Host: " + QtNetworkSettings::serverName().toLatin1() + "\r\n"
+                          "Proxy-connection: close\r\n"
+                          "\r\n")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("200 ")
+            << Chat::DiscardUntilDisconnect
+
+            // proxy CONNECT
+            << Chat::Reconnect
+            << Chat::send("CONNECT " + QtNetworkSettings::serverName().toLatin1() + ":21 HTTP/1.0\r\n"
+                          "\r\n")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("200 ")
+            << Chat::discardUntil("\r\n\r\n")
+            << ftpChat());
+}
+
+void tst_NetworkSelfTest::httpProxyBasicAuth()
+{
+    netChat(3129, QList<Chat>()
+            // test auth required response
+            << Chat::send("GET http://" + QtNetworkSettings::serverName().toLatin1() + "/ HTTP/1.0\r\n"
+                          "Host: " + QtNetworkSettings::serverName().toLatin1() + "\r\n"
+                          "Proxy-connection: close\r\n"
+                          "\r\n")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("407 ")
+            << Chat::discardUntil("\r\nProxy-Authenticate: Basic realm=\"")
+            << Chat::DiscardUntilDisconnect
+
+            // now try sending our credentials
+            << Chat::Reconnect
+            << Chat::send("GET http://" + QtNetworkSettings::serverName().toLatin1() + "/ HTTP/1.0\r\n"
+                          "Host: " + QtNetworkSettings::serverName().toLatin1() + "\r\n"
+                          "Proxy-connection: close\r\n"
+                          "Proxy-Authorization: Basic cXNvY2tzdGVzdDpwYXNzd29yZA==\r\n"
+                          "\r\n")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("200 ")
+            << Chat::DiscardUntilDisconnect);
+}
+
+void tst_NetworkSelfTest::httpProxyNtlmAuth()
+{
+    netChat(3130, QList<Chat>()
+            // test auth required response
+            << Chat::send("GET http://" + QtNetworkSettings::serverName().toLatin1() + "/ HTTP/1.0\r\n"
+                          "Host: " + QtNetworkSettings::serverName().toLatin1() + "\r\n"
+                          "Proxy-connection: keep-alive\r\n" // NTLM auth will disconnect
+                          "\r\n")
+            << Chat::expect("HTTP/1.")
+            << Chat::discardUntil(" ")
+            << Chat::expect("407 ")
+            << Chat::discardUntil("\r\nProxy-Authenticate: NTLM\r\n")
+            << Chat::DiscardUntilDisconnect
+            );
+}
+
+// SOCKSv5 is a binary protocol
+static const char handshakeNoAuth[] = "\5\1\0";
+static const char handshakeOkNoAuth[] = "\5\0";
+static const char handshakeAuthPassword[] = "\5\1\2\1\12qsockstest\10password";
+static const char handshakeOkPasswdAuth[] = "\5\2\1\0";
+static const char handshakeAuthNotOk[] = "\5\377";
+static const char connect1[] = "\5\1\0\1\177\0\0\1\0\25"; // Connect IPv4 127.0.0.1 port 21
+static const char connect2[] = "\5\1\0\3\11localhost\0\25"; // Connect hostname localhost 21
+static const char connected[] = "\5\0\0";
+
+void tst_NetworkSelfTest::socks5Proxy()
+{
+    netChat(1080, QList<Chat>()
+            // IP address connection
+            << Chat::send(QByteArray(handshakeNoAuth, -1 + sizeof handshakeNoAuth))
+            << Chat::expect(QByteArray(handshakeOkNoAuth, -1 + sizeof handshakeOkNoAuth))
+            << Chat::send(QByteArray(connect1, -1 + sizeof connect1))
+            << Chat::expect(QByteArray(connected, -1 + sizeof connected))
+            << Chat::expect("\1") // IPv4 address following
+            << Chat::skipBytes(6) // the server's local address and port
+            << ftpChat()
+
+            // hostname connection
+            << Chat::Reconnect
+            << Chat::send(QByteArray(handshakeNoAuth, -1 + sizeof handshakeNoAuth))
+            << Chat::expect(QByteArray(handshakeOkNoAuth, -1 + sizeof handshakeOkNoAuth))
+            << Chat::send(QByteArray(connect2, -1 + sizeof connect2))
+            << Chat::expect(QByteArray(connected, -1 + sizeof connected))
+            << Chat::expect("\1") // IPv4 address following
+            << Chat::skipBytes(6) // the server's local address and port
+            << ftpChat()
+            );
+}
+
+void tst_NetworkSelfTest::socks5ProxyAuth()
+{
+    netChat(1081, QList<Chat>()
+            // unauthenticated connect -- will get error
+            << Chat::send(QByteArray(handshakeNoAuth, -1 + sizeof handshakeNoAuth))
+            << Chat::expect(QByteArray(handshakeAuthNotOk, -1 + sizeof handshakeAuthNotOk))
+            << Chat::RemoteDisconnect
+
+            // now try to connect with authentication
+            << Chat::Reconnect
+            << Chat::send(QByteArray(handshakeAuthPassword, -1 + sizeof handshakeAuthPassword))
+            << Chat::expect(QByteArray(handshakeOkPasswdAuth, -1 + sizeof handshakeOkPasswdAuth))
+            << Chat::send(QByteArray(connect1, -1 + sizeof connect1))
+            << Chat::expect(QByteArray(connected, -1 + sizeof connected))
+            << Chat::expect("\1") // IPv4 address following
+            << Chat::skipBytes(6) // the server's local address and port
+            << ftpChat()
+            );
+}
+
+QTEST_MAIN(tst_NetworkSelfTest)
+#include "tst_networkselftest.moc"
diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index 331546d..c4da3ce 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -4,7 +4,8 @@ TEMPLATE = subdirs
 !wince*:SUBDIRS += \
            headers
 
-SUBDIRS += bic \
+SUBDIRS += _networkselftest \
+           bic \
            dynamicobject \
            collections \
            compile \
@@ -296,6 +297,7 @@ SUBDIRS += bic \
            qstandarditem \
            qstandarditemmodel \
            qstate \
+           qstatemachine \
            qstatusbar \
            qstl \
            qstring \
diff --git a/tests/auto/qcombobox/tst_qcombobox.cpp b/tests/auto/qcombobox/tst_qcombobox.cpp
index 2fff6d0..816b2e8 100644
--- a/tests/auto/qcombobox/tst_qcombobox.cpp
+++ b/tests/auto/qcombobox/tst_qcombobox.cpp
@@ -2171,7 +2171,7 @@ void tst_QComboBox::noScrollbar_data()
     QTest::newRow("everything and more") << QString::fromLatin1("QAbstractItemView {  border: 1px 3px 5px 1px solid blue; "
                                                        " padding: 2px 5px 3px 1px; margin: 2px 5px 3px 1px;  } "
                                                        " QAbstractItemView::item {  border: 2px solid green; "
-                                                       "                      padding: 1px 1px 2px 2px margin: 1px; } " );
+                                                       "                      padding: 1px 1px 2px 2px; margin: 1px; } " );
 }
 
 void tst_QComboBox::noScrollbar()
@@ -2179,10 +2179,11 @@ void tst_QComboBox::noScrollbar()
     QStringList initialContent;
     initialContent << "foo" << "bar" << "foobar" << "moo";
     QFETCH(QString, stylesheet);
+    QString oldCss = qApp->styleSheet();
+    qApp->setStyleSheet(stylesheet);
 
     {
         QComboBox comboBox;
-        comboBox.setStyleSheet(stylesheet);
         comboBox.addItems(initialContent);
         comboBox.show();
         comboBox.resize(200, comboBox.height());
@@ -2196,7 +2197,6 @@ void tst_QComboBox::noScrollbar()
     {
         QTableWidget *table = new QTableWidget(2,2);
         QComboBox comboBox;
-        comboBox.setStyleSheet(stylesheet);
         comboBox.setView(table);
         comboBox.setModel(table->model());
         comboBox.show();
@@ -2207,6 +2207,8 @@ void tst_QComboBox::noScrollbar()
         QVERIFY(!comboBox.view()->horizontalScrollBar()->isVisible());
         QVERIFY(!comboBox.view()->verticalScrollBar()->isVisible());
     }
+
+    qApp->setStyleSheet(oldCss);
 }
 
 void tst_QComboBox::setItemDelegate()
diff --git a/tests/auto/qdate/tst_qdate.cpp b/tests/auto/qdate/tst_qdate.cpp
index d4273d0..4d6c80c 100644
--- a/tests/auto/qdate/tst_qdate.cpp
+++ b/tests/auto/qdate/tst_qdate.cpp
@@ -82,6 +82,8 @@ private slots:
     void operator_gt_eq();
     void fromString_data();
     void fromString();
+    void fromString_format_data();
+    void fromString_format();
     void toString_format_data();
     void toString_format();
     void isLeapYear();
@@ -618,6 +620,30 @@ void tst_QDate::fromString()
         QCOMPARE( QDate::fromString( str2, Qt::ISODate ), d1 );
 }
 
+void tst_QDate::fromString_format_data()
+{
+    QTest::addColumn<QString>("string");
+    QTest::addColumn<QString>("format");
+    QTest::addColumn<QDate>("date");
+
+    //year with yy is always 19xx for compatibility
+    QTest::newRow( "data0" ) << QString("21052006") << QString("ddMMyyyy") << QDate(2006,5,21);
+    QTest::newRow( "data1" ) << QString("210506") << QString("ddMMyy") << QDate(1906,5,21);
+    QTest::newRow( "data2" ) << QString("21/5/2006") << QString("d/M/yyyy") << QDate(2006,5,21);
+    QTest::newRow( "data3" ) << QString("21/5/06") << QString("d/M/yy") << QDate(1906,5,21);
+    QTest::newRow( "data4" ) << QString("20060521") << QString("yyyyMMdd") << QDate(2006,5,21);
+    QTest::newRow( "data5" ) << QString("060521") << QString("yyMMdd") << QDate(1906,5,21);
+}
+
+void tst_QDate::fromString_format()
+{
+    QFETCH( QString, string );
+    QFETCH( QString, format );
+    QFETCH( QDate, date );
+
+    QCOMPARE( QDate::fromString( string, format ), date );
+}
+
 void tst_QDate::toString_format_data()
 {
     QTest::addColumn<QDate>("t");
diff --git a/tests/auto/qeasingcurve/tst_qeasingcurve.cpp b/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
index 8d42e5e..b25cdc7 100644
--- a/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
+++ b/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
@@ -179,196 +179,197 @@ void tst_QEasingCurve::propertyDefaults()
 }
 
 typedef QList<int> IntList;
+typedef QList<qreal> RealList;
 Q_DECLARE_METATYPE(IntList)
+Q_DECLARE_METATYPE(RealList)
 
 void tst_QEasingCurve::valueForProgress_data()
 {
     QTest::addColumn<int>("type");
     QTest::addColumn<IntList>("at");
-    QTest::addColumn<IntList>("expected");
+    QTest::addColumn<RealList>("expected");
     // automatically generated.
     // note that values are scaled from range [0,1] to range [0, 100] in order to store them as
     // integer values and avoid fp inaccuracies
-
     QTest::newRow("Linear") << int(QEasingCurve::Linear)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.1 << 0.2 << 0.3 << 0.4 << 0.5 << 0.6 << 0.7 << 0.8 << 0.9 << 1);
 
     QTest::newRow("InQuad") << int(QEasingCurve::InQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 1 << 4 << 9 << 16 << 25 << 36 << 48 << 64 << 81 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.01 << 0.04 << 0.09 << 0.16 << 0.25 << 0.36 << 0.49 << 0.64 << 0.81 << 1);
 
     QTest::newRow("OutQuad") << int(QEasingCurve::OutQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 19 << 36 << 51 << 64 << 75 << 84 << 90 << 96 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.19 << 0.36 << 0.51 << 0.64 << 0.75 << 0.84 << 0.91 << 0.96 << 0.99 << 1);
 
     QTest::newRow("InOutQuad") << int(QEasingCurve::InOutQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 2 << 8 << 18 << 32 << 50 << 68 << 82 << 92 << 98 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.02 << 0.08 << 0.18 << 0.32 << 0.5 << 0.68 << 0.82 << 0.92 << 0.98 << 1);
 
     QTest::newRow("OutInQuad") << int(QEasingCurve::OutInQuad)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 18 << 32 << 42 << 48 << 50 << 52 << 57 << 68 << 82 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.18 << 0.32 << 0.42 << 0.48 << 0.5 << 0.52 << 0.58 << 0.68 << 0.82 << 1);
 
     QTest::newRow("InCubic") << int(QEasingCurve::InCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 2 << 6 << 12 << 21 << 34 << 51 << 72 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.001 << 0.008 << 0.027 << 0.064 << 0.125 << 0.216 << 0.343 << 0.512 << 0.729 << 1);
 
     QTest::newRow("OutCubic") << int(QEasingCurve::OutCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 27 << 48 << 65 << 78 << 87 << 93 << 97 << 99 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.271 << 0.488 << 0.657 << 0.784 << 0.875 << 0.936 << 0.973 << 0.992 << 0.999 << 1);
 
     QTest::newRow("InOutCubic") << int(QEasingCurve::InOutCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 3 << 10 << 25 << 50 << 74 << 89 << 96 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.004 << 0.032 << 0.108 << 0.256 << 0.5 << 0.744 << 0.892 << 0.968 << 0.996 << 1);
 
     QTest::newRow("OutInCubic") << int(QEasingCurve::OutInCubic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 24 << 39 << 46 << 49 << 50 << 50 << 53 << 60 << 75 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.244 << 0.392 << 0.468 << 0.496 << 0.5 << 0.504 << 0.532 << 0.608 << 0.756 << 1);
 
     QTest::newRow("InQuart") << int(QEasingCurve::InQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 2 << 6 << 12 << 24 << 40 << 65 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.0001 << 0.0016 << 0.0081 << 0.0256 << 0.0625 << 0.1296 << 0.2401 << 0.4096 << 0.6561 << 1);
 
     QTest::newRow("OutQuart") << int(QEasingCurve::OutQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 34 << 59 << 75 << 87 << 93 << 97 << 99 << 99 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.3439 << 0.5904 << 0.7599 << 0.8704 << 0.9375 << 0.9744 << 0.9919 << 0.9984 << 0.9999 << 1);
 
     QTest::newRow("InOutQuart") << int(QEasingCurve::InOutQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 1 << 6 << 20 << 50 << 79 << 93 << 98 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.0008 << 0.0128 << 0.0648 << 0.2048 << 0.5 << 0.7952 << 0.9352 << 0.9872 << 0.9992 << 1);
 
     QTest::newRow("OutInQuart") << int(QEasingCurve::OutInQuart)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 29 << 43 << 48 << 49 << 50 << 50 << 51 << 56 << 70 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.2952 << 0.4352 << 0.4872 << 0.4992 << 0.5 << 0.5008 << 0.5128 << 0.5648 << 0.7048 << 1);
 
     QTest::newRow("InQuint") << int(QEasingCurve::InQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 1 << 3 << 7 << 16 << 32 << 59 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 1e-05 << 0.00032 << 0.00243 << 0.01024 << 0.03125 << 0.07776 << 0.1681 << 0.3277 << 0.5905 << 1);
 
     QTest::newRow("OutQuint") << int(QEasingCurve::OutQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 40 << 67 << 83 << 92 << 96 << 98 << 99 << 99 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.4095 << 0.6723 << 0.8319 << 0.9222 << 0.9688 << 0.9898 << 0.9976 << 0.9997 << 1 << 1);
 
     QTest::newRow("InOutQuint") << int(QEasingCurve::InOutQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 3 << 16 << 50 << 83 << 96 << 99 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.00016 << 0.00512 << 0.03888 << 0.1638 << 0.5 << 0.8362 << 0.9611 << 0.9949 << 0.9998 << 1);
 
     QTest::newRow("OutInQuint") << int(QEasingCurve::OutInQuint)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 33 << 46 << 49 << 49 << 50 << 50 << 50 << 53 << 66 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.3362 << 0.4611 << 0.4949 << 0.4998 << 0.5 << 0.5002 << 0.5051 << 0.5389 << 0.6638 << 1);
 
     QTest::newRow("InSine") << int(QEasingCurve::InSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 1 << 4 << 10 << 19 << 29 << 41 << 54 << 69 << 84 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.01231 << 0.04894 << 0.109 << 0.191 << 0.2929 << 0.4122 << 0.546 << 0.691 << 0.8436 << 1);
 
     QTest::newRow("OutSine") << int(QEasingCurve::OutSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 15 << 30 << 45 << 58 << 70 << 80 << 89 << 95 << 98 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.1564 << 0.309 << 0.454 << 0.5878 << 0.7071 << 0.809 << 0.891 << 0.9511 << 0.9877 << 1);
 
     QTest::newRow("InOutSine") << int(QEasingCurve::InOutSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 2 << 9 << 20 << 34 << 49 << 65 << 79 << 90 << 97 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.02447 << 0.09549 << 0.2061 << 0.3455 << 0.5 << 0.6545 << 0.7939 << 0.9045 << 0.9755 << 1);
 
     QTest::newRow("OutInSine") << int(QEasingCurve::OutInSine)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 15 << 29 << 40 << 47 << 50 << 52 << 59 << 70 << 84 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.1545 << 0.2939 << 0.4045 << 0.4755 << 0.5 << 0.5245 << 0.5955 << 0.7061 << 0.8455 << 1);
 
     QTest::newRow("InExpo") << int(QEasingCurve::InExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 1 << 3 << 6 << 12 << 24 << 49 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.0009531 << 0.002906 << 0.006812 << 0.01462 << 0.03025 << 0.0615 << 0.124 << 0.249 << 0.499 << 1);
 
     QTest::newRow("OutExpo") << int(QEasingCurve::OutExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 50 << 75 << 87 << 93 << 96 << 98 << 99 << 99 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.5005 << 0.7507 << 0.8759 << 0.9384 << 0.9697 << 0.9854 << 0.9932 << 0.9971 << 0.999 << 1);
 
     QTest::newRow("InOutExpo") << int(QEasingCurve::InOutExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 3 << 12 << 50 << 87 << 96 << 99 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.001453 << 0.007312 << 0.03075 << 0.1245 << 0.5002 << 0.8754 << 0.9692 << 0.9927 << 0.9985 << 1);
 
     QTest::newRow("OutInExpo") << int(QEasingCurve::OutInExpo)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 37 << 46 << 49 << 49 << 50 << 50 << 50 << 53 << 62 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.3754 << 0.4692 << 0.4927 << 0.4985 << 0.5 << 0.5015 << 0.5073 << 0.5308 << 0.6245 << 1);
 
     QTest::newRow("InCirc") << int(QEasingCurve::InCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 2 << 4 << 8 << 13 << 19 << 28 << 40 << 56 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.005013 << 0.0202 << 0.04606 << 0.08348 << 0.134 << 0.2 << 0.2859 << 0.4 << 0.5641 << 1);
 
     QTest::newRow("OutCirc") << int(QEasingCurve::OutCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 43 << 59 << 71 << 80 << 86 << 91 << 95 << 97 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.4359 << 0.6 << 0.7141 << 0.8 << 0.866 << 0.9165 << 0.9539 << 0.9798 << 0.995 << 1);
 
     QTest::newRow("InOutCirc") << int(QEasingCurve::InOutCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 1 << 4 << 9 << 20 << 50 << 80 << 89 << 95 << 98 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.0101 << 0.04174 << 0.1 << 0.2 << 0.5 << 0.8 << 0.9 << 0.9583 << 0.9899 << 1);
 
     QTest::newRow("OutInCirc") << int(QEasingCurve::OutInCirc)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 29 << 40 << 45 << 48 << 50 << 51 << 54 << 60 << 70 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.3 << 0.4 << 0.4583 << 0.4899 << 0.5 << 0.5101 << 0.5417 << 0.6 << 0.7 << 1);
 
     QTest::newRow("InElastic") << int(QEasingCurve::InElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << 0 << 1 << -1 << -3 << 12 << -12 << -25 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.001953 << -0.001953 << -0.003906 << 0.01562 << -0.01562 << -0.03125 << 0.125 << -0.125 << -0.25 << 1);
 
     QTest::newRow("OutElastic") << int(QEasingCurve::OutElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 125 << 112 << 87 << 103 << 101 << 98 << 100 << 100 << 99 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 1.25 << 1.125 << 0.875 << 1.031 << 1.016 << 0.9844 << 1.004 << 1.002 << 0.998 << 1);
 
     QTest::newRow("InOutElastic") << int(QEasingCurve::InOutElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 0 << 0 << -1 << -6 << 50 << 106 << 101 << 99 << 100 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << -0.0009766 << 0.007812 << -0.01563 << -0.0625 << 0.5 << 1.062 << 1.016 << 0.9922 << 1.001 << 1);
 
     QTest::newRow("OutInElastic") << int(QEasingCurve::OutInElastic)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 37 << 56 << 49 << 49 << 50 << 49 << 50 << 53 << 24 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.375 << 0.5625 << 0.4922 << 0.498 << 0.5 << 0.4961 << 0.5078 << 0.5313 << 0.25 << 1);
 
     QTest::newRow("InBack") << int(QEasingCurve::InBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << -1 << -4 << -8 << -9 << -8 << -2 << 9 << 29 << 59 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << -0.01431 << -0.04645 << -0.0802 << -0.09935 << -0.0877 << -0.02903 << 0.09287 << 0.2942 << 0.5912 << 1);
 
     QTest::newRow("OutBack") << int(QEasingCurve::OutBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 40 << 70 << 90 << 102 << 108 << 109 << 108 << 104 << 101 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.4088 << 0.7058 << 0.9071 << 1.029 << 1.088 << 1.099 << 1.08 << 1.046 << 1.014 << 1);
 
     QTest::newRow("InOutBack") << int(QEasingCurve::InOutBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << -3 << -9 << -7 << 8 << 50 << 91 << 107 << 109 << 103 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << -0.03752 << -0.09256 << -0.07883 << 0.08993 << 0.5 << 0.9101 << 1.079 << 1.093 << 1.038 << 1);
 
     QTest::newRow("OutInBack") << int(QEasingCurve::OutInBack)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 35 << 51 << 54 << 52 << 50 << 47 << 45 << 48 << 64 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.3529 << 0.5145 << 0.5497 << 0.5232 << 0.5 << 0.4768 << 0.4503 << 0.4855 << 0.6471 << 1);
 
     QTest::newRow("InBounce") << int(QEasingCurve::InBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 1 << 6 << 6 << 22 << 23 << 9 << 31 << 69 << 92 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.01188 << 0.06 << 0.06937 << 0.2275 << 0.2344 << 0.09 << 0.3194 << 0.6975 << 0.9244 << 1);
 
     QTest::newRow("OutBounce") << int(QEasingCurve::OutBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 7 << 30 << 68 << 90 << 76 << 77 << 93 << 94 << 98 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.07563 << 0.3025 << 0.6806 << 0.91 << 0.7656 << 0.7725 << 0.9306 << 0.94 << 0.9881 << 1);
 
     QTest::newRow("InOutBounce") << int(QEasingCurve::InOutBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 3 << 11 << 4 << 34 << 50 << 65 << 95 << 88 << 97 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.03 << 0.1138 << 0.045 << 0.3488 << 0.5 << 0.6512 << 0.955 << 0.8862 << 0.97 << 1);
 
     QTest::newRow("OutInBounce") << int(QEasingCurve::OutInBounce)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 15 << 40 << 27 << 43 << 50 << 56 << 72 << 58 << 84 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.1513 << 0.41 << 0.2725 << 0.44 << 0.5 << 0.56 << 0.7275 << 0.59 << 0.8488 << 1);
 
     QTest::newRow("InCurve") << int(QEasingCurve::InCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 2 << 10 << 23 << 37 << 50 << 60 << 70 << 80 << 90 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.02447 << 0.1059 << 0.2343 << 0.3727 << 0.5 << 0.6055 << 0.7 << 0.8 << 0.9 << 1);
 
     QTest::newRow("OutCurve") << int(QEasingCurve::OutCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 39 << 50 << 62 << 76 << 89 << 97 << 100);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.1 << 0.2 << 0.3 << 0.3945 << 0.5 << 0.6273 << 0.7657 << 0.8941 << 0.9755 << 1);
 
     QTest::newRow("SineCurve") << int(QEasingCurve::SineCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 0 << 9 << 34 << 65 << 90 << 100 << 90 << 65 << 34 << 9 << 0);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0 << 0.09549 << 0.3455 << 0.6545 << 0.9045 << 1 << 0.9045 << 0.6545 << 0.3455 << 0.09549 << 0);
 
     QTest::newRow("CosineCurve") << int(QEasingCurve::CosineCurve)
-                 << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
-                 << (IntList()  << 50 << 79 << 97 << 97 << 79 << 50 << 20 << 2 << 2 << 20 << 49);
+         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)
+         << (RealList() << 0.5 << 0.7939 << 0.9755 << 0.9755 << 0.7939 << 0.5 << 0.2061 << 0.02447 << 0.02447 << 0.2061 << 0.5);
 
 }
 
@@ -389,12 +390,11 @@ void tst_QEasingCurve::valueForProgress()
         for (int t = 0; t <= 100; t+= 10) {
             qreal ease = curve.valueForProgress(t/qreal(100));
             strInputs += QString::fromAscii(" << %1").arg(t);
-            strOutputs += QString::fromAscii(" << %1").arg(int(100*ease));
-
+            strOutputs += " << " + QString().setNum(ease, 'g', 4);
         }
         QString str = QString::fromAscii("    QTest::newRow(\"%1\") << int(QEasingCurve::%2)\n"
-                                                "\t\t << (IntList() %3)\n"
-                                                "\t\t << (IntList() %4);\n\n")
+                                                "         << (IntList() %3)\n"
+                                                "         << (RealList()%4);\n\n")
                                       .arg(strCurve)
                                       .arg(strCurve)
                                       .arg(strInputs)
@@ -406,13 +406,19 @@ void tst_QEasingCurve::valueForProgress()
 #else
     QFETCH(int, type);
     QFETCH(IntList, at);
-    QFETCH(IntList, expected);
+    QFETCH(RealList, expected);
 
     QEasingCurve curve((QEasingCurve::Type)type);
     for (int i = 0; i < at.count(); ++i) {
         qreal ease = curve.valueForProgress(at.at(i)/qreal(100));
-        int ex = expected.at(i);
-        QCOMPARE(int(100*ease), ex);
+        // converting ease to 4 precision qreal to match the generated samples
+        qreal easeConv = qreal(QString().setNum(ease, 'g', 4).toDouble());
+        qreal ex = expected.at(i);
+
+        // the least significant digit it is still subject to rounding errors
+        qreal error = easeConv - ex;
+        // accept the potential rounding error in the least significant digit
+        QVERIFY(error <= 0.00001 );
     }
 #endif
 }
diff --git a/tests/auto/qfile/copy-fallback.qrc b/tests/auto/qfile/copy-fallback.qrc
new file mode 100644
index 0000000..864491f
--- /dev/null
+++ b/tests/auto/qfile/copy-fallback.qrc
@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+    <file>copy-fallback.qrc</file>
+</qresource>
+</RCC>
diff --git a/tests/auto/qfile/test/test.pro b/tests/auto/qfile/test/test.pro
index 68f4c05..8d26f5e 100644
--- a/tests/auto/qfile/test/test.pro
+++ b/tests/auto/qfile/test/test.pro
@@ -17,7 +17,7 @@ QT = core network
 DEFINES += SRCDIR=\\\"$$PWD/../\\\"
 }
 
-RESOURCES      += ../qfile.qrc ../rename-fallback.qrc
+RESOURCES      += ../qfile.qrc ../rename-fallback.qrc ../copy-fallback.qrc
 
 TARGET = ../tst_qfile
 
diff --git a/tests/auto/qfile/tst_qfile.cpp b/tests/auto/qfile/tst_qfile.cpp
index cb8091b..d650b0d 100644
--- a/tests/auto/qfile/tst_qfile.cpp
+++ b/tests/auto/qfile/tst_qfile.cpp
@@ -126,6 +126,7 @@ private slots:
     void copyAfterFail();
     void copyRemovesTemporaryFile() const;
     void copyShouldntOverwrite();
+    void copyFallback();
     void link();
     void linkToDir();
     void absolutePathLinkToRelativePath();
@@ -214,6 +215,13 @@ void tst_QFile::cleanup()
 // TODO: Add cleanup code here.
 // This will be executed immediately after each test is run.
 
+    // for copyFallback()
+    if (QFile::exists("file-copy-destination.txt")) {
+        QFile::setPermissions("file-copy-destination.txt",
+                QFile::ReadOwner | QFile::WriteOwner);
+        QFile::remove("file-copy-destination.txt");
+    }
+
     // for renameFallback()
     QFile::remove("file-rename-destination.txt");
 
@@ -948,6 +956,34 @@ void tst_QFile::copyShouldntOverwrite()
     QFile::remove("tst_qfile.cpy");
 }
 
+void tst_QFile::copyFallback()
+{
+    // Using a resource file to trigger QFile::copy's fallback handling
+    QFile file(":/copy-fallback.qrc");
+    QFile::remove("file-copy-destination.txt");
+
+    QVERIFY2(file.exists(), "test precondition");
+    QVERIFY2(!QFile::exists("file-copy-destination.txt"), "test precondition");
+
+    // Fallback copy of closed file.
+    QVERIFY(file.copy("file-copy-destination.txt"));
+    QVERIFY(QFile::exists("file-copy-destination.txt"));
+    QVERIFY(!file.isOpen());
+
+    // Need to reset permissions on Windows to be able to delete
+    QVERIFY(QFile::setPermissions("file-copy-destination.txt",
+            QFile::ReadOwner | QFile::WriteOwner));
+    QVERIFY(QFile::remove("file-copy-destination.txt"));
+
+    // Fallback copy of open file.
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QVERIFY(file.copy("file-copy-destination.txt"));
+    QVERIFY(QFile::exists("file-copy-destination.txt"));
+    QVERIFY(!file.isOpen());
+
+    QFile::remove("file-copy-destination.txt");
+}
+
 #ifdef Q_OS_WIN
 #include <objbase.h>
 #include <shlobj.h>
@@ -2122,6 +2158,7 @@ void tst_QFile::renameFallback()
 
     QVERIFY(!file.rename("file-rename-destination.txt"));
     QVERIFY(!QFile::exists("file-rename-destination.txt"));
+    QVERIFY(!file.isOpen());
 }
 
 void tst_QFile::renameMultiple()
diff --git a/tests/auto/qfiledialog/tst_qfiledialog.cpp b/tests/auto/qfiledialog/tst_qfiledialog.cpp
index 689f73d..16c84d8 100644
--- a/tests/auto/qfiledialog/tst_qfiledialog.cpp
+++ b/tests/auto/qfiledialog/tst_qfiledialog.cpp
@@ -159,6 +159,7 @@ private slots:
     void task218353_relativePaths();
     void task251321_sideBarHiddenEntries();
     void task251341_sideBarRemoveEntries();
+    void task254490_selectFileMultipleTimes();
 
 private:
     QByteArray userSettings;
@@ -1981,5 +1982,37 @@ void tst_QFiledialog::task251341_sideBarRemoveEntries()
     current.rmdir("testDir");
 }
 
+void tst_QFiledialog::task254490_selectFileMultipleTimes()
+{
+    QString tempPath = QDir::tempPath();
+    QTemporaryFile *t;
+    t = new QTemporaryFile;
+    t->open();
+    QNonNativeFileDialog fd(0, "TestFileDialog");
+
+    fd.setDirectory(tempPath);
+    fd.setViewMode(QFileDialog::List);
+    fd.setAcceptMode(QFileDialog::AcceptSave);
+    fd.setFileMode(QFileDialog::AnyFile);
+
+    //This should select the file in the QFileDialog
+    fd.selectFile(t->fileName());
+
+    //This should clear the selection and write it into the filename line edit
+    fd.selectFile("new_file.txt");
+
+    fd.show();
+    QTest::qWait(250);
+
+    QLineEdit *lineEdit = qFindChild<QLineEdit*>(&fd, "fileNameEdit");
+    QVERIFY(lineEdit);
+    QCOMPARE(lineEdit->text(),QLatin1String("new_file.txt"));
+    QListView *list = qFindChild<QListView*>(&fd, "listView");
+    QVERIFY(list);
+    QCOMPARE(list->selectionModel()->selectedRows(0).count(), 0);
+
+    t->deleteLater();
+}
+
 QTEST_MAIN(tst_QFiledialog)
 #include "tst_qfiledialog.moc"
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index b3ae60a..8afdeb4 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -219,6 +219,8 @@ private slots:
     void updateCachedItemAfterMove();
     void deviceTransform_data();
     void deviceTransform();
+    void setTransformProperties_data();
+    void setTransformProperties();
 
     // task specific tests below me
     void task141694_textItemEnsureVisible();
@@ -228,6 +230,7 @@ private slots:
     void task240400_clickOnTextItem_data();
     void task240400_clickOnTextItem();
     void task243707_addChildBeforeParent();
+    void task197802_childrenVisibility();
 };
 
 void tst_QGraphicsItem::init()
@@ -5435,6 +5438,41 @@ void tst_QGraphicsItem::task243707_addChildBeforeParent()
     QVERIFY(!widget2->commonAncestorItem(widget));
 }
 
+void tst_QGraphicsItem::task197802_childrenVisibility()
+{
+    QGraphicsScene scene;
+    QGraphicsRectItem item(QRectF(0,0,20,20));
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(QRectF(0,0,10,10), &item);
+    scene.addItem(&item);
+
+    //freshly created: both visible
+    QVERIFY(item.isVisible());
+    QVERIFY(item2->isVisible());
+
+    //hide child: parent visible, child not
+    item2->hide();
+    QVERIFY(item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //hide parent: parent and child invisible
+    item.hide();
+    QVERIFY(!item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //ask to show the child: parent and child invisible anyways
+    item2->show();
+    QVERIFY(!item.isVisible());
+    QVERIFY(!item2->isVisible());
+
+    //show the parent: both parent and child visible
+    item.show();
+    QVERIFY(item.isVisible());
+    QVERIFY(item2->isVisible());
+
+    delete item2;
+}
+
 void tst_QGraphicsItem::boundingRegion_data()
 {
     QTest::addColumn<QLineF>("line");
@@ -6390,5 +6428,129 @@ void tst_QGraphicsItem::deviceTransform()
     QCOMPARE(rect3->deviceTransform(deviceX).map(QPointF(50, 50)), mapResult3);
 }
 
+void tst_QGraphicsItem::setTransformProperties_data()
+{
+    QTest::addColumn<QPointF>("origin");
+    QTest::addColumn<qreal>("rotationX");
+    QTest::addColumn<qreal>("rotationY");
+    QTest::addColumn<qreal>("rotationZ");
+    QTest::addColumn<qreal>("scaleX");
+    QTest::addColumn<qreal>("scaleY");
+    QTest::addColumn<qreal>("shearX");
+    QTest::addColumn<qreal>("shearY");
+
+    QTest::newRow("nothing") << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+
+    QTest::newRow("rotationZ") << QPointF() << qreal(0.0) << qreal(0.0) << qreal(42.2)
+                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+
+    QTest::newRow("rotationXY") << QPointF() << qreal(12.5) << qreal(53.6) << qreal(0.0)
+                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+
+    QTest::newRow("rotationXYZ") << QPointF() << qreal(-25) << qreal(12) << qreal(556)
+                                          << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+
+    QTest::newRow("rotationXYZ dicentred") << QPointF(-53, 25.2) 
+                                << qreal(-2578.2) << qreal(4565.2) << qreal(56)
+                                << qreal(1) << qreal(1) << qreal(0.0) << qreal(0.0);
+
+    QTest::newRow("Scale")    << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                                          << qreal(6) << qreal(0.5) << qreal(0.0) << qreal(0.0);
+
+    QTest::newRow("Shear")    << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                                          << qreal(1) << qreal(1) << qreal(2.2) << qreal(0.5);
+
+    QTest::newRow("Scale and Shear")    << QPointF() << qreal(0.0) << qreal(0.0) << qreal(0.0)
+                                          << qreal(5.2) << qreal(2.1) << qreal(5.2) << qreal(5.5);
+
+    QTest::newRow("Everything")  << QPointF() << qreal(41) << qreal(-23) << qreal(0.56)
+                                        << qreal(8.2) << qreal(-0.2) << qreal(-12) << qreal(-0.8);
+
+    QTest::newRow("Everything dicentred")  << QPointF(qreal(22.3), qreal(-56.2)) << qreal(-175) << qreal(196) << qreal(-1260)
+                                        << qreal(4) << qreal(2) << qreal(2.56) << qreal(0.8);
+}
+
+void tst_QGraphicsItem::setTransformProperties()
+{
+    QFETCH(QPointF,origin);
+    QFETCH(qreal,rotationX);
+    QFETCH(qreal,rotationY);
+    QFETCH(qreal,rotationZ);
+    QFETCH(qreal,scaleX);
+    QFETCH(qreal,scaleY);
+    QFETCH(qreal,shearX);
+    QFETCH(qreal,shearY);
+
+    QTransform result;
+    result.translate(origin.x(), origin.y());
+    result.rotate(rotationX, Qt::XAxis);
+    result.rotate(rotationY, Qt::YAxis);
+    result.rotate(rotationZ, Qt::ZAxis);
+    result.shear(shearX, shearY);
+    result.scale(scaleX, scaleY);
+    result.translate(-origin.x(), -origin.y());
+
+    QGraphicsScene scene;
+    QGraphicsRectItem *item = new QGraphicsRectItem(QRectF(0, 0, 100, 100));
+    scene.addItem(item);
+    item->setPos(100, 100);
+
+    item->setRotation(rotationX, rotationY, rotationZ);
+    item->setScale(scaleX, scaleY);
+    item->setShear(shearX, shearY);
+    item->setTransformOrigin(origin);
+
+    QCOMPARE(item->xRotation(), rotationX);
+    QCOMPARE(item->yRotation(), rotationY);
+    QCOMPARE(item->zRotation(), rotationZ);
+    QCOMPARE(item->xScale(), scaleX);
+    QCOMPARE(item->yScale(), scaleY);
+    QCOMPARE(item->horizontalShear(), shearX);
+    QCOMPARE(item->verticalShear(), shearY);
+    QCOMPARE(item->transformOrigin(), origin);
+
+    QCOMPARE(result, item->transform());
+
+    //-----------------------------------------------------------------
+    //Change the rotation Z
+    item->setZRotation(45);
+    QTransform result2;
+    result2.translate(origin.x(), origin.y());
+    result2.rotate(rotationX, Qt::XAxis);
+    result2.rotate(rotationY, Qt::YAxis);
+    result2.rotate(45, Qt::ZAxis);
+    result2.shear(shearX, shearY);
+    result2.scale(scaleX, scaleY);
+    result2.translate(-origin.x(), -origin.y());
+
+    QCOMPARE(item->xRotation(), rotationX);
+    QCOMPARE(item->yRotation(), rotationY);
+    QCOMPARE(item->zRotation(), 45.0);
+    QCOMPARE(item->xScale(), scaleX);
+    QCOMPARE(item->yScale(), scaleY);
+    QCOMPARE(item->horizontalShear(), shearX);
+    QCOMPARE(item->verticalShear(), shearY);
+    QCOMPARE(item->transformOrigin(), origin);
+
+    QCOMPARE(result2, item->transform());
+
+    //-----------------------------------------------------------------
+    // calling setTransform() should reset the properties to their default
+    item->setTransform(result);
+
+    QCOMPARE(item->xRotation(), 0.0);
+    QCOMPARE(item->yRotation(), 0.0);
+    QCOMPARE(item->zRotation(), 0.0);
+    QCOMPARE(item->xScale(), 1.0);
+    QCOMPARE(item->yScale(), 1.0);
+    QCOMPARE(item->horizontalShear(), 0.0);
+    QCOMPARE(item->verticalShear(), 0.0);
+    QCOMPARE(item->transformOrigin(), QPointF(0,0));
+
+    QCOMPARE(result, item->transform());
+}
+
+
 QTEST_MAIN(tst_QGraphicsItem)
 #include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qimage/tst_qimage.cpp b/tests/auto/qimage/tst_qimage.cpp
index c6b0560..b7199f3 100644
--- a/tests/auto/qimage/tst_qimage.cpp
+++ b/tests/auto/qimage/tst_qimage.cpp
@@ -131,6 +131,8 @@ private slots:
     void nullSize();
 
     void premultipliedAlphaConsistency();
+
+    void compareIndexed();
 };
 
 tst_QImage::tst_QImage()
@@ -1762,5 +1764,31 @@ void tst_QImage::premultipliedAlphaConsistency()
     }
 }
 
+void tst_QImage::compareIndexed()
+{
+    QImage img(256, 1, QImage::Format_Indexed8);
+
+    QVector<QRgb> colorTable(256);
+    for (int i = 0; i < 256; ++i)
+        colorTable[i] = qRgb(i, i, i);
+    img.setColorTable(colorTable);
+
+    for (int i = 0; i < 256; ++i) {
+        img.setPixel(i, 0, i);
+    }
+
+    QImage imgInverted(256, 1, QImage::Format_Indexed8);
+    QVector<QRgb> invertedColorTable(256);
+    for (int i = 0; i < 256; ++i)
+        invertedColorTable[255-i] = qRgb(i, i, i);
+    imgInverted.setColorTable(invertedColorTable);
+
+    for (int i = 0; i < 256; ++i) {
+        imgInverted.setPixel(i, 0, (255-i));
+    }
+
+    QCOMPARE(img, imgInverted);
+}
+
 QTEST_MAIN(tst_QImage)
 #include "tst_qimage.moc"
diff --git a/tests/auto/qitemdelegate/tst_qitemdelegate.cpp b/tests/auto/qitemdelegate/tst_qitemdelegate.cpp
index 27741e0..615ac01 100644
--- a/tests/auto/qitemdelegate/tst_qitemdelegate.cpp
+++ b/tests/auto/qitemdelegate/tst_qitemdelegate.cpp
@@ -59,6 +59,8 @@
 
 #include <QItemDelegate>
 #include <QAbstractItemDelegate>
+#include <QTextEdit>
+#include <QPlainTextEdit>
 
 Q_DECLARE_METATYPE(QAbstractItemDelegate::EndEditHint)
 
@@ -226,6 +228,8 @@ private slots:
     void decoration();
     void editorEvent_data();
     void editorEvent();
+    void enterKey_data();
+    void enterKey();
 };
 
 
@@ -1048,6 +1052,80 @@ void tst_QItemDelegate::editorEvent()
     QCOMPARE(index.data(Qt::CheckStateRole).toInt(), expectedCheckState);
 }
 
+void tst_QItemDelegate::enterKey_data()
+{
+    QTest::addColumn<int>("widget");
+    QTest::addColumn<int>("key");
+    QTest::addColumn<bool>("expectedFocus");
+    
+    QTest::newRow("lineedit enter") << 1 << int(Qt::Key_Enter) << false;
+    QTest::newRow("textedit enter") << 2 << int(Qt::Key_Enter) << true;
+    QTest::newRow("plaintextedit enter") << 3 << int(Qt::Key_Enter) << true;
+    QTest::newRow("plaintextedit return") << 3 << int(Qt::Key_Return) << true;
+    QTest::newRow("plaintextedit tab") << 3 << int(Qt::Key_Tab) << false;
+    QTest::newRow("lineedit tab") << 1 << int(Qt::Key_Tab) << false;
+}
+
+void tst_QItemDelegate::enterKey()
+{
+    QFETCH(int, widget);
+    QFETCH(int, key);
+    QFETCH(bool, expectedFocus);
+    
+    QStandardItemModel model;
+    model.appendRow(new QStandardItem());
+    
+    QListView view;
+    view.setModel(&model);
+    view.show();
+    QApplication::setActiveWindow(&view);
+    view.setFocus();
+    QTest::qWait(30);
+    
+    struct TestDelegate : public QItemDelegate
+    {
+        int widgetType;
+        virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/) const
+        {
+            QWidget *editor = 0;
+            switch(widgetType) {
+                case 1: 
+                    editor = new QLineEdit(parent);
+                    break;
+                case 2:
+                    editor = new QTextEdit(parent);
+                    break;
+                case 3:
+                    editor = new QPlainTextEdit(parent);
+                    break;
+            }
+            editor->setObjectName(QString::fromLatin1("TheEditor"));
+            return editor;
+        }
+    } delegate;
+    
+    delegate.widgetType = widget;
+    
+    view.setItemDelegate(&delegate);
+    QModelIndex index = model.index(0, 0);
+    view.setCurrentIndex(index); // the editor will only selectAll on the current index
+    view.edit(index);
+    QTest::qWait(30);
+    
+    QList<QWidget*> lineEditors = qFindChildren<QWidget *>(view.viewport(), QString::fromLatin1("TheEditor"));
+    QCOMPARE(lineEditors.count(), 1);
+    
+    QWidget *editor = lineEditors.at(0);
+    QCOMPARE(editor->hasFocus(), true);
+    
+    QTest::keyClick(editor, Qt::Key(key));
+    QApplication::processEvents();
+    
+    QCOMPARE(editor->hasFocus(), expectedFocus);
+}
+
+
+
 // ### _not_ covered:
 
 // editing with a custom editor factory
diff --git a/tests/auto/qmake/tst_qmake.cpp b/tests/auto/qmake/tst_qmake.cpp
index 70f1f3c..1178c81 100644
--- a/tests/auto/qmake/tst_qmake.cpp
+++ b/tests/auto/qmake/tst_qmake.cpp
@@ -63,6 +63,7 @@ public slots:
 
 private slots:
     void simple_app();
+    void simple_app_shadowbuild();
     void simple_lib();
     void simple_dll();
     void subdirs();
@@ -143,6 +144,21 @@ void tst_qmake::simple_app()
     QVERIFY( test_compiler.removeMakefile( workDir ) );
 }
 
+void tst_qmake::simple_app_shadowbuild()
+{
+    QString workDir = base_path + "/testdata/simple_app";
+    QString buildDir = base_path + "/testdata/simple_app_build";
+
+    QVERIFY( test_compiler.qmake( workDir, "simple_app", buildDir ));
+    QVERIFY( test_compiler.make( buildDir ));
+    QVERIFY( test_compiler.exists( buildDir, "simple_app", Exe, "1.0.0" ));
+    QVERIFY( test_compiler.makeClean( buildDir ));
+    QVERIFY( test_compiler.exists( buildDir, "simple_app", Exe, "1.0.0" )); // Should still exist after a make clean
+    QVERIFY( test_compiler.makeDistClean( buildDir ));
+    QVERIFY( !test_compiler.exists( buildDir, "simple_app", Exe, "1.0.0" )); // Should not exist after a make distclean
+    QVERIFY( test_compiler.removeMakefile( buildDir ) );
+}
+
 void tst_qmake::simple_dll()
 {
     QString workDir = base_path + "/testdata/simple_dll";
diff --git a/tests/auto/qobject/tst_qobject.cpp b/tests/auto/qobject/tst_qobject.cpp
index fb46073..399d021 100644
--- a/tests/auto/qobject/tst_qobject.cpp
+++ b/tests/auto/qobject/tst_qobject.cpp
@@ -116,6 +116,7 @@ private slots:
     void dumpObjectInfo();
     void connectToSender();
     void qobjectConstCast();
+    void uniqConnection();
 protected:
 };
 
@@ -204,12 +205,20 @@ public:
 	sequence_slot3 = 0;
 	sequence_slot2 = 0;
 	sequence_slot1 = 0;
+        count_slot1 = 0;
+        count_slot2 = 0;
+        count_slot3 = 0;
+        count_slot4 = 0;
     }
 
     int sequence_slot1;
     int sequence_slot2;
     int sequence_slot3;
     int sequence_slot4;
+    int count_slot1;
+    int count_slot2;
+    int count_slot3;
+    int count_slot4;
 
     bool called(int slot) {
         switch (slot) {
@@ -224,10 +233,10 @@ public:
     static int sequence;
 
 public slots:
-    void slot1() { sequence_slot1 = ++sequence; }
-    void slot2() { sequence_slot2 = ++sequence; }
-    void slot3() { sequence_slot3 = ++sequence; }
-    void slot4() { sequence_slot4 = ++sequence; }
+    void slot1() { sequence_slot1 = ++sequence; count_slot1++; }
+    void slot2() { sequence_slot2 = ++sequence; count_slot2++; }
+    void slot3() { sequence_slot3 = ++sequence; count_slot3++; }
+    void slot4() { sequence_slot4 = ++sequence; count_slot4++; }
 
 };
 
@@ -2783,5 +2792,69 @@ void tst_QObject::qobjectConstCast()
     QVERIFY(qobject_cast<const FooObject *>(cptr));
 }
 
+void tst_QObject::uniqConnection()
+{
+    SenderObject *s = new SenderObject;
+    ReceiverObject *r1 = new ReceiverObject;
+    ReceiverObject *r2 = new ReceiverObject;
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    QVERIFY( connect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r2, SLOT( slot1() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r1, SLOT( slot3() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal3() ), r1, SLOT( slot3() ) , Qt::UniqueConnection) );
+
+    s->emitSignal1();
+    s->emitSignal2();
+    s->emitSignal3();
+    s->emitSignal4();
+
+    QCOMPARE( r1->count_slot1, 1 );
+    QCOMPARE( r1->count_slot2, 0 );
+    QCOMPARE( r1->count_slot3, 2 );
+    QCOMPARE( r1->count_slot4, 0 );
+    QCOMPARE( r2->count_slot1, 1 );
+    QCOMPARE( r2->count_slot2, 0 );
+    QCOMPARE( r2->count_slot3, 0 );
+    QCOMPARE( r2->count_slot4, 0 );
+    QCOMPARE( r1->sequence_slot1, 1 );
+    QCOMPARE( r2->sequence_slot1, 2 );
+    QCOMPARE( r1->sequence_slot3, 4 );
+
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    QVERIFY( connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal4() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY(!connect( s, SIGNAL( signal4() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY( connect( s, SIGNAL( signal1() ), r2, SLOT( slot4() ) , Qt::UniqueConnection) );
+    QVERIFY(!connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) , Qt::UniqueConnection) );
+
+    s->emitSignal4();
+    QCOMPARE( r1->count_slot4, 1 );
+    QCOMPARE( r2->count_slot4, 1 );
+    QCOMPARE( r1->sequence_slot4, 1 );
+    QCOMPARE( r2->sequence_slot4, 2 );
+
+    r1->reset();
+    r2->reset();
+    ReceiverObject::sequence = 0;
+
+    connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) );
+
+    s->emitSignal4();
+    QCOMPARE( r1->count_slot4, 2 );
+    QCOMPARE( r2->count_slot4, 1 );
+    QCOMPARE( r1->sequence_slot4, 3 );
+    QCOMPARE( r2->sequence_slot4, 2 );
+
+    delete s;
+    delete r1;
+    delete r2;
+}
+
 QTEST_MAIN(tst_QObject)
 #include "tst_qobject.moc"
diff --git a/tests/auto/qpixmapcache/tst_qpixmapcache.cpp b/tests/auto/qpixmapcache/tst_qpixmapcache.cpp
index 405ac34..fb5998a 100644
--- a/tests/auto/qpixmapcache/tst_qpixmapcache.cpp
+++ b/tests/auto/qpixmapcache/tst_qpixmapcache.cpp
@@ -369,6 +369,14 @@ void tst_QPixmapCache::remove()
     key = QPixmapCache::insert(p1);
     QCOMPARE(getPrivate(key)->key, 1);
 
+    //Test if pixmaps are correctly deleted
+    QPixmapCache::clear();
+    key = QPixmapCache::insert(p1);
+    QCOMPARE(getPrivate(key)->key, 1);
+    QVERIFY(QPixmapCache::find(key, &p1) != 0);
+    QPixmapCache::remove(key);
+    QCOMPARE(p1.isDetached(), true);
+
     //We mix both part of the API
     QPixmapCache::clear();
     p1.fill(Qt::red);
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
index 7e910d4..0aeac91 100644
--- a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -63,6 +63,18 @@ protected:
     }
 };
 
+class MyObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal x READ x WRITE setX) 
+public:
+    MyObject() : m_x(0) { }
+    qreal x() const { return m_x; }
+    void setX(qreal x) { m_x = x; }
+private:
+    qreal m_x;
+};
+
 class tst_QPropertyAnimation : public QObject
 {
   Q_OBJECT
@@ -92,6 +104,7 @@ private slots:
     void startWithoutStartValue();
     void playForwardBackward();
     void interpolated();
+    void setStartEndValues_data();
     void setStartEndValues();
     void zeroDurationStart();
     void operationsInStates_data();
@@ -283,7 +296,7 @@ void tst_QPropertyAnimation::statesAndSignals()
 void tst_QPropertyAnimation::deletion1()
 {
     QObject *object = new QWidget;
-    QPointer<QPropertyAnimation> anim = new QPropertyAnimation(object,"minimumWidth");
+    QPointer<QPropertyAnimation> anim = new QPropertyAnimation(object, "minimumWidth");
 
     //test that the animation is deleted correctly depending of the deletion flag passed in start()
     QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
@@ -686,52 +699,78 @@ void tst_QPropertyAnimation::interpolated()
     }
 }
 
+Q_DECLARE_METATYPE(QVariant)
+
+void tst_QPropertyAnimation::setStartEndValues_data()
+{
+    QTest::addColumn<QByteArray>("propertyName");
+    QTest::addColumn<QVariant>("initialValue");
+    QTest::addColumn<QVariant>("startValue");
+    QTest::addColumn<QVariant>("endValue");
+
+    QTest::newRow("dynamic property")  << QByteArray("ole") << QVariant(42) << QVariant(0) << QVariant(10);
+    QTest::newRow("real property, with unmatching types") << QByteArray("x") << QVariant(42.) << QVariant(0) << QVariant(10.);
+}
+
 void tst_QPropertyAnimation::setStartEndValues()
 {
+    MyObject object;
+    QFETCH(QByteArray, propertyName);
+    QFETCH(QVariant, initialValue);
+    QFETCH(QVariant, startValue);
+    QFETCH(QVariant, endValue);
+
     //this tests the start value, end value and default start value
-    QObject o;
-    o.setProperty("ole", 42);
-    QPropertyAnimation anim(&o, "ole");
+    object.setProperty(propertyName, initialValue);
+    QPropertyAnimation anim(&object, propertyName);
     QVariantAnimation::KeyValues values;
     QCOMPARE(anim.keyValues(), values);
 
     //let's add a start value
-    anim.setStartValue(0);
-    values << QVariantAnimation::KeyValue(0, 0);
+    anim.setStartValue(startValue);
+    values << QVariantAnimation::KeyValue(0, startValue);
     QCOMPARE(anim.keyValues(), values);
 
-    anim.setEndValue(10);
-    values << QVariantAnimation::KeyValue(1, 10);
+    anim.setEndValue(endValue);
+    values << QVariantAnimation::KeyValue(1, endValue);
     QCOMPARE(anim.keyValues(), values);
 
     //now we can play with objects
-    QCOMPARE(o.property("ole").toInt(), 42);
-    QCOMPARE(o.property("ole").toInt(), 42);
+    QCOMPARE(object.property(propertyName).toDouble(), initialValue.toDouble());
     anim.start();
     QVERIFY(anim.startValue().isValid());
-    QCOMPARE(o.property("ole"), anim.startValue());
+    QCOMPARE(object.property(propertyName), anim.startValue());
+    anim.setCurrentTime(anim.duration()/2);
+    QCOMPARE(object.property(propertyName).toDouble(), (startValue.toDouble() + endValue.toDouble())/2 ); //just in the middle of the animation
+    anim.setCurrentTime(anim.duration()); //we go to the end of the animation
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped); //it should have stopped
+    QVERIFY(anim.endValue().isValid());
+    QCOMPARE(object.property(propertyName), anim.endValue()); //end of the animations
 
     //now we remove the explicit start value and test the implicit one
     anim.stop();
-    o.setProperty("ole", 42);
+    object.setProperty(propertyName, initialValue);
+
+    //let's reset the start value
     values.remove(0);
-    anim.setStartValue(QVariant()); //reset the start value
+    anim.setStartValue(QVariant());
     QCOMPARE(anim.keyValues(), values);
     QVERIFY(!anim.startValue().isValid());
+
     anim.start();
-    QCOMPARE(o.property("ole").toInt(), 42);
+    QCOMPARE(object.property(propertyName), initialValue);
     anim.setCurrentTime(anim.duration()/2);
-    QCOMPARE(o.property("ole").toInt(), 26); //just in the middle of the animation
-    anim.setCurrentTime(anim.duration());
+    QCOMPARE(object.property(propertyName).toDouble(), (initialValue.toDouble() + endValue.toDouble())/2 ); //just in the middle of the animation
+    anim.setCurrentTime(anim.duration()); //we go to the end of the animation
     QCOMPARE(anim.state(), QAnimationGroup::Stopped); //it should have stopped
     QVERIFY(anim.endValue().isValid());
-    QCOMPARE(o.property("ole"), anim.endValue()); //end of the animations
+    QCOMPARE(object.property(propertyName), anim.endValue()); //end of the animations
 
     //now we set back the startValue
-    anim.setStartValue(5);
+    anim.setStartValue(startValue);
     QVERIFY(anim.startValue().isValid());
     anim.start();
-    QCOMPARE(o.property("ole").toInt(), 5);
+    QCOMPARE(object.property(propertyName), startValue);
 }
 
 void tst_QPropertyAnimation::zeroDurationStart()
diff --git a/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp b/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
index f414d3a..d7c231f 100644
--- a/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
+++ b/tests/auto/qsortfilterproxymodel/tst_qsortfilterproxymodel.cpp
@@ -2585,6 +2585,16 @@ void tst_QSortFilterProxyModel::task248868_dynamicSorting()
         QModelIndex index = proxy1.index(row, 0, QModelIndex());
         QCOMPARE(proxy1.data(index, Qt::DisplayRole).toString(), expected.at(row));
     }
+
+    //set up the sorting before seting the model up
+    QSortFilterProxyModel proxy2;
+    proxy2.setDynamicSortFilter(true);
+    proxy2.sort(0);
+    proxy2.setSourceModel(&model2);
+    for (int row = 0; row < proxy2.rowCount(QModelIndex()); ++row) {
+        QModelIndex index = proxy2.index(row, 0, QModelIndex());
+        QCOMPARE(proxy2.data(index, Qt::DisplayRole).toString(), expected.at(row));
+    }
 }
 
 class QtTestModel: public QAbstractItemModel
diff --git a/tests/auto/qstatemachine/tst_qstatemachine.cpp b/tests/auto/qstatemachine/tst_qstatemachine.cpp
index 7476831..768a683 100644
--- a/tests/auto/qstatemachine/tst_qstatemachine.cpp
+++ b/tests/auto/qstatemachine/tst_qstatemachine.cpp
@@ -81,6 +81,24 @@ static int globalTick;
     QCoreApplication::exec(); \
 }
 
+class SignalEmitter : public QObject
+{
+Q_OBJECT
+    public:
+    SignalEmitter(QObject *parent = 0)
+        : QObject(parent) {}
+    void emitSignalWithNoArg()
+        { emit signalWithNoArg(); }
+    void emitSignalWithIntArg(int arg)
+        { emit signalWithIntArg(arg); }
+    void emitSignalWithStringArg(const QString &arg)
+        { emit signalWithStringArg(arg); }
+Q_SIGNALS:
+    void signalWithNoArg();
+    void signalWithIntArg(int);
+    void signalWithStringArg(const QString &);
+};
+
 class tst_QStateMachine : public QObject
 {
     Q_OBJECT
@@ -212,32 +230,12 @@ protected:
     }
 };
 
-static QtMsgType s_msgType;
-static QByteArray s_msg;
-static bool s_countWarnings;
-static QtMsgHandler s_oldHandler;
-
-static void defaultErrorStateTestMessageHandler(QtMsgType type, const char *msg)
-{    
-    s_msgType = type;
-    s_msg = msg;
-    
-    if (s_countWarnings)
-        s_oldHandler(type, msg);
-}
-
 void tst_QStateMachine::init()
 {
-    s_msg = QByteArray();
-    s_msgType = QtDebugMsg;
-    s_countWarnings = true;
-
-    s_oldHandler = qInstallMsgHandler(defaultErrorStateTestMessageHandler);
 }
 
 void tst_QStateMachine::cleanup()
 {
-    qInstallMsgHandler(s_oldHandler);
 }
 
 class EventTransition : public QAbstractTransition
@@ -256,14 +254,13 @@ private:
 
 void tst_QStateMachine::transitionToRootState()
 {
-    s_countWarnings = false;
-
     QStateMachine machine;
 
     QState *initialState = new QState();
     machine.addState(initialState);
     machine.setInitialState(initialState);
 
+    QTest::ignoreMessage(QtWarningMsg, "QAbstractTransition::setTargetStates: root state cannot be target of transition");
     initialState->addTransition(new EventTransition(QEvent::User, machine.rootState()));
 
     machine.start();
@@ -346,8 +343,6 @@ void tst_QStateMachine::transitionEntersParent()
 
 void tst_QStateMachine::defaultErrorState()
 {
-    s_countWarnings = false; // we expect warnings here 
-
     QStateMachine machine;
     QVERIFY(machine.errorState() != 0);
 
@@ -360,14 +355,12 @@ void tst_QStateMachine::defaultErrorState()
     QState *childState = new QState(brokenState);
     childState->setObjectName("childState");
 
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state 'MyInitialState'");
+
     // initialState has no initial state
     machine.start();
     QCoreApplication::processEvents();
 
-    QCOMPARE(s_msgType, QtWarningMsg);
-    QCOMPARE(QString::fromLatin1(s_msg.data()), 
-             QString::fromLatin1("Unrecoverable error detected in running state machine: Missing initial state in compound state 'MyInitialState'"));
-
     QCOMPARE(machine.error(), QStateMachine::NoInitialStateError);
     QCOMPARE(machine.errorString(), QString::fromLatin1("Missing initial state in compound state 'MyInitialState'"));
 
@@ -436,8 +429,6 @@ void tst_QStateMachine::customGlobalErrorState()
     QCOMPARE(customErrorState->errorString, QString::fromLatin1("Missing initial state in compound state 'brokenState'"));
     QCOMPARE(machine.error(), QStateMachine::NoInitialStateError);
     QCOMPARE(machine.errorString(), QString::fromLatin1("Missing initial state in compound state 'brokenState'"));
-    QVERIFY(s_msg.isEmpty());
-    QCOMPARE(s_msgType, QtDebugMsg);
 }
 
 void tst_QStateMachine::customLocalErrorStateInBrokenState()
@@ -453,7 +444,7 @@ void tst_QStateMachine::customLocalErrorStateInBrokenState()
 
     QState *brokenState = new QState();
     brokenState->setObjectName("brokenState");
-    machine.addState(brokenState);    
+    machine.addState(brokenState);        
     brokenState->setErrorState(customErrorState);    
 
     QState *childState = new QState(brokenState);
@@ -461,7 +452,7 @@ void tst_QStateMachine::customLocalErrorStateInBrokenState()
 
     initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
 
-    machine.start();
+    machine.start();    
     QCoreApplication::processEvents();
 
     machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
@@ -470,19 +461,17 @@ void tst_QStateMachine::customLocalErrorStateInBrokenState()
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(customErrorState));
     QCOMPARE(customErrorState->error, QStateMachine::NoInitialStateError);
-    QVERIFY(s_msg.isEmpty());
 }
 
 void tst_QStateMachine::customLocalErrorStateInOtherState()
 {
-    s_countWarnings = false;
-
     QStateMachine machine;
     CustomErrorState *customErrorState = new CustomErrorState(&machine);
     machine.addState(customErrorState);
 
     QState *initialState = new QState();
     initialState->setObjectName("initialState");
+    QTest::ignoreMessage(QtWarningMsg, "QState::setErrorState: error state cannot belong to a different state machine");    
     initialState->setErrorState(customErrorState);
     machine.addState(initialState);
     machine.setInitialState(initialState);
@@ -497,6 +486,7 @@ void tst_QStateMachine::customLocalErrorStateInOtherState()
 
     initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
 
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state 'brokenState'");
     machine.start();
     QCoreApplication::processEvents();
 
@@ -505,7 +495,6 @@ void tst_QStateMachine::customLocalErrorStateInOtherState()
 
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(machine.errorState()));
-    QCOMPARE(s_msgType, QtWarningMsg);
 }
 
 void tst_QStateMachine::customLocalErrorStateInParentOfBrokenState()
@@ -522,8 +511,7 @@ void tst_QStateMachine::customLocalErrorStateInParentOfBrokenState()
     QState *parentOfBrokenState = new QState();
     machine.addState(parentOfBrokenState);
     parentOfBrokenState->setObjectName("parentOfBrokenState");
-    parentOfBrokenState->setErrorState(customErrorState);
-    
+    parentOfBrokenState->setErrorState(customErrorState);    
 
     QState *brokenState = new QState(parentOfBrokenState);
     brokenState->setObjectName("brokenState");
@@ -542,7 +530,6 @@ void tst_QStateMachine::customLocalErrorStateInParentOfBrokenState()
 
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(customErrorState));
-    QVERIFY(s_msg.isEmpty());
 }
 
 void tst_QStateMachine::customLocalErrorStateOverridesParent()
@@ -584,7 +571,6 @@ void tst_QStateMachine::customLocalErrorStateOverridesParent()
     QVERIFY(machine.configuration().contains(customErrorStateForBrokenState));
     QCOMPARE(customErrorStateForBrokenState->error, QStateMachine::NoInitialStateError);
     QCOMPARE(customErrorStateForParent->error, QStateMachine::NoError);
-    QVERIFY(s_msg.isEmpty());
 }
 
 void tst_QStateMachine::errorStateHasChildren()
@@ -623,14 +609,11 @@ void tst_QStateMachine::errorStateHasChildren()
     QCOMPARE(machine.configuration().count(), 2);
     QVERIFY(machine.configuration().contains(customErrorState));
     QVERIFY(machine.configuration().contains(childOfErrorState)); 
-    QVERIFY(s_msg.isEmpty());
 }
 
 
 void tst_QStateMachine::errorStateHasErrors()
 {
-    s_countWarnings = false;
-
     QStateMachine machine;
     CustomErrorState *customErrorState = new CustomErrorState(&machine);
     customErrorState->setObjectName("customErrorState");
@@ -660,21 +643,19 @@ void tst_QStateMachine::errorStateHasErrors()
     QCoreApplication::processEvents();
 
     machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state 'customErrorState'");
     QCoreApplication::processEvents();
 
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(oldErrorState)); // Fall back to default
     QCOMPARE(machine.error(), QStateMachine::NoInitialStateError);
     QCOMPARE(machine.errorString(), QString::fromLatin1("Missing initial state in compound state 'customErrorState'"));
-
-    QCOMPARE(s_msgType, QtWarningMsg);
 }
 
 void tst_QStateMachine::errorStateIsRootState()
 {
-    s_countWarnings = false;
-
     QStateMachine machine;
+    QTest::ignoreMessage(QtWarningMsg, "QStateMachine::setErrorState: root state cannot be error state");
     machine.setErrorState(machine.rootState());
 
     QState *initialState = new QState();
@@ -695,6 +676,7 @@ void tst_QStateMachine::errorStateIsRootState()
     QCoreApplication::processEvents();
 
     machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state 'brokenState'");
     QCoreApplication::processEvents();
 
     QCOMPARE(machine.configuration().count(), 1);    
@@ -775,8 +757,6 @@ void tst_QStateMachine::errorStateEntersParentFirst()
 
 void tst_QStateMachine::customErrorStateIsNull()
 {
-    s_countWarnings = false;
-
     QStateMachine machine;
     QAbstractState *oldErrorState = machine.errorState();
     machine.rootState()->setErrorState(0);
@@ -795,12 +775,12 @@ void tst_QStateMachine::customErrorStateIsNull()
     QCoreApplication::processEvents();
 
     machine.postEvent(new QEvent(QEvent::User));
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state ''");
     QCoreApplication::processEvents();
 
     QCOMPARE(machine.errorState(), reinterpret_cast<void *>(0));
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(oldErrorState));
-    QCOMPARE(s_msgType, QtWarningMsg);
 }
 
 void tst_QStateMachine::clearError()
@@ -891,7 +871,7 @@ void tst_QStateMachine::brokenStateIsNeverEntered()
 {
     QStateMachine machine;
 
-    QObject *entryController = new QObject();
+    QObject *entryController = new QObject(&machine);
     entryController->setProperty("brokenStateEntered", false);
     entryController->setProperty("childStateEntered", false);
     entryController->setProperty("errorStateEntered", false);
@@ -925,19 +905,18 @@ void tst_QStateMachine::brokenStateIsNeverEntered()
 
 void tst_QStateMachine::transitionToStateNotInGraph()
 {
-    s_countWarnings = false;
-
-    QStateMachine machine;
+    QStateMachine machine;    
 
     QState *initialState = new QState(machine.rootState());
     initialState->setObjectName("initialState");
     machine.setInitialState(initialState);
 
-    QState *independentState = new QState();
-    independentState->setObjectName("independentState");
-    initialState->addTransition(independentState);
+    QState independentState;
+    independentState.setObjectName("independentState");
+    initialState->addTransition(&independentState);
 
     machine.start();
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: No common ancestor for targets and source of transition from state 'initialState'");
     QCoreApplication::processEvents();
 
     QCOMPARE(machine.configuration().count(), 1);
@@ -946,14 +925,13 @@ void tst_QStateMachine::transitionToStateNotInGraph()
 
 void tst_QStateMachine::customErrorStateNotInGraph()
 {
-    s_countWarnings = false;
-
     QStateMachine machine;
 
-    QState *errorState = new QState();
-    errorState->setObjectName("errorState");
-    machine.setErrorState(errorState);
-    QVERIFY(errorState != machine.errorState());
+    QState errorState;
+    errorState.setObjectName("errorState");
+    QTest::ignoreMessage(QtWarningMsg, "QState::setErrorState: error state cannot belong to a different state machine");
+    machine.setErrorState(&errorState);
+    QVERIFY(&errorState != machine.errorState());
 
     QState *initialBrokenState = new QState(machine.rootState());
     initialBrokenState->setObjectName("initialBrokenState");
@@ -961,6 +939,7 @@ void tst_QStateMachine::customErrorStateNotInGraph()
     new QState(initialBrokenState);
 
     machine.start();
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state 'initialBrokenState'");
     QCoreApplication::processEvents();
     
     QCOMPARE(machine.configuration().count(), 1);
@@ -969,13 +948,14 @@ void tst_QStateMachine::customErrorStateNotInGraph()
 
 void tst_QStateMachine::restoreProperties()
 {
-    QObject *object = new QObject();
-    object->setProperty("a", 1);
-    object->setProperty("b", 2);
-
     QStateMachine machine;
+    QCOMPARE(machine.globalRestorePolicy(), QStateMachine::DoNotRestoreProperties);
     machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
 
+    QObject *object = new QObject(&machine);
+    object->setProperty("a", 1);
+    object->setProperty("b", 2);
+
     QState *S1 = new QState();
     S1->setObjectName("S1");
     S1->assignProperty(object, "a", 3);
@@ -1024,6 +1004,7 @@ void tst_QStateMachine::rootState()
     QVERIFY(qobject_cast<QState*>(machine.rootState()) != 0);
     QCOMPARE(qobject_cast<QState*>(machine.rootState())->parentState(), (QState*)0);
     QCOMPARE(machine.rootState()->parent(), (QObject*)&machine);
+    QCOMPARE(machine.rootState()->machine(), &machine);
 
     QState *s1 = new QState(machine.rootState());
     QCOMPARE(s1->parentState(), machine.rootState());
@@ -1045,7 +1026,9 @@ void tst_QStateMachine::addAndRemoveState()
 
     QState *s1 = new QState();
     QCOMPARE(s1->parentState(), (QState*)0);
+    QCOMPARE(s1->machine(), (QStateMachine*)0);
     machine.addState(s1);
+    QCOMPARE(s1->machine(), &machine);
     QCOMPARE(s1->parentState(), machine.rootState());
     QCOMPARE(root_d->childStates().size(), 2);
     QCOMPARE(root_d->childStates().at(0), (QAbstractState*)machine.errorState());
@@ -1080,6 +1063,20 @@ void tst_QStateMachine::addAndRemoveState()
     QTest::ignoreMessage(QtWarningMsg, "QStateMachine::removeState: cannot remove null state");
     machine.removeState(0);
 
+    {
+        QStateMachine machine2;
+        {
+            char warning[256];
+            sprintf(warning, "QStateMachine::removeState: state %p's machine (%p) is different from this machine (%p)",
+                    machine2.rootState(), &machine2, &machine);
+            QTest::ignoreMessage(QtWarningMsg, warning);
+            machine.removeState(machine2.rootState());
+        }
+        // ### check this behavior
+        machine.addState(machine2.rootState());
+        QCOMPARE(machine2.rootState()->parent(), (QObject*)machine.rootState());
+    }
+
     delete s1;
     delete s2;
     // ### how to deal with this?
@@ -1102,13 +1099,40 @@ void tst_QStateMachine::stateEntryAndExit()
 
         TestState *s2 = new TestState(machine.rootState());
         QFinalState *s3 = new QFinalState(machine.rootState());
+
         TestTransition *t = new TestTransition(s2);
+        QCOMPARE(t->machine(), (QStateMachine*)0);
+        QCOMPARE(t->sourceState(), (QState*)0);
+        QCOMPARE(t->targetState(), s2);
+        QCOMPARE(t->targetStates().size(), 1);
+        QCOMPARE(t->targetStates().at(0), s2);
+        t->setTargetState(0);
+        QCOMPARE(t->targetState(), (QState*)0);
+        QVERIFY(t->targetStates().isEmpty());
+        t->setTargetState(s2);
+        QCOMPARE(t->targetState(), s2);
+        QTest::ignoreMessage(QtWarningMsg, "QAbstractTransition::setTargetStates: target state(s) cannot be null");
+        t->setTargetStates(QList<QAbstractState*>() << 0);
+        QCOMPARE(t->targetState(), s2);
+        t->setTargetStates(QList<QAbstractState*>() << s2);
+        QCOMPARE(t->targetState(), s2);
+        QCOMPARE(t->targetStates().size(), 1);
+        QCOMPARE(t->targetStates().at(0), s2);
         QCOMPARE(s1->addTransition(t), (QAbstractTransition*)t);
+        QCOMPARE(t->sourceState(), s1);
+        QCOMPARE(t->machine(), &machine);
+
         {
             QAbstractTransition *trans = s2->addTransition(s3);
             QVERIFY(trans != 0);
             QCOMPARE(trans->sourceState(), (QAbstractState*)s2);
             QCOMPARE(trans->targetState(), (QAbstractState*)s3);
+            {
+                char warning[256];
+                sprintf(warning, "QState::removeTransition: transition %p's source state (%p) is different from this state (%p)", trans, s2, s1);
+                QTest::ignoreMessage(QtWarningMsg, warning);
+                s1->removeTransition(trans);
+            }
             s2->removeTransition(trans);
             QCOMPARE(trans->sourceState(), (QAbstractState*)0);
             QCOMPARE(trans->targetState(), (QAbstractState*)s3);
@@ -1120,6 +1144,14 @@ void tst_QStateMachine::stateEntryAndExit()
         QSignalSpy stoppedSpy(&machine, SIGNAL(stopped()));
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
         machine.setInitialState(s1);
+        QCOMPARE(machine.initialState(), (QAbstractState*)s1);
+        {
+            char warning[256];
+            sprintf(warning, "QState::setInitialState: state %p is not a child of this state (%p)", machine.rootState(), machine.rootState());
+            QTest::ignoreMessage(QtWarningMsg, warning);
+            machine.setInitialState(machine.rootState());
+            QCOMPARE(machine.initialState(), (QAbstractState*)s1);
+        }
         QVERIFY(machine.configuration().isEmpty());
         globalTick = 0;
         QVERIFY(!machine.isRunning());
@@ -1252,6 +1284,11 @@ void tst_QStateMachine::assignPropertyWithAnimation()
     // Single animation
     {
         QStateMachine machine;
+        QVERIFY(machine.animationsEnabled());
+        machine.setAnimationsEnabled(false);
+        QVERIFY(!machine.animationsEnabled());
+        machine.setAnimationsEnabled(true);
+        QVERIFY(machine.animationsEnabled());
         QObject obj;
         obj.setProperty("foo", 321);
         obj.setProperty("bar", 654);
@@ -1261,9 +1298,22 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         s2->assignProperty(&obj, "foo", 456);
         s2->assignProperty(&obj, "bar", 789);
         QAbstractTransition *trans = s1->addTransition(s2);
+        QVERIFY(trans->animations().isEmpty());
+        QTest::ignoreMessage(QtWarningMsg, "QAbstractTransition::addAnimation: cannot add null animation");
+        trans->addAnimation(0);
         QPropertyAnimation anim(&obj, "foo");
         anim.setDuration(250);
         trans->addAnimation(&anim);
+        QCOMPARE(trans->animations().size(), 1);
+        QCOMPARE(trans->animations().at(0), (QAbstractAnimation*)&anim);
+        QCOMPARE(anim.parent(), (QObject*)0);
+        QTest::ignoreMessage(QtWarningMsg, "QAbstractTransition::removeAnimation: cannot remove null animation");
+        trans->removeAnimation(0);
+        trans->removeAnimation(&anim);
+        QVERIFY(trans->animations().isEmpty());
+        trans->addAnimation(&anim);
+        QCOMPARE(trans->animations().size(), 1);
+        QCOMPARE(trans->animations().at(0), (QAbstractAnimation*)&anim);
         QFinalState *s3 = new QFinalState(machine.rootState());
         s2->addTransition(s2, SIGNAL(polished()), s3);
 
@@ -1339,6 +1389,10 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         obj.setProperty("bar", 654);
         QState *s1 = new QState(machine.rootState());
         QCOMPARE(s1->childMode(), QState::ExclusiveStates);
+        s1->setChildMode(QState::ParallelStates);
+        QCOMPARE(s1->childMode(), QState::ParallelStates);
+        s1->setChildMode(QState::ExclusiveStates);
+        QCOMPARE(s1->childMode(), QState::ExclusiveStates);
         QCOMPARE(s1->initialState(), (QAbstractState*)0);
         s1->setObjectName("s1");
         s1->assignProperty(&obj, "foo", 123);
@@ -1375,6 +1429,44 @@ void tst_QStateMachine::assignPropertyWithAnimation()
         QCOMPARE(obj.property("foo").toInt(), 321);
         QCOMPARE(obj.property("bar").toInt(), 789);
     }
+    // Aborted animation
+    {
+        QStateMachine machine;
+        SignalEmitter emitter;
+        QObject obj;
+        obj.setProperty("foo", 321);
+        obj.setProperty("bar", 654);
+        QState *group = new QState(machine.rootState());
+        QState *s1 = new QState(group);
+        group->setInitialState(s1);
+        s1->assignProperty(&obj, "foo", 123);
+        QState *s2 = new QState(group);
+        s2->assignProperty(&obj, "foo", 456);
+        s2->assignProperty(&obj, "bar", 789);
+        QAbstractTransition *trans = s1->addTransition(&emitter, SIGNAL(signalWithNoArg()), s2);
+        QPropertyAnimation anim(&obj, "foo");
+        anim.setDuration(8000);
+        trans->addAnimation(&anim);
+        QPropertyAnimation anim2(&obj, "bar");
+        anim2.setDuration(8000);
+        trans->addAnimation(&anim2);
+        QState *s3 = new QState(group);
+        s3->assignProperty(&obj, "foo", 911);
+        s2->addTransition(&emitter, SIGNAL(signalWithNoArg()), s3);
+
+        machine.setInitialState(group);
+        machine.start();
+        QTRY_COMPARE(machine.configuration().contains(s1), true);
+        QSignalSpy polishedSpy(s2, SIGNAL(polished()));
+        emitter.emitSignalWithNoArg();
+        QTRY_COMPARE(machine.configuration().contains(s2), true);
+        QVERIFY(polishedSpy.isEmpty());
+        emitter.emitSignalWithNoArg(); // will cause animations from s1-->s2 to abort
+        QTRY_COMPARE(machine.configuration().contains(s3), true);
+        QVERIFY(polishedSpy.isEmpty());
+        QCOMPARE(obj.property("foo").toInt(), 911);
+        QCOMPARE(obj.property("bar").toInt(), 789);
+    }
 }
 
 struct StringEvent : public QEvent
@@ -1412,47 +1504,59 @@ class StringEventPoster : public QState
 {
 public:
     StringEventPoster(QStateMachine *machine, const QString &value, QState *parent = 0)
-        : QState(parent), m_machine(machine), m_value(value) {}
+        : QState(parent), m_machine(machine), m_value(value), m_delay(0) {}
 
     void setString(const QString &value)
         { m_value = value; }
+    void setDelay(int delay)
+        { m_delay = delay; }
 
 protected:
     virtual void onEntry(QEvent *)
     {
-        m_machine->postEvent(new StringEvent(m_value));
+        m_machine->postEvent(new StringEvent(m_value), m_delay);
     }
     virtual void onExit(QEvent *) {}
 
 private:
     QStateMachine *m_machine;
     QString m_value;
+    int m_delay;
 };
 
 void tst_QStateMachine::postEvent()
 {
-    QStateMachine machine;
-    StringEventPoster *s1 = new StringEventPoster(&machine, "a");
-    QFinalState *s2 = new QFinalState;
-    s1->addTransition(new StringTransition("a", s2));
-    machine.addState(s1);
-    machine.addState(s2);
-    machine.setInitialState(s1);
-    QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
-    machine.start();
-    QTRY_COMPARE(finishedSpy.count(), 1);
-    QCOMPARE(machine.configuration().size(), 1);
-    QVERIFY(machine.configuration().contains(s2));
+    for (int x = 0; x < 2; ++x) {
+        QStateMachine machine;
+        {
+            QEvent e(QEvent::None);
+            QTest::ignoreMessage(QtWarningMsg, "QStateMachine::postEvent: cannot post event when the state machine is not running");
+            machine.postEvent(&e);
+        }
+        StringEventPoster *s1 = new StringEventPoster(&machine, "a");
+        if (x == 1)
+            s1->setDelay(100);
+        QFinalState *s2 = new QFinalState;
+        s1->addTransition(new StringTransition("a", s2));
+        machine.addState(s1);
+        machine.addState(s2);
+        machine.setInitialState(s1);
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.start();
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s2));
 
-    s1->setString("b");
-    QFinalState *s3 = new QFinalState();
-    machine.addState(s3);
-    s1->addTransition(new StringTransition("b", s3));
-    finishedSpy.clear();
-    machine.start();
-    QTRY_COMPARE(finishedSpy.count(), 1);
-    QCOMPARE(machine.configuration().size(), 1);
-    QVERIFY(machine.configuration().contains(s3));
+        s1->setString("b");
+        QFinalState *s3 = new QFinalState();
+        machine.addState(s3);
+        s1->addTransition(new StringTransition("b", s3));
+        finishedSpy.clear();
+        machine.start();
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s3));
+    }
 }
 
 void tst_QStateMachine::stateFinished()
@@ -1489,6 +1593,12 @@ void tst_QStateMachine::parallelStates()
         QFinalState *s1_2_f = new QFinalState(s1_2);
         s1_2_1->addTransition(s1_2_f);
       s1_2->setInitialState(s1_2_1);
+    {
+        char warning[256];
+        sprintf(warning, "QState::setInitialState: ignoring attempt to set initial state of parallel state group %p", s1);
+        QTest::ignoreMessage(QtWarningMsg, warning);
+        s1->setInitialState(0);
+    }
     machine.addState(s1);
 
     QFinalState *s2 = new QFinalState();
@@ -1566,29 +1676,11 @@ void tst_QStateMachine::allSourceToTargetConfigurations()
     QTRY_COMPARE(finishedSpy.count(), 1);
 }
 
-class SignalEmitter : public QObject
-{
-Q_OBJECT
-    public:
-    SignalEmitter(QObject *parent = 0)
-        : QObject(parent) {}
-    void emitSignalWithNoArg()
-        { emit signalWithNoArg(); }
-    void emitSignalWithIntArg(int arg)
-        { emit signalWithIntArg(arg); }
-    void emitSignalWithStringArg(const QString &arg)
-        { emit signalWithStringArg(arg); }
-Q_SIGNALS:
-    void signalWithNoArg();
-    void signalWithIntArg(int);
-    void signalWithStringArg(const QString &);
-};
-
 class TestSignalTransition : public QSignalTransition
 {
 public:
-    TestSignalTransition()
-        : QSignalTransition() {}
+    TestSignalTransition(QState *sourceState = 0)
+        : QSignalTransition(sourceState) {}
     TestSignalTransition(QObject *sender, const char *signal,
                          QAbstractState *target)
         : QSignalTransition(sender, signal, QList<QAbstractState*>() << target) {}
@@ -1626,14 +1718,12 @@ void tst_QStateMachine::signalTransitions()
         QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: no such signal SignalEmitter::noSuchSignal()");
         QCOMPARE(s0->addTransition(&emitter, SIGNAL(noSuchSignal()), s1), (QObject*)0);
 
-        {
-            QSignalTransition *trans = s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), s1);
-            QVERIFY(trans != 0);
-            QCOMPARE(trans->sourceState(), s0);
-            QCOMPARE(trans->targetState(), (QAbstractState*)s1);
-            QCOMPARE(trans->senderObject(), (QObject*)&emitter);
-            QCOMPARE(trans->signal(), QByteArray(SIGNAL(signalWithNoArg())));
-        }
+        QSignalTransition *trans = s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), s1);
+        QVERIFY(trans != 0);
+        QCOMPARE(trans->sourceState(), s0);
+        QCOMPARE(trans->targetState(), (QAbstractState*)s1);
+        QCOMPARE(trans->senderObject(), (QObject*)&emitter);
+        QCOMPARE(trans->signal(), QByteArray(SIGNAL(signalWithNoArg())));
 
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
         machine.setInitialState(s0);
@@ -1645,6 +1735,33 @@ void tst_QStateMachine::signalTransitions()
         QTRY_COMPARE(finishedSpy.count(), 1);
 
         emitter.emitSignalWithNoArg();
+
+        trans->setSignal(SIGNAL(signalWithIntArg(int)));
+        QCOMPARE(trans->signal(), QByteArray(SIGNAL(signalWithIntArg(int))));
+        machine.start();
+        QCoreApplication::processEvents();
+        emitter.emitSignalWithIntArg(123);
+        QTRY_COMPARE(finishedSpy.count(), 2);
+
+        machine.start();
+        QCoreApplication::processEvents();
+        trans->setSignal(SIGNAL(signalWithNoArg()));
+        QCOMPARE(trans->signal(), QByteArray(SIGNAL(signalWithNoArg())));
+        emitter.emitSignalWithNoArg();
+        QTRY_COMPARE(finishedSpy.count(), 3);
+
+        SignalEmitter emitter2;
+        machine.start();
+        QCoreApplication::processEvents();
+        trans->setSenderObject(&emitter2);
+        emitter2.emitSignalWithNoArg();
+        QTRY_COMPARE(finishedSpy.count(), 4);
+
+        machine.start();
+        QCoreApplication::processEvents();
+        QTest::ignoreMessage(QtWarningMsg, "QSignalTransition: no such signal: SignalEmitter::noSuchSignal()");
+        trans->setSignal(SIGNAL(noSuchSignal()));
+        QCOMPARE(trans->signal(), QByteArray(SIGNAL(noSuchSignal())));
     }
     {
         QStateMachine machine;
@@ -1756,20 +1873,65 @@ void tst_QStateMachine::signalTransitions()
         QCOMPARE(machine.configuration().size(), 1);
         QVERIFY(machine.configuration().contains(s1));
     }
+    // multiple signal transitions from same source
+    {
+        QStateMachine machine;
+        SignalEmitter emitter;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+        s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), s1);
+        QFinalState *s2 = new QFinalState(machine.rootState());
+        s0->addTransition(&emitter, SIGNAL(signalWithIntArg(int)), s2);
+        QFinalState *s3 = new QFinalState(machine.rootState());
+        s0->addTransition(&emitter, SIGNAL(signalWithStringArg(QString)), s3);
+
+        QSignalSpy startedSpy(&machine, SIGNAL(started()));
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+
+        machine.start();
+        QTRY_COMPARE(startedSpy.count(), 1);
+        emitter.emitSignalWithNoArg();
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s1));
+
+        machine.start();
+        QTRY_COMPARE(startedSpy.count(), 2);
+        emitter.emitSignalWithIntArg(123);
+        QTRY_COMPARE(finishedSpy.count(), 2);
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s2));
+
+        machine.start();
+        QTRY_COMPARE(startedSpy.count(), 3);
+        emitter.emitSignalWithStringArg("hello");
+        QTRY_COMPARE(finishedSpy.count(), 3);
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s3));
+    }
 }
 
 void tst_QStateMachine::eventTransitions()
 {
     QPushButton button;
-    {
+    for (int x = 0; x < 2; ++x) {
         QStateMachine machine;
         QState *s0 = new QState(machine.rootState());
         QFinalState *s1 = new QFinalState(machine.rootState());
 
-        QMouseEventTransition *trans = new QMouseEventTransition(&button, QEvent::MouseButtonPress, Qt::LeftButton);
+        QMouseEventTransition *trans;
+        if (x == 0) {
+            trans = new QMouseEventTransition(&button, QEvent::MouseButtonPress, Qt::LeftButton);
+            QCOMPARE(trans->targetState(), (QAbstractState*)0);
+            trans->setTargetState(s1);
+        } else {
+            trans = new QMouseEventTransition(&button, QEvent::MouseButtonPress,
+                                              Qt::LeftButton, QList<QAbstractState*>() << s1);
+        }
         QCOMPARE(trans->eventType(), QEvent::MouseButtonPress);
         QCOMPARE(trans->button(), Qt::LeftButton);
-        trans->setTargetState(s1);
+        QCOMPARE(trans->targetState(), (QAbstractState*)s1);
         s0->addTransition(trans);
 
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1778,25 +1940,53 @@ void tst_QStateMachine::eventTransitions()
         QCoreApplication::processEvents();
 
         QTest::mousePress(&button, Qt::LeftButton);
-        QCoreApplication::processEvents();
-
         QTRY_COMPARE(finishedSpy.count(), 1);
 
         QTest::mousePress(&button, Qt::LeftButton);
+
+        trans->setEventType(QEvent::MouseButtonRelease);
+        QCOMPARE(trans->eventType(), QEvent::MouseButtonRelease);
+        machine.start();
+        QCoreApplication::processEvents();
+        QTest::mouseRelease(&button, Qt::LeftButton);
+        QTRY_COMPARE(finishedSpy.count(), 2);
+
+        machine.start();
+        QCoreApplication::processEvents();
+        trans->setEventType(QEvent::MouseButtonPress);
+        QTest::mousePress(&button, Qt::LeftButton);
+        QTRY_COMPARE(finishedSpy.count(), 3);
+
+        QPushButton button2;
+        machine.start();
+        QCoreApplication::processEvents();
+        trans->setEventObject(&button2);
+        QTest::mousePress(&button2, Qt::LeftButton);
+        QTRY_COMPARE(finishedSpy.count(), 4);
     }
-    {
+    for (int x = 0; x < 3; ++x) {
         QStateMachine machine;
         QState *s0 = new QState(machine.rootState());
         QFinalState *s1 = new QFinalState(machine.rootState());
 
-        QEventTransition *trans = new QEventTransition();
-        QCOMPARE(trans->eventObject(), (QObject*)0);
-        QCOMPARE(trans->eventType(), QEvent::None);
-        trans->setEventObject(&button);
+        QEventTransition *trans;
+        if (x == 0) {
+            trans = new QEventTransition();
+            QCOMPARE(trans->eventObject(), (QObject*)0);
+            QCOMPARE(trans->eventType(), QEvent::None);
+            trans->setEventObject(&button);
+            trans->setEventType(QEvent::MouseButtonPress);
+            trans->setTargetState(s1);
+        } else if (x == 1) {
+            trans = new QEventTransition(&button, QEvent::MouseButtonPress);
+            trans->setTargetState(s1);
+        } else {
+            trans = new QEventTransition(&button, QEvent::MouseButtonPress,
+                                         QList<QAbstractState*>() << s1);
+        }
         QCOMPARE(trans->eventObject(), (QObject*)&button);
-        trans->setEventType(QEvent::MouseButtonPress);
         QCOMPARE(trans->eventType(), QEvent::MouseButtonPress);
-        trans->setTargetState(s1);
+        QCOMPARE(trans->targetState(), (QAbstractState*)s1);
         s0->addTransition(trans);
 
         QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
@@ -1929,57 +2119,123 @@ void tst_QStateMachine::eventTransitions()
         QCOMPARE(machine.configuration().size(), 1);
         QVERIFY(machine.configuration().contains(s1));
     }
+    // multiple event transitions from same source
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+        QFinalState *s2 = new QFinalState(machine.rootState());
+        QEventTransition *t0 = new QEventTransition(&button, QEvent::MouseButtonPress);
+        t0->setTargetState(s1);
+        s0->addTransition(t0);
+        QEventTransition *t1 = new QEventTransition(&button, QEvent::MouseButtonRelease);
+        t1->setTargetState(s2);
+        s0->addTransition(t1);
+
+        QSignalSpy startedSpy(&machine, SIGNAL(started()));
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+
+        machine.start();
+        QTRY_COMPARE(startedSpy.count(), 1);
+        QTest::mousePress(&button, Qt::LeftButton);
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s1));
+
+        machine.start();
+        QTRY_COMPARE(startedSpy.count(), 2);
+        QTest::mouseRelease(&button, Qt::LeftButton);
+        QTRY_COMPARE(finishedSpy.count(), 2);
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s2));
+    }
+    // custom event
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+
+        QEventTransition *trans = new QEventTransition(&button, QEvent::Type(QEvent::User+1));
+        trans->setTargetState(s1);
+        s0->addTransition(trans);
+
+        QSignalSpy startedSpy(&machine, SIGNAL(started()));
+        machine.setInitialState(s0);
+        machine.start();
+        QTest::ignoreMessage(QtWarningMsg, "QObject event transitions are not supported for custom types");
+        QTRY_COMPARE(startedSpy.count(), 1);
+    }
 }
 
 void tst_QStateMachine::historyStates()
 {
-    QStateMachine machine;
-    QState *root = machine.rootState();
-      QState *s0 = new QState(root);
-        QState *s00 = new QState(s0);
-        QState *s01 = new QState(s0);
-        QHistoryState *s0h = new QHistoryState(s0);
-      QState *s1 = new QState(root);
-      QFinalState *s2 = new QFinalState(root);
-
-    s00->addTransition(new StringTransition("a", s01));
-    s0->addTransition(new StringTransition("b", s1));
-    s1->addTransition(new StringTransition("c", s0h));
-    s0->addTransition(new StringTransition("d", s2));
-
-    root->setInitialState(s0);
-    s0->setInitialState(s00);
+    for (int x = 0; x < 2; ++x) {
+        QStateMachine machine;
+        QState *root = machine.rootState();
+          QState *s0 = new QState(root);
+            QState *s00 = new QState(s0);
+            QState *s01 = new QState(s0);
+            QHistoryState *s0h;
+            if (x == 0) {
+                s0h = new QHistoryState(s0);
+                QCOMPARE(s0h->historyType(), QHistoryState::ShallowHistory);
+                s0h->setHistoryType(QHistoryState::DeepHistory);
+            } else {
+                s0h = new QHistoryState(QHistoryState::DeepHistory, s0);
+            }
+            QCOMPARE(s0h->historyType(), QHistoryState::DeepHistory);
+            s0h->setHistoryType(QHistoryState::ShallowHistory);
+            QCOMPARE(s0h->historyType(), QHistoryState::ShallowHistory);
+            QCOMPARE(s0h->defaultState(), (QAbstractState*)0);
+            s0h->setDefaultState(s00);
+            QCOMPARE(s0h->defaultState(), (QAbstractState*)s00);
+            char warning[256];
+            sprintf(warning, "QHistoryState::setDefaultState: state %p does not belong to this history state's group (%p)", s0, s0);
+            QTest::ignoreMessage(QtWarningMsg, warning);
+            s0h->setDefaultState(s0);
+          QState *s1 = new QState(root);
+          QFinalState *s2 = new QFinalState(root);
+
+        s00->addTransition(new StringTransition("a", s01));
+        s0->addTransition(new StringTransition("b", s1));
+        s1->addTransition(new StringTransition("c", s0h));
+        s0->addTransition(new StringTransition("d", s2));
+
+        root->setInitialState(s0);
+        s0->setInitialState(s00);
 
-    QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
-    machine.start();
-    QCoreApplication::processEvents();
-    QCOMPARE(machine.configuration().size(), 2);
-    QVERIFY(machine.configuration().contains(s0));
-    QVERIFY(machine.configuration().contains(s00));
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.start();
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 2);
+        QVERIFY(machine.configuration().contains(s0));
+        QVERIFY(machine.configuration().contains(s00));
 
-    machine.postEvent(new StringEvent("a"));
-    QCoreApplication::processEvents();
-    QCOMPARE(machine.configuration().size(), 2);
-    QVERIFY(machine.configuration().contains(s0));
-    QVERIFY(machine.configuration().contains(s01));
+        machine.postEvent(new StringEvent("a"));
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 2);
+        QVERIFY(machine.configuration().contains(s0));
+        QVERIFY(machine.configuration().contains(s01));
 
-    machine.postEvent(new StringEvent("b"));
-    QCoreApplication::processEvents();
-    QCOMPARE(machine.configuration().size(), 1);
-    QVERIFY(machine.configuration().contains(s1));
+        machine.postEvent(new StringEvent("b"));
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s1));
 
-    machine.postEvent(new StringEvent("c"));
-    QCoreApplication::processEvents();
-    QCOMPARE(machine.configuration().size(), 2);
-    QVERIFY(machine.configuration().contains(s0));
-    QVERIFY(machine.configuration().contains(s01));
+        machine.postEvent(new StringEvent("c"));
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 2);
+        QVERIFY(machine.configuration().contains(s0));
+        QVERIFY(machine.configuration().contains(s01));
 
-    machine.postEvent(new StringEvent("d"));
-    QCoreApplication::processEvents();
-    QCOMPARE(machine.configuration().size(), 1);
-    QVERIFY(machine.configuration().contains(s2));
+        machine.postEvent(new StringEvent("d"));
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s2));
 
-    QTRY_COMPARE(finishedSpy.count(), 1);
+        QTRY_COMPARE(finishedSpy.count(), 1);
+    }
 }
 
 void tst_QStateMachine::startAndStop()
@@ -2010,6 +2266,9 @@ void tst_QStateMachine::startAndStop()
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(s1));
 
+    QTest::ignoreMessage(QtWarningMsg, "QStateMachine::start(): already running");
+    machine.start();
+
     machine.stop();
     QTRY_COMPARE(machine.isRunning(), false);
     QTRY_COMPARE(stoppedSpy.count(), 1);
@@ -2018,6 +2277,11 @@ void tst_QStateMachine::startAndStop()
 
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(s1));
+
+    machine.start();
+    machine.stop();
+    QTRY_COMPARE(startedSpy.count(), 2);
+    QCOMPARE(stoppedSpy.count(), 2);
 }
 
 void tst_QStateMachine::targetStateWithNoParent()
@@ -2025,8 +2289,8 @@ void tst_QStateMachine::targetStateWithNoParent()
     QStateMachine machine;
     QState *s1 = new QState(machine.rootState());
     s1->setObjectName("s1");
-    QState *s2 = new QState();
-    s1->addTransition(s2);
+    QState s2;
+    s1->addTransition(&s2);
     machine.setInitialState(s1);
     QSignalSpy startedSpy(&machine, SIGNAL(started()));
     QSignalSpy stoppedSpy(&machine, SIGNAL(stopped()));
@@ -2058,7 +2322,7 @@ void tst_QStateMachine::defaultGlobalRestorePolicy()
 {
     QStateMachine machine;    
 
-    QObject *propertyHolder = new QObject();
+    QObject *propertyHolder = new QObject(&machine);
     propertyHolder->setProperty("a", 1);
     propertyHolder->setProperty("b", 2);
 
@@ -2147,7 +2411,7 @@ void tst_QStateMachine::globalRestorePolicySetToDoNotRestore()
     QStateMachine machine;
     machine.setGlobalRestorePolicy(QStateMachine::DoNotRestoreProperties);
 
-    QObject *propertyHolder = new QObject();
+    QObject *propertyHolder = new QObject(&machine);
     propertyHolder->setProperty("a", 1);
     propertyHolder->setProperty("b", 2);
 
@@ -2308,7 +2572,7 @@ void tst_QStateMachine::globalRestorePolicySetToRestore()
     QStateMachine machine;    
     machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
 
-    QObject *propertyHolder = new QObject();
+    QObject *propertyHolder = new QObject(&machine);
     propertyHolder->setProperty("a", 1);
     propertyHolder->setProperty("b", 2);
 
@@ -2428,7 +2692,7 @@ void tst_QStateMachine::simpleAnimation()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("fooBar", 1.0);
 
     QState *s1 = new QState(machine.rootState());
@@ -2471,7 +2735,7 @@ void tst_QStateMachine::twoAnimations()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
     object->setProperty("bar", 3.0);
 
@@ -2515,7 +2779,7 @@ void tst_QStateMachine::twoAnimatedTransitions()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
 
     QState *s1 = new QState(machine.rootState());
@@ -2559,7 +2823,7 @@ void tst_QStateMachine::playAnimationTwice()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
 
     QState *s1 = new QState(machine.rootState());
@@ -2602,7 +2866,7 @@ void tst_QStateMachine::nestedTargetStateForAnimation()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
     object->setProperty("bar", 3.0);
 
@@ -2659,7 +2923,7 @@ void tst_QStateMachine::animatedGlobalRestoreProperty()
     QStateMachine machine;
     machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
 
     SlotCalledCounter counter;
@@ -2705,7 +2969,7 @@ void tst_QStateMachine::specificTargetValueOfAnimation()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
 
     QState *s1 = new QState(machine.rootState());
@@ -2769,7 +3033,7 @@ void tst_QStateMachine::addDefaultAnimationWithUnusedAnimation()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
     object->setProperty("bar", 2.0);
 
@@ -2848,7 +3112,7 @@ void tst_QStateMachine::overrideDefaultAnimationWithSpecific()
 {
     QStateMachine machine;
 
-    QObject *object = new QObject();
+    QObject *object = new QObject(&machine);
     object->setProperty("foo", 1.0);
 
     SlotCalledCounter counter;
diff --git a/tests/auto/qtemporaryfile/tst_qtemporaryfile.cpp b/tests/auto/qtemporaryfile/tst_qtemporaryfile.cpp
index 2daa0f6..26f5f40 100644
--- a/tests/auto/qtemporaryfile/tst_qtemporaryfile.cpp
+++ b/tests/auto/qtemporaryfile/tst_qtemporaryfile.cpp
@@ -77,6 +77,7 @@ private slots:
     void fileTemplate_data();
     void getSetCheck();
     void fileName();
+    void fileNameIsEmpty();
     void autoRemove();
     void write();
     void openCloseOpenClose();
@@ -86,6 +87,8 @@ private slots:
     void stressTest();
     void rename();
     void renameFdLeak();
+    void reOpenThroughQFile();
+
 public:
 };
 
@@ -189,6 +192,27 @@ void tst_QTemporaryFile::fileName()
     QCOMPARE(absoluteFilePath, absoluteTempPath);
 }
 
+void tst_QTemporaryFile::fileNameIsEmpty()
+{
+    QString filename;
+    {
+        QTemporaryFile file;
+        QVERIFY(file.fileName().isEmpty());
+
+        QVERIFY(file.open());
+        QVERIFY(!file.fileName().isEmpty());
+
+        filename = file.fileName();
+        QVERIFY(QFile::exists(filename));
+
+        file.close();
+        QVERIFY(!file.isOpen());
+        QVERIFY(QFile::exists(filename));
+        QVERIFY(!file.fileName().isEmpty());
+    }
+    QVERIFY(!QFile::exists(filename));
+}
+
 void tst_QTemporaryFile::autoRemove()
 {
 	// Test auto remove
@@ -358,6 +382,7 @@ void tst_QTemporaryFile::rename()
         QVERIFY(file.rename("temporary-file.txt"));
         QVERIFY(!dir.exists(tempname));
         QVERIFY(dir.exists("temporary-file.txt"));
+        QCOMPARE(file.fileName(), QString("temporary-file.txt"));
     }
 
     QVERIFY(!dir.exists(tempname));
@@ -401,5 +426,18 @@ void tst_QTemporaryFile::renameFdLeak()
 #endif
 }
 
+void tst_QTemporaryFile::reOpenThroughQFile()
+{
+    QByteArray data("abcdefghij");
+
+    QTemporaryFile file;
+    QVERIFY(((QFile &)file).open(QIODevice::WriteOnly));
+    QCOMPARE(file.write(data), (qint64)data.size());
+
+    file.close();
+    QVERIFY(file.open());
+    QCOMPARE(file.readAll(), data);
+}
+
 QTEST_MAIN(tst_QTemporaryFile)
 #include "tst_qtemporaryfile.moc"
diff --git a/tests/auto/qtreeview/tst_qtreeview.cpp b/tests/auto/qtreeview/tst_qtreeview.cpp
index c4517d6..2ef76a4 100644
--- a/tests/auto/qtreeview/tst_qtreeview.cpp
+++ b/tests/auto/qtreeview/tst_qtreeview.cpp
@@ -227,6 +227,7 @@ private slots:
     void task246536_scrollbarsNotWorking();
     void task250683_wrongSectionSize();
     void task239271_addRowsWithFirstColumnHidden();
+    void task254234_proxySort();
 };
 
 class QtTestModel: public QAbstractItemModel
@@ -2498,7 +2499,6 @@ void tst_QTreeView::sortByColumn()
     QCOMPARE(view.header()->sortIndicatorSection(), 0);
     QCOMPARE(view.model()->data(view.model()->index(0,0)).toString(), QString::fromLatin1("a"));
     QCOMPARE(view.model()->data(view.model()->index(1,0)).toString(), QString::fromLatin1("b"));
-    
 }
 
 /*
@@ -3346,7 +3346,6 @@ void tst_QTreeView::task246536_scrollbarsNotWorking()
     QVERIFY(o.count > 0);
 }
 
-
 void tst_QTreeView::task250683_wrongSectionSize()
 {
     QDirModel model;
@@ -3400,5 +3399,32 @@ void tst_QTreeView::task239271_addRowsWithFirstColumnHidden()
     QVERIFY(delegate.paintedIndexes.contains(sub11.index()));
 }
 
+void tst_QTreeView::task254234_proxySort()
+{
+    //based on tst_QTreeView::sortByColumn
+    // it used not to work when setting the source of a proxy after enabling sorting
+    QTreeView view;
+    QStandardItemModel model(4,2);
+    model.setItem(0,0,new QStandardItem("b"));
+    model.setItem(1,0,new QStandardItem("d"));
+    model.setItem(2,0,new QStandardItem("c"));
+    model.setItem(3,0,new QStandardItem("a"));
+    model.setItem(0,1,new QStandardItem("e"));
+    model.setItem(1,1,new QStandardItem("g"));
+    model.setItem(2,1,new QStandardItem("h"));
+    model.setItem(3,1,new QStandardItem("f"));
+
+    view.sortByColumn(1);
+    view.setSortingEnabled(true);
+
+    QSortFilterProxyModel proxy;
+    proxy.setDynamicSortFilter(true);
+    view.setModel(&proxy);
+    proxy.setSourceModel(&model);
+    QCOMPARE(view.header()->sortIndicatorSection(), 1);
+    QCOMPARE(view.model()->data(view.model()->index(0,1)).toString(), QString::fromLatin1("h"));
+    QCOMPARE(view.model()->data(view.model()->index(1,1)).toString(), QString::fromLatin1("g"));
+}
+
 QTEST_MAIN(tst_QTreeView)
 #include "tst_qtreeview.moc"
diff --git a/tests/benchmarks/qgraphicsitem/qgraphicsitem.pro b/tests/benchmarks/qgraphicsitem/qgraphicsitem.pro
new file mode 100644
index 0000000..c8fc07b
--- /dev/null
+++ b/tests/benchmarks/qgraphicsitem/qgraphicsitem.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+TEMPLATE = app
+TARGET = tst_qgraphicsitem
+
+SOURCES += tst_qgraphicsitem.cpp
+
diff --git a/tests/benchmarks/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/benchmarks/qgraphicsitem/tst_qgraphicsitem.cpp
new file mode 100644
index 0000000..68e3aa1
--- /dev/null
+++ b/tests/benchmarks/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -0,0 +1,170 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+****************************************************************************/
+
+#include <qtest.h>
+#include <QGraphicsItem>
+#include <QGraphicsScene>
+#include <QGraphicsView>
+
+//TESTED_FILES=
+
+class tst_QGraphicsItem : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QGraphicsItem();
+    virtual ~tst_QGraphicsItem();
+
+public slots:
+    void init();
+    void cleanup();
+
+private slots:
+    void setPos_data();
+    void setPos();
+    void setTransform_data();
+    void setTransform();
+    void rotate();
+    void scale();
+    void shear();
+    void translate();
+    void setRotation();
+    void setRotationXYZ();
+};
+
+tst_QGraphicsItem::tst_QGraphicsItem()
+{
+}
+
+tst_QGraphicsItem::~tst_QGraphicsItem()
+{
+}
+
+void tst_QGraphicsItem::init()
+{
+}
+
+void tst_QGraphicsItem::cleanup()
+{
+}
+
+void tst_QGraphicsItem::setPos_data()
+{
+    QTest::addColumn<QPointF>("pos");
+
+    QTest::newRow("0, 0") << QPointF(0, 0);
+    QTest::newRow("10, 10") << QPointF(10, 10);
+    QTest::newRow("-10, -10") << QPointF(-10, -10);
+}
+
+void tst_QGraphicsItem::setPos()
+{
+    QFETCH(QPointF, pos);
+
+    QGraphicsScene scene;
+    QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        rect->setPos(10, 10);
+        rect->transform(); // prevent lazy optimizing
+    }
+}
+
+void tst_QGraphicsItem::setTransform_data()
+{
+    QTest::addColumn<QTransform>("transform");
+
+    QTest::newRow("id") << QTransform();
+    QTest::newRow("rotate 45z") << QTransform().rotate(45);
+    QTest::newRow("scale 2x2") << QTransform().scale(2, 2);
+    QTest::newRow("translate 100, 100") << QTransform().translate(100, 100);
+    QTest::newRow("rotate 45x 45y 45z") << QTransform().rotate(45, Qt::XAxis)
+        .rotate(45, Qt::YAxis).rotate(45, Qt::ZAxis);
+}
+
+void tst_QGraphicsItem::setTransform()
+{
+    QFETCH(QTransform, transform);
+
+    QGraphicsScene scene;
+    QGraphicsRectItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        item->setTransform(transform);
+        item->transform(); // prevent lazy optimizing
+    }
+}
+
+void tst_QGraphicsItem::rotate()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        item->rotate(45);
+        item->transform(); // prevent lazy optimizing
+    }
+}
+
+void tst_QGraphicsItem::scale()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        item->scale(2, 2);
+        item->transform(); // prevent lazy optimizing
+    }
+}
+
+void tst_QGraphicsItem::shear()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        item->shear(1.5, 1.5);
+        item->transform(); // prevent lazy optimizing
+    }
+}
+
+void tst_QGraphicsItem::translate()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        item->translate(100, 100);
+        item->transform(); // prevent lazy optimizing
+    }
+}
+
+void tst_QGraphicsItem::setRotation()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        item->setXRotation(45);
+        item->transform(); // prevent lazy optimizing
+    }
+}
+
+void tst_QGraphicsItem::setRotationXYZ()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item = scene.addRect(QRectF(0, 0, 100, 100));
+
+    QBENCHMARK {
+        item->setRotation(45, 45, 45);
+        item->transform(); // prevent lazy optimizing
+    }
+}
+
+QTEST_MAIN(tst_QGraphicsItem)
+#include "tst_qgraphicsitem.moc"
diff --git a/tests/benchmarks/qgraphicsview/images/wine-big.jpeg b/tests/benchmarks/qgraphicsview/images/wine-big.jpeg
new file mode 100644
index 0000000..9900a50
--- /dev/null
+++ b/tests/benchmarks/qgraphicsview/images/wine-big.jpeg
diff --git a/tests/benchmarks/qgraphicsview/qgraphicsview.qrc b/tests/benchmarks/qgraphicsview/qgraphicsview.qrc
index 5e80029..3681648 100644
--- a/tests/benchmarks/qgraphicsview/qgraphicsview.qrc
+++ b/tests/benchmarks/qgraphicsview/qgraphicsview.qrc
@@ -2,6 +2,7 @@
 <qresource>
     <file>images/designer.png</file>
     <file>images/wine.jpeg</file>
+    <file>images/wine-big.jpeg</file>
     <file>random.data</file>
 </qresource>
 </RCC>
diff --git a/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp b/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp
index a06e033..570f744 100644
--- a/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp
+++ b/tests/benchmarks/qgraphicsview/tst_qgraphicsview.cpp
@@ -124,6 +124,8 @@ private slots:
     void textRiver();
     void moveItemCache_data();
     void moveItemCache();
+    void paintItemCache_data();
+    void paintItemCache();
 };
 
 tst_QGraphicsView::tst_QGraphicsView()
@@ -796,5 +798,105 @@ void tst_QGraphicsView::moveItemCache()
     }
 }
 
+class UpdatedPixmapCacheItem : public QGraphicsPixmapItem
+{
+public:
+    UpdatedPixmapCacheItem(bool partial, QGraphicsItem *parent = 0)
+        : QGraphicsPixmapItem(parent), partial(partial)
+    {
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
+    {
+        QGraphicsPixmapItem::paint(painter,option,widget);
+    }
+protected:
+    void advance(int i)
+    {
+        if (partial)
+            update(QRectF(boundingRect().center().x(), boundingRect().center().x(), 30, 30));
+        else
+            update();
+    }
+
+private:
+    bool partial;
+};
+
+void tst_QGraphicsView::paintItemCache_data()
+{
+    QTest::addColumn<bool>("updatePartial");
+    QTest::addColumn<bool>("rotation");
+    QTest::addColumn<int>("cacheMode");
+    QTest::newRow("Partial Update : ItemCoordinate Cache") << true << false << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Partial Update : DeviceCoordinate Cache") << true << false << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Partial Update : No Cache") << true << false << (int)QGraphicsItem::NoCache;
+    QTest::newRow("Full Update : ItemCoordinate Cache") << false << false << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Full Update : DeviceCoordinate Cache") << false << false << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Full Update : No Cache") << false << false << (int)QGraphicsItem::NoCache;
+    QTest::newRow("Partial Update : ItemCoordinate Cache item rotated") << true << true << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Partial Update : DeviceCoordinate Cache item rotated") << true << true << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Partial Update : No Cache item rotated") << true << true << (int)QGraphicsItem::NoCache;
+    QTest::newRow("Full Update : ItemCoordinate Cache item rotated") << false  << true << (int)QGraphicsItem::ItemCoordinateCache;
+    QTest::newRow("Full Update : DeviceCoordinate Cache item rotated") << false << true << (int)QGraphicsItem::DeviceCoordinateCache;
+    QTest::newRow("Full Update : No Cache item rotated") << false << true <<(int)QGraphicsItem::NoCache;
+}
+
+void tst_QGraphicsView::paintItemCache()
+{
+    QFETCH(bool, updatePartial);
+    QFETCH(bool, rotation);
+    QFETCH(int, cacheMode);
+
+    QGraphicsScene scene(0, 0, 300, 300);
+
+    CountPaintEventView view(&scene);
+    view.resize(600, 600);
+    view.setFrameStyle(0);
+    view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    view.show();
+
+    QPixmap pix(":/images/wine.jpeg");
+    QVERIFY(!pix.isNull());
+
+    QList<QGraphicsItem *> items;
+    QFile file(":/random.data");
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QDataStream str(&file);
+    UpdatedPixmapCacheItem *item = new UpdatedPixmapCacheItem(updatePartial);
+    item->setPixmap(pix);
+    item->setCacheMode((QGraphicsItem::CacheMode)cacheMode);
+    if (rotation)
+        item->setTransform(QTransform().rotate(45));
+    item->setPos(-100, -100);
+    scene.addItem(item);
+
+    QPixmap pix2(":/images/wine-big.jpeg");
+    item = new UpdatedPixmapCacheItem(updatePartial);
+    item->setPixmap(pix2);
+    item->setCacheMode((QGraphicsItem::CacheMode)cacheMode);
+    if (rotation)
+        item->setTransform(QTransform().rotate(45));
+    item->setPos(0, 0);
+    scene.addItem(item);
+
+    view.count = 0;
+
+    QBENCHMARK {
+#ifdef CALLGRIND_DEBUG
+        CALLGRIND_START_INSTRUMENTATION
+#endif
+        for (int i = 0; i < 50; ++i) {
+            scene.advance();
+            while (view.count < (i+1))
+                qApp->processEvents();
+        }
+#ifdef CALLGRIND_DEBUG
+        CALLGRIND_STOP_INSTRUMENTATION
+#endif
+    }
+}
+
 QTEST_MAIN(tst_QGraphicsView)
 #include "tst_qgraphicsview.moc"
diff --git a/tests/benchmarks/qstring/main.cpp b/tests/benchmarks/qstring/main.cpp
new file mode 100644
index 0000000..cbbf0a1
--- /dev/null
+++ b/tests/benchmarks/qstring/main.cpp
@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QStringList>
+#include <qtest.h>
+
+class tst_QString: public QObject
+{
+    Q_OBJECT
+private slots:
+    void equals() const;
+    void equals_data() const;
+};
+
+void tst_QString::equals() const
+{
+    QFETCH(QString, a);
+    QFETCH(QString, b);
+
+    QBENCHMARK {
+        a == b;
+    }
+}
+
+void tst_QString::equals_data() const
+{
+    static const struct {
+        ushort data[80];
+        int dummy;              // just to ensure 4-byte alignment
+    } data = {
+        {
+            64, 64, 64, 64,  64, 64, 64, 64,
+            64, 64, 64, 64,  64, 64, 64, 64, // 16
+            64, 64, 64, 64,  64, 64, 64, 64,
+            64, 64, 64, 64,  64, 64, 64, 64, // 32
+            64, 64, 64, 64,  64, 64, 64, 64,
+            64, 64, 64, 64,  64, 64, 64, 64, // 48
+            64, 64, 64, 64,  64, 64, 64, 64,
+            64, 64, 64, 64,  64, 64, 64, 64, // 64
+            64, 64, 64, 64,  96, 96, 96, 96,
+            64, 64, 96, 96,  96, 96, 96, 96  // 80
+        }, 0
+    };
+    const QChar *ptr = reinterpret_cast<const QChar *>(data.data);
+
+    QTest::addColumn<QString>("a");
+    QTest::addColumn<QString>("b");
+    QString base = QString::fromRawData(ptr, 64);
+
+    QTest::newRow("different-length") << base << QString::fromRawData(ptr, 4);
+    QTest::newRow("same-string") << base << base;
+    QTest::newRow("same-data") << base << QString::fromRawData(ptr, 64);
+
+    // try to avoid crossing a cache line (that is, at ptr[64])
+    QTest::newRow("aligned-aligned-4n")
+            << QString::fromRawData(ptr, 60) << QString::fromRawData(ptr + 2, 60);
+    QTest::newRow("aligned-unaligned-4n")
+            << QString::fromRawData(ptr, 60) << QString::fromRawData(ptr + 1, 60);
+    QTest::newRow("unaligned-unaligned-4n")
+            << QString::fromRawData(ptr + 1, 60) << QString::fromRawData(ptr + 3, 60);
+
+    QTest::newRow("aligned-aligned-4n+1")
+            << QString::fromRawData(ptr, 61) << QString::fromRawData(ptr + 2, 61);
+    QTest::newRow("aligned-unaligned-4n+1")
+            << QString::fromRawData(ptr, 61) << QString::fromRawData(ptr + 1, 61);
+    QTest::newRow("unaligned-unaligned-4n+1")
+            << QString::fromRawData(ptr + 1, 61) << QString::fromRawData(ptr + 3, 61);
+
+    QTest::newRow("aligned-aligned-4n-1")
+            << QString::fromRawData(ptr, 59) << QString::fromRawData(ptr + 2, 59);
+    QTest::newRow("aligned-unaligned-4n-1")
+            << QString::fromRawData(ptr, 59) << QString::fromRawData(ptr + 1, 59);
+    QTest::newRow("unaligned-unaligned-4n-1")
+            << QString::fromRawData(ptr + 1, 59) << QString::fromRawData(ptr + 3, 59);
+
+    QTest::newRow("aligned-aligned-2n")
+            << QString::fromRawData(ptr, 58) << QString::fromRawData(ptr + 2, 58);
+    QTest::newRow("aligned-unaligned-2n")
+            << QString::fromRawData(ptr, 58) << QString::fromRawData(ptr + 1, 58);
+    QTest::newRow("unaligned-unaligned-2n")
+            << QString::fromRawData(ptr + 1, 58) << QString::fromRawData(ptr + 3, 58);
+}
+
+QTEST_MAIN(tst_QString)
+
+#include "main.moc"
diff --git a/tests/benchmarks/qstring/qstring.pro b/tests/benchmarks/qstring/qstring.pro
new file mode 100644
index 0000000..74423e7
--- /dev/null
+++ b/tests/benchmarks/qstring/qstring.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+TARGET = tst_qstring
+QT -= gui
+SOURCES += main.cpp