Merge branch 'master' of git://gitorious.org/qt/qt

33 files changed, 9614 insertions, 11 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 714e19d..27e3c74 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 \
            collections \
            compile \
            compilerwarnings \
@@ -75,6 +76,7 @@ SUBDIRS += bic \
            qaction \
            qactiongroup \
            qalgorithms \
+           qanimationgroup \
            qapplication \
            qatomicint \
            qatomicpointer \
@@ -214,6 +216,7 @@ SUBDIRS += bic \
            qpainter \
            qpainterpath \
            qpalette \
+           qparallelanimationgroup \
            qpathclipper \
            qpen \
            qpicture \
@@ -229,6 +232,7 @@ SUBDIRS += bic \
            qprocess \
            qprogressbar \
            qprogressdialog \
+           qpropertyanimation \
            qpushbutton \
            qqueue \
            qradiobutton \
@@ -256,6 +260,7 @@ SUBDIRS += bic \
            qscrollarea \
            qsemaphore \
 	   qsharedpointer \
+           qsequentialanimationgroup \
            qset \
            qsettings \
            qshortcut \
@@ -289,6 +294,8 @@ SUBDIRS += bic \
            qstackedwidget \
            qstandarditem \
            qstandarditemmodel \
+           qstate \
+           qstatemachine \
            qstatusbar \
            qstl \
            qstring \
@@ -342,6 +349,7 @@ SUBDIRS += bic \
            qtranslator \
            qtransform \
            qtransformedscreen \
+           qtransition \
            qtreeview \
            qtreewidget \
            qtreewidgetitemiterator \
diff --git a/tests/auto/qanimationgroup/qanimationgroup.pro b/tests/auto/qanimationgroup/qanimationgroup.pro
new file mode 100644
index 0000000..97d33dd
--- /dev/null
+++ b/tests/auto/qanimationgroup/qanimationgroup.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT = core gui
+SOURCES  += tst_qanimationgroup.cpp
+
+
diff --git a/tests/auto/qanimationgroup/tst_qanimationgroup.cpp b/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
new file mode 100644
index 0000000..2952a39
--- /dev/null
+++ b/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
@@ -0,0 +1,413 @@
+/****************************************************************************
+**
+** 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 <QtCore/qanimationgroup.h>
+#include <QtCore/qsequentialanimationgroup.h>
+#include <QtCore/qparallelanimationgroup.h>
+
+//TESTED_CLASS=QAnimationGroup
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(QAbstractAnimation::State)
+
+class tst_QAnimationGroup : public QObject
+{
+  Q_OBJECT
+public:
+    tst_QAnimationGroup();
+    virtual ~tst_QAnimationGroup();
+
+public Q_SLOTS:
+    void init();
+    void cleanup();
+
+private slots:
+    void construction();
+    void emptyGroup();
+    void setCurrentTime();
+    void statesAndSignals();
+    void setParentAutoAdd();
+    void beginNestedGroup();
+    void addChildTwice();
+    void loopWithoutStartValue();
+};
+
+tst_QAnimationGroup::tst_QAnimationGroup()
+{
+}
+
+tst_QAnimationGroup::~tst_QAnimationGroup()
+{
+}
+
+void tst_QAnimationGroup::init()
+{
+    qRegisterMetaType<QAbstractAnimation::State>("QAbstractAnimation::State");
+}
+
+void tst_QAnimationGroup::cleanup()
+{
+}
+
+void tst_QAnimationGroup::construction()
+{
+    QSequentialAnimationGroup animationgroup;
+}
+
+class AnimationObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int value READ value WRITE setValue)
+public:
+    AnimationObject(int startValue = 0)
+        : v(startValue)
+    { }
+
+    int value() const { return v; }
+    void setValue(int value) { v = value; }
+
+    int v;
+};
+
+class TestAnimation : public QVariantAnimation
+{
+    Q_OBJECT
+public:
+    virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
+    virtual void updateState(QAbstractAnimation::State oldState,
+                             QAbstractAnimation::State newState)
+    {
+        Q_UNUSED(oldState)
+        Q_UNUSED(newState)
+    };
+};
+
+class UncontrolledAnimation : public QPropertyAnimation
+{
+    Q_OBJECT
+public:
+    UncontrolledAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0)
+        : QPropertyAnimation(target, propertyName, parent), id(0)
+    {
+        setDuration(250);
+    }
+
+    int duration() const { return -1; /* not time driven */ }
+
+protected:
+    void timerEvent(QTimerEvent *event)
+    {
+        if (event->timerId() == id)
+            stop();
+    }
+
+    void updateRunning(bool running)
+    {
+        if (running) {
+            id = startTimer(500);
+        } else {
+            killTimer(id);
+            id = 0;
+        }
+    }
+
+private:
+    int id;
+};
+
+void tst_QAnimationGroup::emptyGroup()
+{
+    QSequentialAnimationGroup group;
+    QSignalSpy groupStateChangedSpy(&group, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    group.start();
+
+    QCOMPARE(groupStateChangedSpy.count(), 2);
+
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(1).at(1)),
+             QAnimationGroup::Stopped);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+
+    QTest::ignoreMessage(QtWarningMsg, "QAbstractAnimation::pause: Cannot pause a stopped animation");
+    group.pause();
+
+    QCOMPARE(groupStateChangedSpy.count(), 2);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+
+    group.start();
+
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(2).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(3).at(1)),
+             QAnimationGroup::Stopped);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+
+    group.stop();
+
+    QCOMPARE(groupStateChangedSpy.count(), 4);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QAnimationGroup::setCurrentTime()
+{
+    AnimationObject s_o1;
+    AnimationObject s_o2;
+    AnimationObject s_o3;
+    AnimationObject p_o1;
+    AnimationObject p_o2;
+    AnimationObject p_o3;
+    AnimationObject t_o1;
+    AnimationObject t_o2;
+
+    // sequence operating on same object/property
+    QSequentialAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    a2_s_o1->setLoopCount(3);
+    sequence->addAnimation(a1_s_o1);
+    sequence->addAnimation(a2_s_o1);
+    sequence->addAnimation(a3_s_o1);
+
+    // sequence operating on different object/properties
+    QAnimationGroup *sequence2 = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
+    QVariantAnimation *a1_s_o3 = new QPropertyAnimation(&s_o3, "value");
+    sequence2->addAnimation(a1_s_o2);
+    sequence2->addAnimation(a1_s_o3);
+
+    // parallel operating on different object/properties
+    QAnimationGroup *parallel = new QParallelAnimationGroup();
+    QVariantAnimation *a1_p_o1 = new QPropertyAnimation(&p_o1, "value");
+    QVariantAnimation *a1_p_o2 = new QPropertyAnimation(&p_o2, "value");
+    QVariantAnimation *a1_p_o3 = new QPropertyAnimation(&p_o3, "value");
+    a1_p_o2->setLoopCount(3);
+    parallel->addAnimation(a1_p_o1);
+    parallel->addAnimation(a1_p_o2);
+    parallel->addAnimation(a1_p_o3);
+
+    UncontrolledAnimation *notTimeDriven = new UncontrolledAnimation(&t_o1, "value");
+    QCOMPARE(notTimeDriven->totalDuration(), -1);
+
+    QVariantAnimation *loopsForever = new QPropertyAnimation(&t_o2, "value");
+    loopsForever->setLoopCount(-1);
+    QCOMPARE(loopsForever->totalDuration(), -1);
+
+    QParallelAnimationGroup group;
+    group.addAnimation(sequence);
+    group.addAnimation(sequence2);
+    group.addAnimation(parallel);
+    group.addAnimation(notTimeDriven);
+    group.addAnimation(loopsForever);
+
+    // Current time = 1
+    group.setCurrentTime(1);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(parallel->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_p_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_p_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_p_o3->state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
+
+    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 1);
+    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 1);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a1_p_o1->currentTime(), 1);
+    QCOMPARE(a1_p_o2->currentTime(), 1);
+    QCOMPARE(a1_p_o3->currentTime(), 1);
+    QCOMPARE(notTimeDriven->currentTime(), 1);
+    QCOMPARE(loopsForever->currentTime(), 1);
+
+    // Current time = 250
+    group.setCurrentTime(250);
+    QCOMPARE(group.currentTime(), 250);
+    QCOMPARE(sequence->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a1_p_o1->currentTime(), 250);
+    QCOMPARE(a1_p_o2->currentTime(), 0);
+    QCOMPARE(a1_p_o2->currentLoop(), 1);
+    QCOMPARE(a1_p_o3->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 250);
+    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(loopsForever->currentLoop(), 1);
+    QCOMPARE(sequence->currentAnimation(), a2_s_o1);
+
+    // Current time = 251
+    group.setCurrentTime(251);
+    QCOMPARE(group.currentTime(), 251);
+    QCOMPARE(sequence->currentTime(), 251);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoop(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(sequence2->currentTime(), 251);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 1);
+    QCOMPARE(a1_p_o1->currentTime(), 250);
+    QCOMPARE(a1_p_o2->currentTime(), 1);
+    QCOMPARE(a1_p_o2->currentLoop(), 1);
+    QCOMPARE(a1_p_o3->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 251);
+    QCOMPARE(loopsForever->currentTime(), 1);
+    QCOMPARE(sequence->currentAnimation(), a2_s_o1);
+}
+
+void tst_QAnimationGroup::statesAndSignals()
+{
+}
+
+void tst_QAnimationGroup::setParentAutoAdd()
+{
+    QParallelAnimationGroup group;
+    QVariantAnimation *animation = new QPropertyAnimation(&group);
+    QCOMPARE(animation->group(), &group);
+}
+
+void tst_QAnimationGroup::beginNestedGroup()
+{
+    QAnimationGroup *subGroup;
+    QAnimationGroup *parent = new QParallelAnimationGroup();
+
+    for (int i = 0; i < 10; ++i) {
+        if (i & 1)
+            subGroup = new QParallelAnimationGroup(parent);
+        else
+            subGroup = new QSequentialAnimationGroup(parent);
+
+        QCOMPARE(parent->animationCount(), 1);
+        QAnimationGroup *child = static_cast<QAnimationGroup *>(parent->animationAt(0));
+
+        QCOMPARE(child->parent(), static_cast<QObject *>(parent));
+        if (i & 1)
+            QVERIFY(qobject_cast<QParallelAnimationGroup *> (child));
+        else
+            QVERIFY(qobject_cast<QSequentialAnimationGroup *> (child));
+
+        parent = child;
+    }
+}
+
+void tst_QAnimationGroup::addChildTwice()
+{
+    QPropertyAnimation *subGroup;
+    QPropertyAnimation *subGroup2;
+    QAnimationGroup *parent = new QSequentialAnimationGroup();
+
+    subGroup = new QPropertyAnimation();
+    subGroup->setParent(parent);
+    parent->addAnimation(subGroup);
+    QCOMPARE(parent->animationCount(), 1);
+
+    parent->clearAnimations();
+
+    QCOMPARE(parent->animationCount(), 0);
+
+    // adding the same item twice to a group will remove the item from its current position
+    // and append it to the end
+    subGroup = new QPropertyAnimation(parent);
+    subGroup2 = new QPropertyAnimation(parent);
+
+    QCOMPARE(parent->animationCount(), 2);
+    QCOMPARE(parent->animationAt(0), subGroup);
+    QCOMPARE(parent->animationAt(1), subGroup2);
+
+    parent->addAnimation(subGroup);
+
+    QCOMPARE(parent->animationCount(), 2);
+    QCOMPARE(parent->animationAt(0), subGroup2);
+    QCOMPARE(parent->animationAt(1), subGroup);
+
+    delete parent;
+}
+
+void tst_QAnimationGroup::loopWithoutStartValue()
+{
+    QAnimationGroup *parent = new QSequentialAnimationGroup();
+    QObject o;
+    o.setProperty("ole", 0);
+    QCOMPARE(o.property("ole").toInt(), 0);
+
+    QPropertyAnimation anim1(&o, "ole");
+    anim1.setEndValue(-50);
+    anim1.setDuration(100);
+
+    QPropertyAnimation anim2(&o, "ole");
+    anim2.setEndValue(50);
+    anim2.setDuration(100);
+
+    parent->addAnimation(&anim1);
+    parent->addAnimation(&anim2);
+
+    parent->setLoopCount(-1);
+    parent->start();
+
+    QVERIFY(anim1.startValue().isNull());
+    QCOMPARE(anim1.currentValue().toInt(), 0);
+    QCOMPARE(parent->currentLoop(), 0);
+
+    parent->setCurrentTime(200);
+    QCOMPARE(parent->currentLoop(), 1);
+    QCOMPARE(anim1.currentValue().toInt(), 50);
+    parent->stop();
+}
+
+QTEST_MAIN(tst_QAnimationGroup)
+#include "tst_qanimationgroup.moc"
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/qeasingcurve.pro b/tests/auto/qeasingcurve/qeasingcurve.pro
new file mode 100644
index 0000000..2b66081
--- /dev/null
+++ b/tests/auto/qeasingcurve/qeasingcurve.pro
@@ -0,0 +1,3 @@
+load(qttest_p4)
+QT = core
+SOURCES  += tst_qeasingcurve.cpp
diff --git a/tests/auto/qeasingcurve/tst_qeasingcurve.cpp b/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
new file mode 100644
index 0000000..b25cdc7
--- /dev/null
+++ b/tests/auto/qeasingcurve/tst_qeasingcurve.cpp
@@ -0,0 +1,493 @@
+/****************************************************************************
+**
+** 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>
+
+#if QT_VERSION < 0x040200
+QTEST_NOOP_MAIN
+#else
+
+#include <qeasingcurve.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QEasingCurve : public QObject {
+  Q_OBJECT
+
+public:
+    tst_QEasingCurve();
+    virtual ~tst_QEasingCurve();
+
+public Q_SLOTS:
+    void init();
+    void cleanup();
+
+private slots:
+    void type();
+    void propertyDefaults();
+    void valueForProgress_data();
+    void valueForProgress();
+    void setCustomType();
+    void operators();
+
+protected:
+};
+
+tst_QEasingCurve::tst_QEasingCurve()
+{
+}
+
+tst_QEasingCurve::~tst_QEasingCurve()
+{
+}
+
+void tst_QEasingCurve::init()
+{
+}
+
+void tst_QEasingCurve::cleanup()
+{
+}
+#include <qdebug.h>
+
+void tst_QEasingCurve::type()
+{
+    {
+    QEasingCurve curve(QEasingCurve::Linear);
+    QCOMPARE(curve.period(), 0.3);
+    QCOMPARE(curve.amplitude(), 1.0);
+
+    curve.setPeriod(5);
+    curve.setAmplitude(3);
+    QCOMPARE(curve.period(), 5.0);
+    QCOMPARE(curve.amplitude(), 3.0);
+
+    curve.setType(QEasingCurve::InElastic);
+    QCOMPARE(curve.period(), 5.0);
+    QCOMPARE(curve.amplitude(), 3.0);
+    }
+
+    {
+    QEasingCurve curve(QEasingCurve::InElastic);
+    QCOMPARE(curve.period(), 0.3);
+    QCOMPARE(curve.amplitude(), 1.0);
+    curve.setAmplitude(2);
+    QCOMPARE(curve.type(), QEasingCurve::InElastic);
+    curve.setType(QEasingCurve::Linear);
+    }
+
+    {
+    // check bounaries
+    QEasingCurve curve(QEasingCurve::InCubic);
+    QTest::ignoreMessage(QtWarningMsg, "QEasingCurve: Invalid curve type 9999");
+    curve.setType((QEasingCurve::Type)9999);
+    QCOMPARE(curve.type(), QEasingCurve::InCubic);
+    QTest::ignoreMessage(QtWarningMsg, "QEasingCurve: Invalid curve type -9999");
+    curve.setType((QEasingCurve::Type)-9999);
+    QCOMPARE(curve.type(), QEasingCurve::InCubic);
+    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QEasingCurve: Invalid curve type %1")
+                        .arg(QEasingCurve::NCurveTypes).toLatin1().constData());
+    curve.setType(QEasingCurve::NCurveTypes);
+    QCOMPARE(curve.type(), QEasingCurve::InCubic);
+    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QEasingCurve: Invalid curve type %1")
+                        .arg(QEasingCurve::Custom).toLatin1().constData());
+    curve.setType(QEasingCurve::Custom);
+    QCOMPARE(curve.type(), QEasingCurve::InCubic);
+    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QEasingCurve: Invalid curve type %1")
+                        .arg(-1).toLatin1().constData());
+    curve.setType((QEasingCurve::Type)-1);
+    QCOMPARE(curve.type(), QEasingCurve::InCubic);
+    curve.setType(QEasingCurve::Linear);
+    QCOMPARE(curve.type(), QEasingCurve::Linear);
+    curve.setType(QEasingCurve::CosineCurve);
+    QCOMPARE(curve.type(), QEasingCurve::CosineCurve);
+    }
+}
+
+void tst_QEasingCurve::propertyDefaults()
+{
+    {
+    // checks if the defaults are correct, but also demonstrates a weakness with the API.
+    QEasingCurve curve(QEasingCurve::InElastic);
+    QCOMPARE(curve.period(), 0.3);
+    QCOMPARE(curve.amplitude(), 1.0);
+    QCOMPARE(curve.overshoot(), qreal(1.70158f));
+    curve.setType(QEasingCurve::InBounce);
+    QCOMPARE(curve.period(), 0.3);
+    QCOMPARE(curve.amplitude(), 1.0);
+    QCOMPARE(curve.overshoot(), qreal(1.70158f));
+    curve.setType(QEasingCurve::Linear);
+    QCOMPARE(curve.period(), 0.3);
+    QCOMPARE(curve.amplitude(), 1.0);
+    QCOMPARE(curve.overshoot(), qreal(1.70158f));
+    curve.setType(QEasingCurve::InElastic);
+    QCOMPARE(curve.period(), 0.3);
+    QCOMPARE(curve.amplitude(), 1.0);
+    QCOMPARE(curve.overshoot(), qreal(1.70158f));
+    curve.setPeriod(0.4);
+    curve.setAmplitude(0.6);
+    curve.setOvershoot(1.0);
+    curve.setType(QEasingCurve::Linear);
+    QCOMPARE(curve.period(), 0.4);
+    QCOMPARE(curve.amplitude(), 0.6);
+    QCOMPARE(curve.overshoot(), 1.0);
+    curve.setType(QEasingCurve::InElastic);
+    QCOMPARE(curve.period(), 0.4);
+    QCOMPARE(curve.amplitude(), 0.6);
+    QCOMPARE(curve.overshoot(), 1.0);
+    }
+}
+
+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<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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (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)
+         << (RealList() << 0.5 << 0.7939 << 0.9755 << 0.9755 << 0.7939 << 0.5 << 0.2061 << 0.02447 << 0.02447 << 0.2061 << 0.5);
+
+}
+
+
+void tst_QEasingCurve::valueForProgress()
+{
+#if 0
+    // used to generate data tables...
+    QFile out;
+    out.open(stdout, QIODevice::WriteOnly);
+    for (int c = QEasingCurve::Linear; c < QEasingCurve::NCurveTypes - 1; ++c) {
+        QEasingCurve curve((QEasingCurve::Type)c);
+        QMetaObject mo = QEasingCurve::staticMetaObject;
+        QString strCurve = QLatin1String(mo.enumerator(mo.indexOfEnumerator("Type")).key(c));
+        QString strInputs;
+        QString strOutputs;
+
+        for (int t = 0; t <= 100; t+= 10) {
+            qreal ease = curve.valueForProgress(t/qreal(100));
+            strInputs += QString::fromAscii(" << %1").arg(t);
+            strOutputs += " << " + QString().setNum(ease, 'g', 4);
+        }
+        QString str = QString::fromAscii("    QTest::newRow(\"%1\") << int(QEasingCurve::%2)\n"
+                                                "         << (IntList() %3)\n"
+                                                "         << (RealList()%4);\n\n")
+                                      .arg(strCurve)
+                                      .arg(strCurve)
+                                      .arg(strInputs)
+                                      .arg(strOutputs);
+        out.write(str.toLatin1().constData());
+    }
+    out.close();
+    exit(1);
+#else
+    QFETCH(int, type);
+    QFETCH(IntList, at);
+    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));
+        // 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
+}
+
+static qreal discreteEase(qreal progress)
+{
+    return qFloor(progress * 10) / qreal(10.0);
+}
+
+void tst_QEasingCurve::setCustomType()
+{
+    QEasingCurve curve;
+    curve.setCustomType(&discreteEase);
+    QCOMPARE(curve.type(), QEasingCurve::Custom);
+    QCOMPARE(curve.valueForProgress(0.0), 0.0);
+    QCOMPARE(curve.valueForProgress(0.05), 0.0);
+    QCOMPARE(curve.valueForProgress(0.10), 0.1);
+    QCOMPARE(curve.valueForProgress(0.15), 0.1);
+    QCOMPARE(curve.valueForProgress(0.20), 0.2);
+    QCOMPARE(curve.valueForProgress(0.25), 0.2);
+    QCOMPARE(curve.valueForProgress(0.30), 0.3);
+    QCOMPARE(curve.valueForProgress(0.35), 0.3);
+    QCOMPARE(curve.valueForProgress(0.999999), 0.9);
+
+    curve.setType(QEasingCurve::Linear);
+    QCOMPARE(curve.type(), QEasingCurve::Linear);
+    QCOMPARE(curve.valueForProgress(0.0), 0.0);
+    QCOMPARE(curve.valueForProgress(0.1), 0.1);
+    QCOMPARE(curve.valueForProgress(0.5), 0.5);
+    QCOMPARE(curve.valueForProgress(0.99), 0.99);
+}
+
+void tst_QEasingCurve::operators()
+{
+    // operator=
+    QEasingCurve curve;
+    QEasingCurve curve2;
+    curve.setCustomType(&discreteEase);
+    curve2 = curve;
+    QCOMPARE(curve2.type(), QEasingCurve::Custom);
+    QCOMPARE(curve2.valueForProgress(0.0), 0.0);
+    QCOMPARE(curve2.valueForProgress(0.05), 0.0);
+    QCOMPARE(curve2.valueForProgress(0.15), 0.1);
+    QCOMPARE(curve2.valueForProgress(0.25), 0.2);
+    QCOMPARE(curve2.valueForProgress(0.35), 0.3);
+    QCOMPARE(curve2.valueForProgress(0.999999), 0.9);
+
+    // operator==
+    curve.setType(QEasingCurve::InBack);
+    curve2 = curve;
+    curve2.setOvershoot(qreal(1.70158f));
+    QCOMPARE(curve.overshoot(), curve2.overshoot());
+    QVERIFY(curve2 == curve);
+
+    curve.setOvershoot(3.0);
+    QVERIFY(curve2 != curve);
+    curve2.setOvershoot(3.0);
+    QVERIFY(curve2 == curve);
+
+    curve2.setType(QEasingCurve::Linear);
+    QCOMPARE(curve.overshoot(), curve2.overshoot());
+    QVERIFY(curve2 != curve);
+    curve2.setType(QEasingCurve::InBack);
+    QCOMPARE(curve.overshoot(), curve2.overshoot());
+    QVERIFY(curve2 == curve);
+}
+
+
+QTEST_MAIN(tst_QEasingCurve)
+#include "tst_qeasingcurve.moc"
+
+#endif //QT_VERSION
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/testdata/bundle-spaces/some-file b/tests/auto/qmake/testdata/bundle-spaces/some-file
index e69de29..9975dba 100644
--- a/tests/auto/qmake/testdata/bundle-spaces/some-file
+++ b/tests/auto/qmake/testdata/bundle-spaces/some-file
@@ -0,0 +1,6 @@
+all:
+	C:\git\qt-kinetic-animations\bin\qmake qdir.pro  -o Makefile -spec win32-msvc2008
+	nmake -f Makefile
+first: all
+qmake:
+	C:\git\qt-kinetic-animations\bin\qmake qdir.pro  -o Makefile -spec win32-msvc2008
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/qparallelanimationgroup/qparallelanimationgroup.pro b/tests/auto/qparallelanimationgroup/qparallelanimationgroup.pro
new file mode 100644
index 0000000..f2cacd3
--- /dev/null
+++ b/tests/auto/qparallelanimationgroup/qparallelanimationgroup.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT = core gui
+SOURCES  += tst_qparallelanimationgroup.cpp
+
+
diff --git a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
new file mode 100644
index 0000000..f2ab57a
--- /dev/null
+++ b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
@@ -0,0 +1,834 @@
+/****************************************************************************
+**
+** 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 <QtCore/qparallelanimationgroup.h>
+
+//TESTED_CLASS=QParallelAnimationGroup
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(QAbstractAnimation::State)
+
+class tst_QParallelAnimationGroup : public QObject
+{
+  Q_OBJECT
+public:
+    tst_QParallelAnimationGroup();
+    virtual ~tst_QParallelAnimationGroup();
+
+public Q_SLOTS:
+    void init();
+    void cleanup();
+
+private slots:
+    void construction();
+    void setCurrentTime();
+    void clearGroup();
+    void propagateGroupUpdateToChildren();
+    void updateChildrenWithRunningGroup();
+    void deleteChildrenWithRunningGroup();
+    void startChildrenWithStoppedGroup();
+    void stopGroupWithRunningChild();
+    void startGroupWithRunningChild();
+    void zeroDurationAnimation();
+    void stopUncontrolledAnimations();
+    void loopCount_data();
+    void loopCount();
+    void autoAdd();
+};
+
+tst_QParallelAnimationGroup::tst_QParallelAnimationGroup()
+{
+}
+
+tst_QParallelAnimationGroup::~tst_QParallelAnimationGroup()
+{
+}
+
+void tst_QParallelAnimationGroup::init()
+{
+    qRegisterMetaType<QAbstractAnimation::State>("QAbstractAnimation::State");
+}
+
+void tst_QParallelAnimationGroup::cleanup()
+{
+}
+
+void tst_QParallelAnimationGroup::construction()
+{
+    QParallelAnimationGroup animationgroup;
+}
+
+class AnimationObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int value READ value WRITE setValue)
+public:
+    AnimationObject(int startValue = 0)
+        : v(startValue)
+    { }
+
+    int value() const { return v; }
+    void setValue(int value) { v = value; }
+
+    int v;
+};
+
+class TestAnimation : public QVariantAnimation
+{
+    Q_OBJECT
+public:
+    virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
+    virtual void updateState(QAbstractAnimation::State oldState,
+                             QAbstractAnimation::State newState)
+    {
+        Q_UNUSED(oldState)
+        Q_UNUSED(newState)
+    };
+};
+
+class TestAnimation2 : public QVariantAnimation
+{
+    Q_OBJECT
+public:
+    TestAnimation2(QAbstractAnimation *animation) : QVariantAnimation(animation) {}
+    TestAnimation2(int duration, QAbstractAnimation *animation) : QVariantAnimation(animation), m_duration(duration) {}
+
+    virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
+    virtual void updateState(QAbstractAnimation::State oldState,
+                             QAbstractAnimation::State newState)
+    {
+        Q_UNUSED(oldState)
+        Q_UNUSED(newState)
+    };
+
+    virtual int duration() const {
+        return m_duration;
+    }
+private:
+    int m_duration;
+};
+
+class UncontrolledAnimation : public QPropertyAnimation
+{
+    Q_OBJECT
+public:
+    UncontrolledAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0)
+        : QPropertyAnimation(target, propertyName, parent), id(0)
+    {
+        setDuration(250);
+    }
+
+    int duration() const { return -1; /* not time driven */ }
+
+protected:
+    void timerEvent(QTimerEvent *event)
+    {
+        if (event->timerId() == id)
+            stop();
+    }
+
+    void updateRunning(bool running)
+    {
+        if (running) {
+            id = startTimer(500);
+        } else {
+            killTimer(id);
+            id = 0;
+        }
+    }
+
+private:
+    int id;
+};
+
+void tst_QParallelAnimationGroup::setCurrentTime()
+{
+    AnimationObject p_o1;
+    AnimationObject p_o2;
+    AnimationObject p_o3;
+    AnimationObject t_o1;
+    AnimationObject t_o2;
+
+    // parallel operating on different object/properties
+    QAnimationGroup *parallel = new QParallelAnimationGroup();
+    QVariantAnimation *a1_p_o1 = new QPropertyAnimation(&p_o1, "value");
+    QVariantAnimation *a1_p_o2 = new QPropertyAnimation(&p_o2, "value");
+    QVariantAnimation *a1_p_o3 = new QPropertyAnimation(&p_o3, "value");
+    a1_p_o2->setLoopCount(3);
+    parallel->addAnimation(a1_p_o1);
+    parallel->addAnimation(a1_p_o2);
+    parallel->addAnimation(a1_p_o3);
+
+    UncontrolledAnimation *notTimeDriven = new UncontrolledAnimation(&t_o1, "value");
+    QCOMPARE(notTimeDriven->totalDuration(), -1);
+
+    QVariantAnimation *loopsForever = new QPropertyAnimation(&t_o2, "value");
+    loopsForever->setLoopCount(-1);
+    QCOMPARE(loopsForever->totalDuration(), -1);
+
+    QParallelAnimationGroup group;
+    group.addAnimation(parallel);
+    group.addAnimation(notTimeDriven);
+    group.addAnimation(loopsForever);
+
+    // Current time = 1
+    group.setCurrentTime(1);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(parallel->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_p_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_p_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_p_o3->state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
+
+    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(a1_p_o1->currentTime(), 1);
+    QCOMPARE(a1_p_o2->currentTime(), 1);
+    QCOMPARE(a1_p_o3->currentTime(), 1);
+    QCOMPARE(notTimeDriven->currentTime(), 1);
+    QCOMPARE(loopsForever->currentTime(), 1);
+
+    // Current time = 250
+    group.setCurrentTime(250);
+    QCOMPARE(group.currentTime(), 250);
+    QCOMPARE(a1_p_o1->currentTime(), 250);
+    QCOMPARE(a1_p_o2->currentTime(), 0);
+    QCOMPARE(a1_p_o2->currentLoop(), 1);
+    QCOMPARE(a1_p_o3->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 250);
+    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(loopsForever->currentLoop(), 1);
+
+    // Current time = 251
+    group.setCurrentTime(251);
+    QCOMPARE(group.currentTime(), 251);
+    QCOMPARE(a1_p_o1->currentTime(), 250);
+    QCOMPARE(a1_p_o2->currentTime(), 1);
+    QCOMPARE(a1_p_o2->currentLoop(), 1);
+    QCOMPARE(a1_p_o3->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 251);
+    QCOMPARE(loopsForever->currentTime(), 1);
+}
+
+void tst_QParallelAnimationGroup::clearGroup()
+{
+    QParallelAnimationGroup group;
+
+    for (int i = 0; i < 10; ++i) {
+        new QParallelAnimationGroup(&group);
+    }
+
+    QCOMPARE(group.animationCount(), 10);
+
+    int count = group.animationCount();
+    QPointer<QAbstractAnimation> *children = new QPointer<QAbstractAnimation>[count];
+    for (int i = 0; i < count; ++i) {
+        QVERIFY(group.animationAt(i) != 0);
+        children[i] = group.animationAt(i);
+    }
+
+    group.clearAnimations();
+    QCOMPARE(group.animationCount(), 0);
+    QCOMPARE(group.currentTime(), 0);
+    for (int i = 0; i < count; ++i)
+        QCOMPARE(children[i], QPointer<QAbstractAnimation>());
+
+    delete[] children;
+}
+
+void tst_QParallelAnimationGroup::propagateGroupUpdateToChildren()
+{
+    // this test verifies if group state changes are updating its children correctly
+    QParallelAnimationGroup group;
+
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation anim1(&o, "ole");
+    anim1.setEndValue(43);
+    anim1.setDuration(100);
+    QVERIFY(!anim1.currentValue().isValid());
+    QCOMPARE(anim1.currentValue().toInt(), 0);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(200);
+
+    QVERIFY(anim2.currentValue().isValid());
+    QCOMPARE(anim2.currentValue().toInt(), 0);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+
+    group.start();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Running);
+
+    group.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(anim1.state(), QAnimationGroup::Paused);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+
+    group.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QParallelAnimationGroup::updateChildrenWithRunningGroup()
+{
+    // assert that its possible to modify a child's state directly while their group is running
+    QParallelAnimationGroup group;
+
+    TestAnimation anim;
+    anim.setStartValue(0);
+    anim.setEndValue(100);
+    anim.setDuration(200);
+
+    QSignalSpy groupStateChangedSpy(&group, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy childStateChangedSpy(&anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    QCOMPARE(groupStateChangedSpy.count(), 0);
+    QCOMPARE(childStateChangedSpy.count(), 0);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim);
+
+    group.start();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim.state(), QAnimationGroup::Running);
+
+    QCOMPARE(groupStateChangedSpy.count(), 1);
+    QCOMPARE(childStateChangedSpy.count(), 1);
+
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+
+    // starting directly a running child will not have any effect
+    anim.start();
+
+    QCOMPARE(groupStateChangedSpy.count(), 1);
+    QCOMPARE(childStateChangedSpy.count(), 1);
+
+    anim.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim.state(), QAnimationGroup::Paused);
+
+    // in the animation stops directly, the group will still be running
+    anim.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QParallelAnimationGroup::deleteChildrenWithRunningGroup()
+{
+    // test if children can be activated when their group is stopped
+    QParallelAnimationGroup group;
+
+    QVariantAnimation *anim1 = new TestAnimation;
+    anim1->setStartValue(0);
+    anim1->setEndValue(100);
+    anim1->setDuration(200);
+    group.addAnimation(anim1);
+
+    QCOMPARE(group.duration(), anim1->duration());
+
+    group.start();
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1->state(), QAnimationGroup::Running);
+
+    QTest::qWait(50);
+    QVERIFY(group.currentTime() > 0);
+
+    delete anim1;
+    QVERIFY(group.animationCount() == 0);
+    QCOMPARE(group.duration(), 0);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(group.currentTime(), 0); //that's the invariant
+}
+
+void tst_QParallelAnimationGroup::startChildrenWithStoppedGroup()
+{
+    // test if children can be activated when their group is stopped
+    QParallelAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(200);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(200);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+
+    group.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    anim1.start();
+    anim2.start();
+    anim2.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+}
+
+void tst_QParallelAnimationGroup::stopGroupWithRunningChild()
+{
+    // children that started independently will not be affected by a group stop
+    QParallelAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(200);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(200);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+
+    anim1.start();
+    anim2.start();
+    anim2.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+
+    group.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+
+    anim1.stop();
+    anim2.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QParallelAnimationGroup::startGroupWithRunningChild()
+{
+    // as the group has precedence over its children, starting a group will restart all the children
+    QParallelAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(200);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(200);
+
+    QSignalSpy stateChangedSpy1(&anim1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy stateChangedSpy2(&anim2, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    QCOMPARE(stateChangedSpy1.count(), 0);
+    QCOMPARE(stateChangedSpy2.count(), 0);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+
+    anim1.start();
+    anim2.start();
+    anim2.pause();
+
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(1).at(1)),
+             QAnimationGroup::Paused);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+
+    group.start();
+
+    QCOMPARE(stateChangedSpy1.count(), 3);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).at(1)),
+             QAnimationGroup::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(2).at(1)),
+             QAnimationGroup::Running);
+
+    QCOMPARE(stateChangedSpy2.count(), 4);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).at(1)),
+             QAnimationGroup::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).at(1)),
+             QAnimationGroup::Running);
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Running);
+}
+
+void tst_QParallelAnimationGroup::zeroDurationAnimation()
+{
+    QParallelAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(0);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(100);
+
+    QSignalSpy stateChangedSpy1(&anim1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy finishedSpy1(&anim1, SIGNAL(finished()));
+
+    QSignalSpy stateChangedSpy2(&anim2, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy finishedSpy2(&anim2, SIGNAL(finished()));
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+    QCOMPARE(stateChangedSpy1.count(), 0);
+    group.start();
+    QCOMPARE(stateChangedSpy1.count(), 2);
+    QCOMPARE(finishedSpy1.count(), 1);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).at(1)),
+             QAnimationGroup::Stopped);
+
+    QCOMPARE(stateChangedSpy2.count(), 1);
+    QCOMPARE(finishedSpy2.count(), 0);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+             QAnimationGroup::Running);
+
+
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Running);
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+
+
+    group.stop();
+    group.setLoopCount(4);
+    stateChangedSpy1.clear();
+    stateChangedSpy2.clear();
+
+    group.start();
+    QCOMPARE(stateChangedSpy1.count(), 2);
+    QCOMPARE(stateChangedSpy2.count(), 1);
+    group.setCurrentTime(50);
+    QCOMPARE(stateChangedSpy1.count(), 2);
+    QCOMPARE(stateChangedSpy2.count(), 1);
+    group.setCurrentTime(150);
+    QCOMPARE(stateChangedSpy1.count(), 4);
+    QCOMPARE(stateChangedSpy2.count(), 3);
+    group.setCurrentTime(50);
+    QCOMPARE(stateChangedSpy1.count(), 6);
+    QCOMPARE(stateChangedSpy2.count(), 5);
+
+}
+
+void tst_QParallelAnimationGroup::stopUncontrolledAnimations()
+{
+    QParallelAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(0);
+
+    AnimationObject o1;
+    UncontrolledAnimation notTimeDriven(&o1, "value");
+    QCOMPARE(notTimeDriven.totalDuration(), -1);
+
+    TestAnimation loopsForever;
+    loopsForever.setStartValue(0);
+    loopsForever.setEndValue(100);
+    loopsForever.setDuration(100);
+    loopsForever.setLoopCount(-1);
+
+    QSignalSpy stateChangedSpy(&anim1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&notTimeDriven);
+    group.addAnimation(&loopsForever);
+
+    group.start();
+
+    QCOMPARE(stateChangedSpy.count(), 2);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).at(1)),
+             QAnimationGroup::Stopped);
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
+    QCOMPARE(loopsForever.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+
+    notTimeDriven.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever.state(), QAnimationGroup::Running);
+
+    loopsForever.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever.state(), QAnimationGroup::Stopped);
+}
+
+struct AnimState {
+    AnimState(int time = -1) : time(time), state(-1) {}
+    AnimState(int time, int state) : time(time), state(state) {}
+    int time;
+    int state;
+};
+
+#define Running QAbstractAnimation::Running
+#define Stopped QAbstractAnimation::Stopped
+
+Q_DECLARE_METATYPE(AnimState)
+void tst_QParallelAnimationGroup::loopCount_data()
+{
+    QTest::addColumn<bool>("directionBackward");
+    QTest::addColumn<int>("setLoopCount");
+    QTest::addColumn<int>("initialGroupTime");
+    QTest::addColumn<int>("currentGroupTime");
+    QTest::addColumn<AnimState>("expected1");
+    QTest::addColumn<AnimState>("expected2");
+    QTest::addColumn<AnimState>("expected3");
+
+    //                                                                                  D U R A T I O N
+    //                                                              100                           60*2                           0
+    // direction = Forward
+    QTest::newRow("50")  << false << 3 << 0 <<  50 << AnimState( 50, Running) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("100") << false << 3 << 0 << 100 << AnimState(100         ) << AnimState( 40, Running) << AnimState(  0, Stopped);
+    QTest::newRow("110") << false << 3 << 0 << 110 << AnimState(100, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("120") << false << 3 << 0 << 120 << AnimState(  0, Running) << AnimState(  0, Running) << AnimState(  0, Stopped);
+
+    QTest::newRow("170") << false << 3 << 0 << 170 << AnimState( 50, Running) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("220") << false << 3 << 0 << 220 << AnimState(100         ) << AnimState( 40, Running) << AnimState(  0, Stopped);
+    QTest::newRow("230") << false << 3 << 0 << 230 << AnimState(100, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("240") << false << 3 << 0 << 240 << AnimState(  0, Running) << AnimState(  0, Running) << AnimState(  0, Stopped);
+
+    QTest::newRow("290") << false << 3 << 0 << 290 << AnimState( 50, Running) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("340") << false << 3 << 0 << 340 << AnimState(100         ) << AnimState( 40, Running) << AnimState(  0, Stopped);
+    QTest::newRow("350") << false << 3 << 0 << 350 << AnimState(100, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("360") << false << 3 << 0 << 360 << AnimState(100, Stopped) << AnimState( 60         ) << AnimState(  0, Stopped);
+
+    QTest::newRow("410") << false << 3 << 0 << 410 << AnimState(100, Stopped) << AnimState( 60, Stopped) << AnimState(  0, Stopped);
+    QTest::newRow("460") << false << 3 << 0 << 460 << AnimState(100, Stopped) << AnimState( 60, Stopped) << AnimState(  0, Stopped);
+    QTest::newRow("470") << false << 3 << 0 << 470 << AnimState(100, Stopped) << AnimState( 60, Stopped) << AnimState(  0, Stopped);
+    QTest::newRow("480") << false << 3 << 0 << 480 << AnimState(100, Stopped) << AnimState( 60, Stopped) << AnimState(  0, Stopped);
+
+    // direction = Forward, rewind
+    QTest::newRow("120-110") << false << 3 << 120 << 110 << AnimState(   0, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("120-50")  << false << 3 << 120 <<  50 << AnimState(  50, Running) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("120-0")   << false << 3 << 120 <<  0  << AnimState(   0, Running) << AnimState(  0, Running) << AnimState(  0, Stopped);
+    QTest::newRow("300-110") << false << 3 << 300 << 110 << AnimState(   0, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("300-50")  << false << 3 << 300 <<  50 << AnimState(  50, Running) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("300-0")   << false << 3 << 300 <<  0  << AnimState(   0, Running) << AnimState(  0, Running) << AnimState(  0, Stopped);
+    QTest::newRow("115-105") << false << 3 << 115 << 105 << AnimState(  42, Stopped) << AnimState( 45, Running) << AnimState(  0, Stopped);
+
+    // direction = Backward
+    QTest::newRow("b120-120") << true << 3 << 120 << 120 << AnimState( 42, Stopped) << AnimState( 60, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b120-110") << true << 3 << 120 << 110 << AnimState( 42, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b120-100") << true << 3 << 120 << 100 << AnimState(100, Running) << AnimState( 40, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b120-50")  << true << 3 << 120 <<  50 << AnimState( 50, Running) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b120-0")   << true << 3 << 120 <<   0 << AnimState(  0, Stopped) << AnimState(  0, Stopped) << AnimState(  0, Stopped);
+    QTest::newRow("b360-170") << true << 3 << 360 << 170 << AnimState( 50, Running) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b360-220") << true << 3 << 360 << 220 << AnimState(100, Running) << AnimState( 40, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b360-210") << true << 3 << 360 << 210 << AnimState( 90, Running) << AnimState( 30, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b360-120") << true << 3 << 360 << 120 << AnimState(  0, Stopped) << AnimState( 60, Running) << AnimState(  0, Stopped);
+
+    // rewind, direction = Backward
+    QTest::newRow("b50-110")  << true << 3 <<  50 << 110 << AnimState(100, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b50-120")  << true << 3 <<  50 << 120 << AnimState(100, Stopped) << AnimState( 60, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b50-140")  << true << 3 <<  50 << 140 << AnimState( 20, Running) << AnimState( 20, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b50-240")  << true << 3 <<  50 << 240 << AnimState(100, Stopped) << AnimState( 60, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b50-260")  << true << 3 <<  50 << 260 << AnimState( 20, Running) << AnimState( 20, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b50-350")  << true << 3 <<  50 << 350 << AnimState(100, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+
+    // infinite looping
+    QTest::newRow("inf1220")  << false << -1 <<  0 << 1220 << AnimState( 20, Running) << AnimState( 20, Running) << AnimState(  0, Stopped);
+    QTest::newRow("inf1310")  << false << -1 <<  0 << 1310 << AnimState( 100, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+    // infinite looping, direction = Backward (will only loop once)
+    QTest::newRow("b.inf120-120") << true  << -1 << 120 << 120 << AnimState( 42, Stopped) << AnimState( 60, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b.inf120-20")  << true  << -1 << 120 <<  20 << AnimState( 20, Running) << AnimState( 20, Running) << AnimState(  0, Stopped);
+    QTest::newRow("b.inf120-110") << true  << -1 << 120 << 110 << AnimState( 42, Stopped) << AnimState( 50, Running) << AnimState(  0, Stopped);
+
+
+}
+
+void tst_QParallelAnimationGroup::loopCount()
+{
+    QFETCH(bool, directionBackward);
+    QFETCH(int, setLoopCount);
+    QFETCH(int, initialGroupTime);
+    QFETCH(int, currentGroupTime);
+    QFETCH(AnimState, expected1);
+    QFETCH(AnimState, expected2);
+    QFETCH(AnimState, expected3);
+
+    QParallelAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(100);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(60);  //total 120
+    anim2.setLoopCount(2);
+
+    TestAnimation anim3;
+    anim3.setStartValue(0);
+    anim3.setEndValue(100);
+    anim3.setDuration(0);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+    group.addAnimation(&anim3);
+
+    group.setLoopCount(setLoopCount);
+    if (initialGroupTime >= 0)
+        group.setCurrentTime(initialGroupTime);
+    if (directionBackward)
+        group.setDirection(QAbstractAnimation::Backward);
+
+    group.start();
+    if (initialGroupTime >= 0)
+        group.setCurrentTime(initialGroupTime);
+
+    anim1.setCurrentTime(42);   // 42 is "untouched"
+    anim2.setCurrentTime(42);
+
+    group.setCurrentTime(currentGroupTime);
+
+    QCOMPARE(anim1.currentTime(), expected1.time);
+    QCOMPARE(anim2.currentTime(), expected2.time);
+    QCOMPARE(anim3.currentTime(), expected3.time);
+
+    if (expected1.state >=0)
+        QCOMPARE(int(anim1.state()), expected1.state);
+    if (expected2.state >=0)
+        QCOMPARE(int(anim2.state()), expected2.state);
+    if (expected3.state >=0)
+        QCOMPARE(int(anim3.state()), expected3.state);
+
+}
+
+void tst_QParallelAnimationGroup::autoAdd()
+{
+    QParallelAnimationGroup group;
+    QCOMPARE(group.duration(), 0);
+    TestAnimation2 *test = new TestAnimation2(250, &group);      // 0, duration = 250;
+    QCOMPARE(test->group(), &group);
+    QCOMPARE(test->duration(), 250);
+    QCOMPARE(group.duration(), 250);
+
+    test = new TestAnimation2(750, &group);     // 1
+    QCOMPARE(test->group(), &group);
+    QCOMPARE(group.duration(), 750);
+    test = new TestAnimation2(500, &group);     // 2
+    QCOMPARE(test->group(), &group);
+    QCOMPARE(group.duration(), 750);
+
+    delete group.animationAt(1);    // remove the one with duration = 750
+    QCOMPARE(group.duration(), 500);
+
+    delete group.animationAt(1);    // remove the one with duration = 500
+    QCOMPARE(group.duration(), 250);
+
+    test = static_cast<TestAnimation2*>(group.animationAt(0));
+    test->setParent(0);    // remove the last one (with duration = 250)
+    QCOMPARE(test->group(), static_cast<QAnimationGroup*>(0));
+    QCOMPARE(group.duration(), 0);
+}
+
+QTEST_MAIN(tst_QParallelAnimationGroup)
+#include "tst_qparallelanimationgroup.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/qpropertyanimation.pro b/tests/auto/qpropertyanimation/qpropertyanimation.pro
new file mode 100644
index 0000000..6d6ddbf
--- /dev/null
+++ b/tests/auto/qpropertyanimation/qpropertyanimation.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT = core gui
+SOURCES  += tst_qpropertyanimation.cpp
+
+
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
new file mode 100644
index 0000000..0aeac91
--- /dev/null
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -0,0 +1,958 @@
+/****************************************************************************
+**
+** 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 <QtCore/qpropertyanimation.h>
+#include <QtCore/qvariantanimation.h>
+#include <QtGui/qwidget.h>
+
+//TESTED_CLASS=QPropertyAnimation
+//TESTED_FILES=
+
+class UncontrolledAnimation : public QPropertyAnimation
+{
+    Q_OBJECT
+public:
+    int duration() const { return -1; /* not time driven */ }
+
+protected:
+    void updateCurrentTime(int msecs)
+    {
+        QPropertyAnimation::updateCurrentTime(msecs);
+        if (msecs >= QPropertyAnimation::duration())
+            stop();
+    }
+};
+
+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
+public:
+    tst_QPropertyAnimation();
+    virtual ~tst_QPropertyAnimation();
+
+public Q_SLOTS:
+    void init();
+    void cleanup();
+
+private slots:
+    void construction();
+    void setCurrentTime_data();
+    void setCurrentTime();
+    void statesAndSignals_data();
+    void statesAndSignals();
+    void deletion1();
+    void deletion2();
+    void deletion3();
+    void duration0();
+    void noStartValue();
+    void noStartValueWithLoop();
+    void startWhenAnotherIsRunning();
+    void easingcurve_data();
+    void easingcurve();
+    void startWithoutStartValue();
+    void playForwardBackward();
+    void interpolated();
+    void setStartEndValues_data();
+    void setStartEndValues();
+    void zeroDurationStart();
+    void operationsInStates_data();
+    void operationsInStates();
+    void oneKeyValue();
+    void updateOnSetKeyValues();
+};
+
+tst_QPropertyAnimation::tst_QPropertyAnimation()
+{
+}
+
+tst_QPropertyAnimation::~tst_QPropertyAnimation()
+{
+}
+
+void tst_QPropertyAnimation::init()
+{
+    qRegisterMetaType<QAbstractAnimation::State>("QAbstractAnimation::State");
+    qRegisterMetaType<QAbstractAnimation::DeletionPolicy>("QAbstractAnimation::DeletionPolicy");
+}
+
+void tst_QPropertyAnimation::cleanup()
+{
+}
+
+class AnimationObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int value READ value WRITE setValue)
+    Q_PROPERTY(qreal realValue READ realValue WRITE setRealValue)
+public:
+    AnimationObject(int startValue = 0)
+        : v(startValue)
+    { }
+
+    int value() const { return v; }
+    void setValue(int value) { v = value; }
+
+    qreal realValue() const { return rv; }
+    void setRealValue(qreal value) { rv = value; }
+
+    int v;
+    qreal rv;
+};
+
+
+void tst_QPropertyAnimation::construction()
+{
+    QPropertyAnimation panimation;
+}
+
+void tst_QPropertyAnimation::setCurrentTime_data()
+{
+    QTest::addColumn<int>("duration");
+    QTest::addColumn<int>("loopCount");
+    QTest::addColumn<int>("currentTime");
+    QTest::addColumn<int>("testCurrentTime");
+    QTest::addColumn<int>("testCurrentLoop");
+
+    QTest::newRow("-1") << -1 << 1 << 0 << 0 << 0;
+    QTest::newRow("0")  <<  0 << 1 << 0 << 0 << 0;
+    QTest::newRow("1")  <<  0 << 1 << 1 << 0 << 0;
+    QTest::newRow("2")  <<  0 << 2 << 1 << 0 << 0;
+    QTest::newRow("3")  <<  1 << 1 << 0 << 0 << 0;
+    QTest::newRow("4")  <<  1 << 1 << 1 << 1 << 0;
+    QTest::newRow("5")  <<  1 << 2 << 1 << 0 << 1;
+    QTest::newRow("6")  <<  1 << 2 << 2 << 1 << 1;
+    QTest::newRow("7")  <<  1 << 2 << 3 << 1 << 1;
+    QTest::newRow("8")  <<  1 << 3 << 2 << 0 << 2;
+    QTest::newRow("9")  <<  1 << 3 << 3 << 1 << 2;
+    QTest::newRow("a") <<  10 << 1 << 0 << 0 << 0;
+    QTest::newRow("b") <<  10 << 1 << 1 << 1 << 0;
+    QTest::newRow("c") <<  10 << 1 << 10 << 10 << 0;
+    QTest::newRow("d") <<  10 << 2 << 10 << 0 << 1;
+    QTest::newRow("e") <<  10 << 2 << 11 << 1 << 1;
+    QTest::newRow("f") <<  10 << 2 << 20 << 10 << 1;
+    QTest::newRow("g") <<  10 << 2 << 21 << 10 << 1;
+    QTest::newRow("negloop 0") <<  10 << -1 << 0 << 0 << 0;
+    QTest::newRow("negloop 1") <<  10 << -1 << 10 << 0 << 1;
+    QTest::newRow("negloop 2") <<  10 << -1 << 15 << 5 << 1;
+    QTest::newRow("negloop 3") <<  10 << -1 << 20 << 0 << 2;
+    QTest::newRow("negloop 4") <<  10 << -1 << 30 << 0 << 3;
+}
+
+void tst_QPropertyAnimation::setCurrentTime()
+{
+    QFETCH(int, duration);
+    QFETCH(int, loopCount);
+    QFETCH(int, currentTime);
+    QFETCH(int, testCurrentTime);
+    QFETCH(int, testCurrentLoop);
+
+    QPropertyAnimation animation;
+    if (duration < 0)
+        QTest::ignoreMessage(QtWarningMsg, "QVariantAnimation::setDuration: cannot set a negative duration");
+    animation.setDuration(duration);
+    animation.setLoopCount(loopCount);
+    animation.setCurrentTime(currentTime);
+
+    QCOMPARE(animation.currentTime(), testCurrentTime);
+    QCOMPARE(animation.currentLoop(), testCurrentLoop);
+}
+
+void tst_QPropertyAnimation::statesAndSignals_data()
+{
+    QTest::addColumn<bool>("uncontrolled");
+    QTest::newRow("normal animation") << false;
+    QTest::newRow("animation with undefined duration")  <<  true;
+}
+
+void tst_QPropertyAnimation::statesAndSignals()
+{
+    QFETCH(bool, uncontrolled);
+    QPropertyAnimation *anim = uncontrolled ? new UncontrolledAnimation : new QPropertyAnimation;
+    anim->setDuration(100);
+
+    QSignalSpy finishedSpy(anim, SIGNAL(finished()));
+    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy currentLoopSpy(anim, SIGNAL(currentLoopChanged(int)));
+
+    anim->setCurrentTime(1);
+    anim->setCurrentTime(100);
+    QCOMPARE(finishedSpy.count(), 0);
+    QCOMPARE(runningSpy.count(), 0);
+    QCOMPARE(currentLoopSpy.count(), 0);
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+
+    anim->setLoopCount(3);
+    anim->setCurrentTime(101);
+
+    if (uncontrolled)
+        QSKIP("Uncontrolled animations don't handle looping", SkipSingle);
+
+    QCOMPARE(currentLoopSpy.count(), 1);
+    QCOMPARE(anim->currentLoop(), 1);
+
+    anim->setCurrentTime(0);
+    QCOMPARE(currentLoopSpy.count(), 2);
+    QCOMPARE(anim->currentLoop(), 0);
+
+    anim->start();
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QCOMPARE(runningSpy.count(), 1); //anim must have started
+    QCOMPARE(anim->currentLoop(), 0);
+    runningSpy.clear();
+
+    anim->stop();
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+    QCOMPARE(runningSpy.count(), 1); //anim must have stopped
+    QCOMPARE(finishedSpy.count(), 0);
+    QCOMPARE(anim->currentTime(), 0);
+    QCOMPARE(anim->currentLoop(), 0);
+    QCOMPARE(currentLoopSpy.count(), 2);
+    runningSpy.clear();
+
+    anim->start();
+    QTest::qWait(1000);
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+    QCOMPARE(runningSpy.count(), 2); //started and stopped again
+    runningSpy.clear();
+    QCOMPARE(finishedSpy.count(), 1);
+    QCOMPARE(anim->currentTime(), 100);
+    QCOMPARE(anim->currentLoop(), 2);
+    QCOMPARE(currentLoopSpy.count(), 4);
+
+    anim->start(); // auto-rewinds
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QCOMPARE(anim->currentTime(), 0);
+    QCOMPARE(anim->currentLoop(), 0);
+    QCOMPARE(currentLoopSpy.count(), 5);
+    QCOMPARE(runningSpy.count(), 1); // anim has started
+    QCOMPARE(finishedSpy.count(), 1);
+    QCOMPARE(anim->currentLoop(), 0);
+    runningSpy.clear();
+
+    QTest::qWait(1000);
+
+    QCOMPARE(currentLoopSpy.count(), 7);
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim->currentLoop(), 2);
+    QCOMPARE(runningSpy.count(), 1); // anim has stopped
+    QCOMPARE(finishedSpy.count(), 2);
+    QCOMPARE(anim->currentTime(), 100);
+
+    delete anim;
+}
+
+void tst_QPropertyAnimation::deletion1()
+{
+    QObject *object = new QWidget;
+    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)));
+    QSignalSpy finishedSpy(anim, SIGNAL(finished()));
+    anim->setStartValue(10);
+    anim->setEndValue(20);
+    anim->setDuration(200);
+    anim->start();
+    QCOMPARE(runningSpy.count(), 1);
+    QCOMPARE(finishedSpy.count(), 0);
+
+    QVERIFY(anim);
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QTest::qWait(100);
+    QVERIFY(anim);
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QTest::qWait(150);
+    QVERIFY(anim); //The animation should not have been deleted
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+    QCOMPARE(runningSpy.count(), 2);
+    QCOMPARE(finishedSpy.count(), 1);
+
+    anim->start(QVariantAnimation::DeleteWhenStopped);
+    QVERIFY(anim);
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QTest::qWait(100);
+    QVERIFY(anim);
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QTest::qWait(150);
+    QVERIFY(!anim);  //The animation must have been deleted
+    QCOMPARE(runningSpy.count(), 4);
+    QCOMPARE(finishedSpy.count(), 2);
+    delete object;
+}
+
+void tst_QPropertyAnimation::deletion2()
+{
+    //test that the animation get deleted if the object is deleted
+    QObject *object = new QWidget;
+    QPointer<QPropertyAnimation> anim = new QPropertyAnimation(object,"minimumWidth");
+    anim->setStartValue(10);
+    anim->setEndValue(20);
+    anim->setDuration(200);
+
+    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy finishedSpy(anim, SIGNAL(finished()));
+
+    anim->setStartValue(10);
+    anim->setEndValue(20);
+    anim->setDuration(200);
+    anim->start();
+
+    QTest::qWait(50);
+    QVERIFY(anim);
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+
+    QCOMPARE(runningSpy.count(), 1);
+    QCOMPARE(finishedSpy.count(), 0);
+
+    //we can't call deletaLater directly because the delete would only happen in the next loop of _this_ event loop
+    QTimer::singleShot(0, object, SLOT(deleteLater()));
+    QTest::qWait(50);
+
+    QVERIFY(anim->targetObject() == 0);
+}
+
+void tst_QPropertyAnimation::deletion3()
+{
+    //test that the stopped signal is emit when the animation is destroyed
+    QObject *object = new QWidget;
+    QPropertyAnimation *anim = new QPropertyAnimation(object,"minimumWidth");
+    anim->setStartValue(10);
+    anim->setEndValue(20);
+    anim->setDuration(200);
+
+    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy finishedSpy(anim, SIGNAL(finished()));
+    anim->start();
+
+    QTest::qWait(50);
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QCOMPARE(runningSpy.count(), 1);
+    QCOMPARE(finishedSpy.count(), 0);
+    delete anim;
+    QCOMPARE(runningSpy.count(), 2);
+    QCOMPARE(finishedSpy.count(), 0);
+}
+
+void tst_QPropertyAnimation::duration0()
+{
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation animation(&o, "ole");
+    animation.setEndValue(43);
+    QVERIFY(!animation.currentValue().isValid());
+    QCOMPARE(animation.currentValue().toInt(), 0);
+    QCOMPARE(o.property("ole").toInt(), 42);
+    animation.setDuration(0);
+    animation.start();
+    QCOMPARE(animation.state(), QAnimationGroup::Stopped);
+    QCOMPARE(animation.currentTime(), 0);
+    QCOMPARE(o.property("ole").toInt(), 43);
+}
+
+class StartValueTester : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int ole READ ole WRITE setOle)
+public:
+    StartValueTester() : o(0) { }
+    int ole() const { return o; }
+    void setOle(int v) { o = v; values << v; }
+
+    int o;
+    QList<int> values;
+};
+
+void tst_QPropertyAnimation::noStartValue()
+{
+    StartValueTester o;
+    o.setProperty("ole", 42);
+    o.values.clear();
+
+    QPropertyAnimation a(&o, "ole");
+    a.setEndValue(420);
+    a.setDuration(250);
+    a.start();
+
+    QTest::qWait(300);
+
+    QCOMPARE(o.values.first(), 42);
+    QCOMPARE(o.values.last(), 420);
+}
+
+void tst_QPropertyAnimation::noStartValueWithLoop()
+{
+    StartValueTester o;
+    o.setProperty("ole", 42);
+    o.values.clear();
+
+    QPropertyAnimation a(&o, "ole");
+    a.setEndValue(420);
+    a.setDuration(250);
+    a.setLoopCount(2);
+    a.start();
+
+    a.setCurrentTime(250);
+    QCOMPARE(o.values.first(), 42);
+    QCOMPARE(a.currentValue().toInt(), 42);
+    QCOMPARE(o.values.last(), 42);
+
+    a.setCurrentTime(500);
+    QCOMPARE(a.currentValue().toInt(), 420);
+}
+
+void tst_QPropertyAnimation::startWhenAnotherIsRunning()
+{
+    StartValueTester o;
+    o.setProperty("ole", 42);
+    o.values.clear();
+
+    {
+        //normal case: the animation finishes and is deleted
+        QPointer<QVariantAnimation> anim = new QPropertyAnimation(&o, "ole");
+        QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+        anim->start(QVariantAnimation::DeleteWhenStopped);
+        QTest::qWait(anim->duration() + 50);
+        QCOMPARE(runningSpy.count(), 2); //started and then stopped
+        QVERIFY(!anim);
+    }
+
+    {
+        QPointer<QVariantAnimation> anim = new QPropertyAnimation(&o, "ole");
+        QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+        anim->start(QVariantAnimation::DeleteWhenStopped);
+        QTest::qWait(anim->duration()/2);
+        QPointer<QVariantAnimation> anim2 = new QPropertyAnimation(&o, "ole");
+        QCOMPARE(runningSpy.count(), 1);
+        QCOMPARE(anim->state(), QVariantAnimation::Running);
+
+        //anim2 will interrupt anim1
+        QMetaObject::invokeMethod(anim2, "start", Qt::QueuedConnection, Q_ARG(QAbstractAnimation::DeletionPolicy, QVariantAnimation::DeleteWhenStopped));
+        QTest::qWait(50);
+        QVERIFY(!anim); //anim should have been deleted
+        QVERIFY(anim2);
+        QTest::qWait(anim2->duration());
+        QVERIFY(!anim2); //anim2 is finished: it should have been deleted by now
+        QVERIFY(!anim);
+    }
+
+}
+
+// copy  from easing.cpp in case that function changes definition
+static qreal easeInOutBack(qreal t)
+{
+    qreal s = 1.70158;
+    qreal t_adj = 2.0f * (qreal)t;
+    if (t_adj < 1) {
+        s *= 1.525f;
+        return 1.0/2*(t_adj*t_adj*((s+1)*t_adj - s));
+    } else {
+        t_adj -= 2;
+        s *= 1.525f;
+        return 1.0/2*(t_adj*t_adj*((s+1)*t_adj + s) + 2);
+    }
+}
+
+void tst_QPropertyAnimation::easingcurve_data()
+{
+    QTest::addColumn<int>("currentTime");
+    QTest::addColumn<int>("expectedvalue");
+
+    QTest::newRow("interpolation1") << 0 << 0;
+    QTest::newRow("interpolation2") << 1000 << 1000;
+    QTest::newRow("extrapolationbelow") << 250 << -99;
+    QTest::newRow("extrapolationabove") << 750 << 1099;
+}
+
+void tst_QPropertyAnimation::easingcurve()
+{
+    QFETCH(int, currentTime);
+    QFETCH(int, expectedvalue);
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation pAnimation(&o, "ole");
+    pAnimation.setStartValue(0);
+    pAnimation.setEndValue(1000);
+    pAnimation.setDuration(1000);
+
+    // this easingcurve assumes that we extrapolate before startValue and after endValue
+    QEasingCurve easingCurve;
+    easingCurve.setCustomType(easeInOutBack);
+    pAnimation.setEasingCurve(easingCurve);
+    pAnimation.start();
+    pAnimation.pause();
+    pAnimation.setCurrentTime(currentTime);
+    QCOMPARE(o.property("ole").toInt(), expectedvalue);
+}
+
+void tst_QPropertyAnimation::startWithoutStartValue()
+{
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation anim(&o, "ole");
+    anim.setEndValue(100);
+
+    anim.start();
+
+    QTest::qWait(100);
+    int current = anim.currentValue().toInt();
+    //it is somewhere in the animation
+    QVERIFY(current > 42);
+    QVERIFY(current < 100);
+
+    QTest::qWait(200);
+    QCOMPARE(anim.state(), QVariantAnimation::Stopped);
+
+    anim.setEndValue(110);
+    anim.start();
+    current = anim.currentValue().toInt();
+    // the default start value will reevaluate the current property
+    // and set it to the end value of the last iteration
+    QCOMPARE(current, 100);
+    QTest::qWait(100);
+    current = anim.currentValue().toInt();
+    //it is somewhere in the animation
+    QVERIFY(current >= 100);
+    QVERIFY(current <= 110);
+}
+
+void tst_QPropertyAnimation::playForwardBackward()
+{
+    QObject o;
+    o.setProperty("ole", 0);
+    QCOMPARE(o.property("ole").toInt(), 0);
+
+    QPropertyAnimation anim(&o, "ole");
+    anim.setEndValue(100);
+    anim.start();
+    QTest::qWait(anim.duration() + 50);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(anim.currentTime(), anim.duration());
+
+    //the animation is at the end
+    anim.setDirection(QVariantAnimation::Backward);
+    anim.start();
+    QCOMPARE(anim.state(), QAbstractAnimation::Running);
+    QTest::qWait(anim.duration() + 50);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(anim.currentTime(), 0);
+
+    //the direction is backward
+    //restarting should jump to the end
+    anim.start();
+    QCOMPARE(anim.state(), QAbstractAnimation::Running);
+    QCOMPARE(anim.currentTime(), anim.duration());
+    QTest::qWait(anim.duration() + 50);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(anim.currentTime(), 0);
+}
+
+struct Number
+{
+    Number() {}
+    Number(int n)
+        : n(n) {}
+
+    Number(const Number &other)
+        : n(other.n){}
+
+    Number &operator=(const Number &other) {
+        n = other.n;
+        return *this;
+    }
+    bool operator==(const Number &other) const {
+        return n == other.n;
+    }
+
+    int n;
+};
+
+Q_DECLARE_METATYPE(Number)
+Q_DECLARE_METATYPE(QAbstractAnimation::State)
+
+QVariant numberInterpolator(const Number &f, const Number &t, qreal progress)
+{
+    return qVariantFromValue<Number>(Number(f.n + (t.n - f.n)*progress));
+}
+
+QVariant xaxisQPointInterpolator(const QPointF &f, const QPointF &t, qreal progress)
+{
+    return QPointF(f.x() + (t.x() - f.x())*progress, f.y());
+}
+
+void tst_QPropertyAnimation::interpolated()
+{
+    QObject o;
+    o.setProperty("point", QPointF()); //this will avoid warnings
+    o.setProperty("number", qVariantFromValue<Number>(Number(42)));
+    QCOMPARE(qVariantValue<Number>(o.property("number")), Number(42));
+    {
+    qRegisterAnimationInterpolator<Number>(numberInterpolator);
+    QPropertyAnimation anim(&o, "number");
+    anim.setStartValue(qVariantFromValue<Number>(Number(0)));
+    anim.setEndValue(qVariantFromValue<Number>(Number(100)));
+    anim.setDuration(1000);
+    anim.start();
+    anim.pause();
+    anim.setCurrentTime(100);
+    Number t(qVariantValue<Number>(o.property("number")));
+    QCOMPARE(t, Number(10));
+    anim.setCurrentTime(500);
+    QCOMPARE(qVariantValue<Number>(o.property("number")), Number(50));
+    }
+    {
+    qRegisterAnimationInterpolator<QPointF>(xaxisQPointInterpolator);
+    QPropertyAnimation anim(&o, "point");
+    anim.setStartValue(QPointF(0,0));
+    anim.setEndValue(QPointF(100, 100));
+    anim.setDuration(1000);
+    anim.start();
+    anim.pause();
+    anim.setCurrentTime(100);
+    QCOMPARE(o.property("point"), QVariant(QPointF(10, 0)));
+    anim.setCurrentTime(500);
+    QCOMPARE(o.property("point"), QVariant(QPointF(50, 0)));
+    }
+    {
+    // unregister it and see if we get back the default behaviour
+    qRegisterAnimationInterpolator<QPointF>(0);
+    QPropertyAnimation anim(&o, "point");
+    anim.setStartValue(QPointF(0,0));
+    anim.setEndValue(QPointF(100, 100));
+    anim.setDuration(1000);
+    anim.start();
+    anim.pause();
+    anim.setCurrentTime(100);
+    QCOMPARE(o.property("point").toPointF(), QPointF(10, 10));
+    anim.setCurrentTime(500);
+    QCOMPARE(o.property("point").toPointF(), QPointF(50, 50));
+    }
+
+    {
+    // Interpolate a qreal property with a int interpolator
+    AnimationObject o1;
+    o1.setRealValue(42.42);
+    QPropertyAnimation anim(&o1, "realValue");
+    anim.setStartValue(0);
+    anim.setEndValue(100);
+    anim.start();
+    QCOMPARE(o1.realValue(), qreal(0));
+    anim.setCurrentTime(250);
+    QCOMPARE(o1.realValue(), qreal(100));
+    }
+}
+
+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
+    object.setProperty(propertyName, initialValue);
+    QPropertyAnimation anim(&object, propertyName);
+    QVariantAnimation::KeyValues values;
+    QCOMPARE(anim.keyValues(), values);
+
+    //let's add a start value
+    anim.setStartValue(startValue);
+    values << QVariantAnimation::KeyValue(0, startValue);
+    QCOMPARE(anim.keyValues(), values);
+
+    anim.setEndValue(endValue);
+    values << QVariantAnimation::KeyValue(1, endValue);
+    QCOMPARE(anim.keyValues(), values);
+
+    //now we can play with objects
+    QCOMPARE(object.property(propertyName).toDouble(), initialValue.toDouble());
+    anim.start();
+    QVERIFY(anim.startValue().isValid());
+    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();
+    object.setProperty(propertyName, initialValue);
+
+    //let's reset the start value
+    values.remove(0);
+    anim.setStartValue(QVariant());
+    QCOMPARE(anim.keyValues(), values);
+    QVERIFY(!anim.startValue().isValid());
+
+    anim.start();
+    QCOMPARE(object.property(propertyName), initialValue);
+    anim.setCurrentTime(anim.duration()/2);
+    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(object.property(propertyName), anim.endValue()); //end of the animations
+
+    //now we set back the startValue
+    anim.setStartValue(startValue);
+    QVERIFY(anim.startValue().isValid());
+    anim.start();
+    QCOMPARE(object.property(propertyName), startValue);
+}
+
+void tst_QPropertyAnimation::zeroDurationStart()
+{
+    QPropertyAnimation anim;
+    QSignalSpy spy(&anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    anim.setDuration(0);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    anim.start();
+    //the animation stops immediately
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(spy.count(), 2);
+
+    //let's check the first state change
+    const QVariantList firstChange = spy.first();
+    //old state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Stopped);
+    //new state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Running);
+
+    //let's check the first state change
+    const QVariantList secondChange = spy.last();
+    //old state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Running);
+    //new state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Stopped);
+}
+
+#define Pause 1
+#define Start 2
+#define Resume 3
+#define Stop 4
+
+void tst_QPropertyAnimation::operationsInStates_data()
+{
+    QTest::addColumn<QAbstractAnimation::State>("originState");
+    QTest::addColumn<int>("operation");
+    QTest::addColumn<QString>("expectedWarning");
+    QTest::addColumn<QAbstractAnimation::State>("expectedState");
+
+    QString pauseWarn(QLatin1String("QAbstractAnimation::pause: Cannot pause a stopped animation"));
+    QString resumeWarn(QLatin1String("QAbstractAnimation::resume: Cannot resume an animation that is not paused"));
+
+    QTest::newRow("S-pause")  << QAbstractAnimation::Stopped << Pause << pauseWarn << QAbstractAnimation::Stopped;
+    QTest::newRow("S-start")  << QAbstractAnimation::Stopped << Start << QString() << QAbstractAnimation::Running;
+    QTest::newRow("S-resume") << QAbstractAnimation::Stopped << Resume << resumeWarn << QAbstractAnimation::Stopped;
+    QTest::newRow("S-stop")   << QAbstractAnimation::Stopped << Stop << QString() << QAbstractAnimation::Stopped;
+
+    QTest::newRow("P-pause")  << QAbstractAnimation::Paused << Pause << QString() << QAbstractAnimation::Paused;
+    QTest::newRow("P-start")  << QAbstractAnimation::Paused << Start << QString() << QAbstractAnimation::Running;
+    QTest::newRow("P-resume") << QAbstractAnimation::Paused << Resume << QString() << QAbstractAnimation::Running;
+    QTest::newRow("P-stop")   << QAbstractAnimation::Paused << Stop << QString() << QAbstractAnimation::Stopped;
+
+    QTest::newRow("R-pause")  << QAbstractAnimation::Running << Pause << QString() << QAbstractAnimation::Paused;
+    QTest::newRow("R-start")  << QAbstractAnimation::Running << Start << QString() << QAbstractAnimation::Running;
+    QTest::newRow("R-resume") << QAbstractAnimation::Running << Resume << resumeWarn << QAbstractAnimation::Running;
+    QTest::newRow("R-stop")   << QAbstractAnimation::Running << Stop << QString() << QAbstractAnimation::Stopped;
+}
+
+void tst_QPropertyAnimation::operationsInStates()
+{
+/**
+ *           | pause()    |start()    |resume()   |stop()
+ * ----------+------------+-----------+-----------+-------------------+
+ * Stopped   | Stopped    |Running    |Stopped    |Stopped            |
+ *          _| qWarning   |restart    |qWarning   |                   |
+ * Paused    | Paused     |Running    |Running    |Stopped            |
+ *          _|            |           |           |                   |
+ * Running   | Paused     |Running    |Running    |Stopped            |
+ *           |            |restart    |qWarning   |                   |
+ * ----------+------------+-----------+-----------+-------------------+
+**/
+
+    QFETCH(QAbstractAnimation::State, originState);
+    QFETCH(int, operation);
+    QFETCH(QString, expectedWarning);
+    QFETCH(QAbstractAnimation::State, expectedState);
+
+    QObject o;
+    o.setProperty("ole", 42);
+    QPropertyAnimation anim(&o, "ole");
+    QSignalSpy spy(&anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    anim.stop();
+    switch (originState) {
+    case QAbstractAnimation::Stopped:
+    break;
+    case QAbstractAnimation::Paused:
+        anim.start();
+        anim.pause();
+    break;
+    case QAbstractAnimation::Running:
+        anim.start();
+    break;
+    }
+    if (!expectedWarning.isEmpty()) {
+        QTest::ignoreMessage(QtWarningMsg, qPrintable(expectedWarning));
+    }
+    QCOMPARE(anim.state(), originState);
+    switch (operation) {
+    case Pause:
+        anim.pause();
+    break;
+    case Start:
+        anim.start();
+    break;
+    case Resume:
+        anim.resume();
+    break;
+    case Stop:
+        anim.stop();
+    break;
+    }
+
+    QCOMPARE(anim.state(), expectedState);
+}
+#undef Pause
+#undef Start
+#undef Resume
+#undef Stop
+
+void tst_QPropertyAnimation::oneKeyValue()
+{
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation animation(&o, "ole");
+    animation.setStartValue(43);
+    animation.setEndValue(44);
+    animation.setDuration(100);
+
+    animation.setCurrentTime(0);
+
+    QVERIFY(animation.currentValue().isValid());
+    QCOMPARE(animation.currentValue().toInt(), 43);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    // remove the last key value
+    animation.setKeyValueAt(1.0, QVariant());
+
+    // we will neither interpolate, nor update the current value
+    // since there is only one 1 key value defined
+    animation.setCurrentTime(100);
+
+    // the animation should not have been modified
+    QVERIFY(animation.currentValue().isValid());
+    QCOMPARE(animation.currentValue().toInt(), 43);
+    QCOMPARE(o.property("ole").toInt(), 42);
+}
+
+void tst_QPropertyAnimation::updateOnSetKeyValues()
+{
+    QObject o;
+    o.setProperty("ole", 100);
+    QCOMPARE(o.property("ole").toInt(), 100);
+
+    QPropertyAnimation animation(&o, "ole");
+    animation.setStartValue(100);
+    animation.setEndValue(200);
+    animation.setDuration(100);
+
+    animation.setCurrentTime(50);
+    QCOMPARE(animation.currentValue().toInt(), 150);
+    animation.setKeyValueAt(0.0, 300);
+    QCOMPARE(animation.currentValue().toInt(), 250);
+
+    o.setProperty("ole", 100);
+    QPropertyAnimation animation2(&o, "ole");
+    QVariantAnimation::KeyValues kValues;
+    kValues << QVariantAnimation::KeyValue(0.0, 100) << QVariantAnimation::KeyValue(1.0, 200);
+    animation2.setKeyValues(kValues);
+    animation2.setDuration(100);
+    animation2.setCurrentTime(50);
+    QCOMPARE(animation2.currentValue().toInt(), 150);
+
+    kValues.clear();
+    kValues << QVariantAnimation::KeyValue(0.0, 300) << QVariantAnimation::KeyValue(1.0, 200);
+    animation2.setKeyValues(kValues);
+
+    QCOMPARE(animation2.currentValue().toInt(), animation.currentValue().toInt());
+}
+
+QTEST_MAIN(tst_QPropertyAnimation)
+#include "tst_qpropertyanimation.moc"
diff --git a/tests/auto/qsequentialanimationgroup/qsequentialanimationgroup.pro b/tests/auto/qsequentialanimationgroup/qsequentialanimationgroup.pro
new file mode 100644
index 0000000..ad861c3
--- /dev/null
+++ b/tests/auto/qsequentialanimationgroup/qsequentialanimationgroup.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT = core gui
+SOURCES  += tst_qsequentialanimationgroup.cpp
+
+
diff --git a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
new file mode 100644
index 0000000..0631343
--- /dev/null
+++ b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
@@ -0,0 +1,1649 @@
+/****************************************************************************
+**
+** 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 "../../shared/util.h"
+
+#include <QtCore/qanimationgroup.h>
+#include <QtCore/qsequentialanimationgroup.h>
+
+//TESTED_CLASS=QSequentialAnimationGroup
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(QAbstractAnimation::State)
+Q_DECLARE_METATYPE(QAbstractAnimation*)
+
+class tst_QSequentialAnimationGroup : public QObject
+{
+  Q_OBJECT
+public:
+    tst_QSequentialAnimationGroup();
+    virtual ~tst_QSequentialAnimationGroup();
+
+public Q_SLOTS:
+    void init();
+    void cleanup();
+
+private slots:
+    void construction();
+    void setCurrentTime();
+    void setCurrentTimeWithUncontrolledAnimation();
+    void seekingForwards();
+    void seekingBackwards();
+    void pauseAndResume();
+    void restart();
+    void looping();
+    void startDelay();
+    void clearGroup();
+    void groupWithZeroDurationAnimations();
+    void propagateGroupUpdateToChildren();
+    void updateChildrenWithRunningGroup();
+    void deleteChildrenWithRunningGroup();
+    void startChildrenWithStoppedGroup();
+    void stopGroupWithRunningChild();
+    void startGroupWithRunningChild();
+    void zeroDurationAnimation();
+    void stopUncontrolledAnimations();
+    void finishWithUncontrolledAnimation();
+    void addRemoveAnimation();
+    void currentAnimation();
+    void currentAnimationWithZeroDuration();
+    void insertAnimation();
+    void clearAnimations();
+};
+
+tst_QSequentialAnimationGroup::tst_QSequentialAnimationGroup()
+{
+}
+
+tst_QSequentialAnimationGroup::~tst_QSequentialAnimationGroup()
+{
+}
+
+void tst_QSequentialAnimationGroup::init()
+{
+    qRegisterMetaType<QAbstractAnimation::State>("QAbstractAnimation::State");
+    qRegisterMetaType<QAbstractAnimation*>("QAbstractAnimation*");
+}
+
+void tst_QSequentialAnimationGroup::cleanup()
+{
+}
+
+void tst_QSequentialAnimationGroup::construction()
+{
+    QSequentialAnimationGroup animationgroup;
+}
+
+class AnimationObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int value READ value WRITE setValue)
+public:
+    AnimationObject(int startValue = 0)
+        : v(startValue)
+    { }
+
+    int value() const { return v; }
+    void setValue(int value) { v = value; }
+
+    int v;
+};
+
+class TestAnimation : public QVariantAnimation
+{
+    Q_OBJECT
+public:
+    virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
+    virtual void updateState(QAbstractAnimation::State oldState,
+                             QAbstractAnimation::State newState)
+    {
+        Q_UNUSED(oldState)
+        Q_UNUSED(newState)
+    };
+};
+
+class UncontrolledAnimation : public QPropertyAnimation
+{
+    Q_OBJECT
+public:
+    UncontrolledAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0)
+        : QPropertyAnimation(target, propertyName, parent)
+    {
+        setDuration(250);
+    }
+
+    int duration() const { return -1; /* not time driven */ }
+
+protected:
+    void updateCurrentTime(int msecs)
+    {
+        QPropertyAnimation::updateCurrentTime(msecs);
+        if (msecs >= QPropertyAnimation::duration())
+            stop();
+    }
+};
+
+void tst_QSequentialAnimationGroup::setCurrentTime()
+{
+    AnimationObject s_o1;
+    AnimationObject s_o2;
+    AnimationObject s_o3;
+
+    // sequence operating on same object/property
+    QAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    a2_s_o1->setLoopCount(3);
+    sequence->addAnimation(a1_s_o1);
+    sequence->addAnimation(a2_s_o1);
+    sequence->addAnimation(a3_s_o1);
+
+    // sequence operating on different object/properties
+    QAnimationGroup *sequence2 = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
+    QVariantAnimation *a1_s_o3 = new QPropertyAnimation(&s_o3, "value");
+    sequence2->addAnimation(a1_s_o2);
+    sequence2->addAnimation(a1_s_o3);
+
+    QSequentialAnimationGroup group;
+    group.addAnimation(sequence);
+    group.addAnimation(sequence2);
+
+    // Current time = 1
+    group.setCurrentTime(1);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+
+    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 1);
+    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 250
+    group.setCurrentTime(250);
+    QCOMPARE(group.currentTime(), 250);
+    QCOMPARE(sequence->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 251
+    group.setCurrentTime(251);
+    QCOMPARE(group.currentTime(), 251);
+    QCOMPARE(sequence->currentTime(), 251);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoop(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(sequence2->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 750
+    group.setCurrentTime(750);
+    QCOMPARE(group.currentTime(), 750);
+    QCOMPARE(sequence->currentTime(), 750);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(sequence2->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 1000
+    group.setCurrentTime(1000);
+    QCOMPARE(group.currentTime(), 1000);
+    QCOMPARE(sequence->currentTime(), 1000);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(sequence2->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 1010
+    group.setCurrentTime(1010);
+    QCOMPARE(group.currentTime(), 1010);
+    QCOMPARE(sequence->currentTime(), 1010);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 10);
+    QCOMPARE(sequence2->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 1250
+    group.setCurrentTime(1250);
+    QCOMPARE(group.currentTime(), 1250);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 1500
+    group.setCurrentTime(1500);
+    QCOMPARE(group.currentTime(), 1500);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 250);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 1750
+    group.setCurrentTime(1750);
+    QCOMPARE(group.currentTime(), 1750);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 500);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 250);
+
+    // Current time = 2000
+    group.setCurrentTime(2000);
+    QCOMPARE(group.currentTime(), 1750);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 500);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 250);
+}
+
+void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
+{
+    AnimationObject s_o1;
+    AnimationObject s_o2;
+    AnimationObject t_o1;
+    AnimationObject t_o2;
+
+    // sequence operating on different object/properties
+    QAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
+    sequence->addAnimation(a1_s_o1);
+    sequence->addAnimation(a1_s_o2);
+
+    UncontrolledAnimation *notTimeDriven = new UncontrolledAnimation(&t_o1, "value");
+    QCOMPARE(notTimeDriven->totalDuration(), -1);
+
+    QVariantAnimation *loopsForever = new QPropertyAnimation(&t_o2, "value");
+    loopsForever->setLoopCount(-1);
+    QCOMPARE(loopsForever->totalDuration(), -1);
+
+    QSequentialAnimationGroup group;
+    group.addAnimation(sequence);
+    group.addAnimation(notTimeDriven);
+    group.addAnimation(loopsForever);
+    group.start();
+    group.pause(); // this allows the group to listen for the finish signal of its children
+
+    // Current time = 1
+    group.setCurrentTime(1);
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(sequence->state(), QAnimationGroup::Paused);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Paused);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
+
+    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 1);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(notTimeDriven->currentTime(), 0);
+    QCOMPARE(loopsForever->currentTime(), 0);
+
+    // Current time = 250
+    group.setCurrentTime(250);
+    QCOMPARE(group.currentTime(), 250);
+    QCOMPARE(sequence->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(notTimeDriven->currentTime(), 0);
+    QCOMPARE(loopsForever->currentTime(), 0);
+
+    // Current time = 500
+    group.setCurrentTime(500);
+    QCOMPARE(group.currentTime(), 500);
+    QCOMPARE(sequence->currentTime(), 500);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 0);
+    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentAnimation(), notTimeDriven);
+
+    // Current time = 505
+    group.setCurrentTime(505);
+    QCOMPARE(group.currentTime(), 505);
+    QCOMPARE(sequence->currentTime(), 500);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 5);
+    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentAnimation(), notTimeDriven);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven->state(), QAnimationGroup::Paused);
+    QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
+
+    // Current time = 750 (end of notTimeDriven animation)
+    group.setCurrentTime(750);
+    QCOMPARE(group.currentTime(), 750);
+    QCOMPARE(sequence->currentTime(), 500);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 250);
+    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentAnimation(), loopsForever);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever->state(), QAnimationGroup::Paused);
+
+    // Current time = 800 (as notTimeDriven was finished at 750, loopsforever should still run)
+    group.setCurrentTime(800);
+    QCOMPARE(group.currentTime(), 800);
+    QCOMPARE(group.currentAnimation(), loopsForever);
+    QCOMPARE(sequence->currentTime(), 500);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(notTimeDriven->currentTime(), 250);
+    QCOMPARE(loopsForever->currentTime(), 50);
+
+    loopsForever->stop(); // this should stop the group
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::seekingForwards()
+{
+    AnimationObject s_o1;
+    AnimationObject s_o2;
+    AnimationObject s_o3;
+
+    // sequence operating on same object/property
+    QAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    a2_s_o1->setLoopCount(3);
+    sequence->addAnimation(a1_s_o1);
+    sequence->addAnimation(a2_s_o1);
+    sequence->addAnimation(a3_s_o1);
+
+    // sequence operating on different object/properties
+    QAnimationGroup *sequence2 = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
+    QVariantAnimation *a1_s_o3 = new QPropertyAnimation(&s_o3, "value");
+    sequence2->addAnimation(a1_s_o2);
+    sequence2->addAnimation(a1_s_o3);
+
+    QSequentialAnimationGroup group;
+    group.addAnimation(sequence);
+    group.addAnimation(sequence2);
+
+    // Current time = 1
+    group.setCurrentTime(1);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o3->state(), QAnimationGroup::Stopped);
+
+    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 1);
+    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(sequence2->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // Current time = 1500
+    group.setCurrentTime(1500);
+    QCOMPARE(group.currentTime(), 1500);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 250);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    // this will restart the group
+    group.start();
+    group.pause();
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(sequence->state(), QAnimationGroup::Paused);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Paused);
+    QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o3->state(), QAnimationGroup::Stopped);
+
+    // Current time = 1750
+    group.setCurrentTime(1750);
+    QCOMPARE(group.currentTime(), 1750);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 500);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 250);
+}
+
+void tst_QSequentialAnimationGroup::seekingBackwards()
+{
+    AnimationObject s_o1;
+    AnimationObject s_o2;
+    AnimationObject s_o3;
+
+    // sequence operating on same object/property
+    QAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    a2_s_o1->setLoopCount(3);
+    sequence->addAnimation(a1_s_o1);
+    sequence->addAnimation(a2_s_o1);
+    sequence->addAnimation(a3_s_o1);
+
+    // sequence operating on different object/properties
+    QAnimationGroup *sequence2 = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
+    QVariantAnimation *a1_s_o3 = new QPropertyAnimation(&s_o3, "value");
+    sequence2->addAnimation(a1_s_o2);
+    sequence2->addAnimation(a1_s_o3);
+
+    QSequentialAnimationGroup group;
+    group.addAnimation(sequence);
+    group.addAnimation(sequence2);
+
+    group.start();
+
+    // Current time = 1600
+    group.setCurrentTime(1600);
+    QCOMPARE(group.currentTime(), 1600);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 350);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 100);
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence2->state(), QAnimationGroup::Running);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o3->state(), QAnimationGroup::Running);
+
+    // Seeking backwards, current time = 1
+    group.setCurrentTime(1);
+    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 1);
+
+    QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
+        "hence they don't reset from their current animation", Continue);
+    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
+        "hence they don't reset from their current animation", Continue);
+    QCOMPARE(a2_s_o1->currentLoop(), 0);
+    QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
+        "hence they don't reset from their current animation", Continue);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(sequence2->currentTime(), 0);
+    QCOMPARE(a1_s_o2->currentTime(), 0);
+    QCOMPARE(a1_s_o3->currentTime(), 0);
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(sequence->state(), QAnimationGroup::Running);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Running);
+    QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o3->state(), QAnimationGroup::Stopped);
+
+    // Current time = 2000
+    group.setCurrentTime(2000);
+    QCOMPARE(group.currentTime(), 1750);
+    QCOMPARE(sequence->currentTime(), 1250);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 2);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(sequence2->currentTime(), 500);
+    QCOMPARE(a1_s_o2->currentTime(), 250);
+    QCOMPARE(a1_s_o3->currentTime(), 250);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a1_s_o3->state(), QAnimationGroup::Stopped);
+}
+
+typedef QList<QAbstractAnimation::State> StateList;
+
+static bool compareStates(const QSignalSpy& spy, const StateList &expectedStates)
+{
+    bool equals = true;
+    for (int i = 0; i < qMax(expectedStates.count(), spy.count()); ++i) {
+        if (i >= spy.count() || i >= expectedStates.count()) {
+            equals = false;
+            break;
+        }
+        QList<QVariant> args = spy.at(i);
+        QAbstractAnimation::State st = expectedStates.at(i);
+        QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.value(1));
+        if (equals && actual != st) {
+            equals = false;
+            break;
+        }
+    }
+    if (!equals) {
+        const char *stateStrings[] = {"Stopped", "Paused", "Running"};
+        QString e,a;
+        for (int i = 0; i < qMax(expectedStates.count(), spy.count()); ++i) {
+            if (i < expectedStates.count()) {
+                int exp = int(expectedStates.at(i));
+                    if (!e.isEmpty())
+                        e += QLatin1String(", ");
+                e += QLatin1String(stateStrings[exp]);
+            }
+            if (i < spy.count()) {
+                QList<QVariant> args = spy.at(i);
+                QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.value(1));
+                if (!a.isEmpty())
+                    a += QLatin1String(", ");
+                if (int(actual) >= 0 && int(actual) <= 2) {
+                    a += QLatin1String(stateStrings[int(actual)]);
+                } else {
+                    a += QLatin1String("NaN");
+                }
+            }
+
+        }
+        qDebug("\n"
+               "expected (count == %d): %s\n"
+               "actual   (count == %d): %s\n", expectedStates.count(), qPrintable(e), spy.count(), qPrintable(a));
+    }
+    return equals;
+}
+
+void tst_QSequentialAnimationGroup::pauseAndResume()
+{
+    AnimationObject s_o1;
+
+    // sequence operating on same object/property
+    QAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    a2_s_o1->setLoopCount(2);
+    sequence->addAnimation(a1_s_o1);
+    sequence->addAnimation(a2_s_o1);
+    sequence->addAnimation(a3_s_o1);
+    sequence->setLoopCount(2);
+
+    QSignalSpy a1StateChangedSpy(a1_s_o1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy seqStateChangedSpy(sequence, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    QSequentialAnimationGroup group;
+    group.addAnimation(sequence);
+
+    group.start();
+    group.pause();
+
+    // Current time = 1751
+    group.setCurrentTime(1751);
+    QCOMPARE(group.currentTime(), 1751);
+    QCOMPARE(sequence->currentTime(), 751);
+    QCOMPARE(sequence->currentLoop(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 1);
+    QCOMPARE(a3_s_o1->currentLoop(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 1);
+
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(sequence->state(), QAnimationGroup::Paused);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a3_s_o1->state(), QAnimationGroup::Paused);
+
+    QCOMPARE(a1StateChangedSpy.count(), 5);     // Running,Paused,Stopped,Running,Stopped
+    QCOMPARE(seqStateChangedSpy.count(), 2);    // Running,Paused
+
+    QVERIFY(compareStates(a1StateChangedSpy, (StateList() << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Paused
+                                              << QAbstractAnimation::Stopped
+                                              << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Stopped)));
+
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(1).at(1)),
+             QAnimationGroup::Paused);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(2).at(1)),
+             QAnimationGroup::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(3).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(4).at(1)),
+             QAnimationGroup::Stopped);
+
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).at(1)),
+             QAnimationGroup::Paused);
+
+    group.resume();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(sequence->state(), QAnimationGroup::Running);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a3_s_o1->state(), QAnimationGroup::Running);
+
+    QVERIFY(group.currentTime() >= 1751);
+    QVERIFY(sequence->currentTime() >= 751);
+    QCOMPARE(sequence->currentLoop(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 1);
+    QCOMPARE(a3_s_o1->currentLoop(), 0);
+    QVERIFY(a3_s_o1->currentTime() >= 1);
+
+    QCOMPARE(seqStateChangedSpy.count(), 3);    // Running,Paused,Running
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(2).at(1)),
+             QAnimationGroup::Running);
+
+    group.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(sequence->state(), QAnimationGroup::Paused);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a3_s_o1->state(), QAnimationGroup::Paused);
+
+    QVERIFY(group.currentTime() >= 1751);
+    QVERIFY(sequence->currentTime() >= 751);
+    QCOMPARE(sequence->currentLoop(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 1);
+    QCOMPARE(a3_s_o1->currentLoop(), 0);
+    QVERIFY(a3_s_o1->currentTime() >= 1);
+
+    QCOMPARE(seqStateChangedSpy.count(), 4);    // Running,Paused,Running,Paused
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(3).at(1)),
+             QAnimationGroup::Paused);
+
+    group.stop();
+
+    QCOMPARE(seqStateChangedSpy.count(), 5);    // Running,Paused,Running,Paused,Stopped
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(4).at(1)),
+             QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::restart()
+{
+    AnimationObject s_o1;
+
+    // sequence operating on same object/property
+    QAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QSignalSpy seqCurrentAnimChangedSpy(sequence, SIGNAL(currentAnimationChanged(QAbstractAnimation*)));
+    QSignalSpy seqStateChangedSpy(sequence, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    QVariantAnimation *anims[3];
+    QSignalSpy *animsStateChanged[3];
+
+    for (int i = 0; i < 3; i++) {
+        anims[i] = new QPropertyAnimation(&s_o1, "value");
+        anims[i]->setDuration(100);
+        animsStateChanged[i] = new QSignalSpy(anims[i], SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    }
+
+    anims[1]->setLoopCount(2);
+    sequence->addAnimation(anims[0]);
+    sequence->addAnimation(anims[1]);
+    sequence->addAnimation(anims[2]);
+    sequence->setLoopCount(2);
+
+    QSequentialAnimationGroup group;
+    group.addAnimation(sequence);
+
+    group.start();
+
+    QTest::qWait(500);
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+
+    QTest::qWait(300);
+    QTRY_COMPARE(group.state(), QAnimationGroup::Stopped);
+
+    for (int i = 0; i < 3; i++) {
+        QCOMPARE(animsStateChanged[i]->count(), 4);
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(0).at(1)),
+                 QAnimationGroup::Running);
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(1).at(1)),
+                 QAnimationGroup::Stopped);
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(2).at(1)),
+                 QAnimationGroup::Running);
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(3).at(1)),
+                 QAnimationGroup::Stopped);
+    }
+
+    QCOMPARE(seqStateChangedSpy.count(), 2);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).at(1)),
+             QAnimationGroup::Stopped);
+
+    QCOMPARE(seqCurrentAnimChangedSpy.count(), 6);
+    for(int i=0; i<seqCurrentAnimChangedSpy.count(); i++)
+            QCOMPARE(anims[i%3], qVariantValue<QAbstractAnimation*>(seqCurrentAnimChangedSpy.at(i).at(0)));
+
+    group.start();
+
+    QCOMPARE(animsStateChanged[0]->count(), 5);
+    QCOMPARE(animsStateChanged[1]->count(), 4);
+    QCOMPARE(animsStateChanged[2]->count(), 4);
+    QCOMPARE(seqStateChangedSpy.count(), 3);
+}
+
+void tst_QSequentialAnimationGroup::looping()
+{
+    AnimationObject s_o1;
+    AnimationObject s_o2;
+    AnimationObject s_o3;
+
+    // sequence operating on same object/property
+    QSequentialAnimationGroup *sequence = new QSequentialAnimationGroup();
+    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+
+    QSignalSpy a1Spy(a1_s_o1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy a2Spy(a2_s_o1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy a3Spy(a3_s_o1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy seqSpy(sequence, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    a2_s_o1->setLoopCount(2);
+    sequence->addAnimation(a1_s_o1);
+    sequence->addAnimation(a2_s_o1);
+    sequence->addAnimation(a3_s_o1);
+    sequence->setLoopCount(2);
+
+    QSequentialAnimationGroup group;
+    QSignalSpy groupSpy(&group, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    group.addAnimation(sequence);
+    group.setLoopCount(2);
+
+    group.start();
+    group.pause();
+
+    // Current time = 1750
+    group.setCurrentTime(1750);
+    QCOMPARE(group.currentTime(), 1750);
+    QCOMPARE(sequence->currentTime(), 750);
+    QCOMPARE(sequence->currentLoop(), 1);
+    QCOMPARE(a1_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 1);
+    // this animation is at the beginning because it is the current one inside sequence
+    QCOMPARE(a3_s_o1->currentLoop(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(sequence->currentAnimation(), a3_s_o1);
+
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(sequence->state(), QAnimationGroup::Paused);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a3_s_o1->state(), QAnimationGroup::Paused);
+
+    QCOMPARE(a1Spy.count(), 5);     // Running,Paused,Stopped,Running,Stopped
+    QVERIFY(compareStates(a1Spy, (StateList() << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Paused
+                                              << QAbstractAnimation::Stopped
+                                              << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Stopped)));
+
+    QCOMPARE(a2Spy.count(), 4);     // Running,Stopped,Running,Stopped
+    QVERIFY(compareStates(a3Spy, (StateList() << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Stopped
+                                              << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Paused)));
+
+    QCOMPARE(seqSpy.count(), 2);    // Running,Paused
+    QCOMPARE(groupSpy.count(), 2);  // Running,Paused
+
+    // Looping, current time = duration + 1
+    group.setCurrentTime(group.duration() + 1);
+    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(group.currentLoop(), 1);
+    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(sequence->currentLoop(), 0);
+    QCOMPARE(a1_s_o1->currentTime(), 1);
+    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoop(), 1);
+    // this animation is at the end because it was run on the previous loop
+    QCOMPARE(a3_s_o1->currentLoop(), 0);
+    QCOMPARE(a3_s_o1->currentTime(), 250);
+
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(sequence->state(), QAnimationGroup::Paused);
+    QCOMPARE(a1_s_o1->state(), QAnimationGroup::Paused);
+    QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a3_s_o1->state(), QAnimationGroup::Stopped);
+
+    QCOMPARE(a1Spy.count(), 7); // Running,Paused,Stopped,Running,Stopped,Running,Stopped
+    QCOMPARE(a2Spy.count(), 4); // Running, Stopped, Running, Stopped
+    QVERIFY(compareStates(a3Spy, (StateList() << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Stopped
+                                              << QAbstractAnimation::Running
+                                              << QAbstractAnimation::Paused
+                                              << QAbstractAnimation::Stopped)));
+    QVERIFY(compareStates(seqSpy, (StateList() << QAbstractAnimation::Running
+                                               << QAbstractAnimation::Paused
+                                               << QAbstractAnimation::Stopped
+                                               << QAbstractAnimation::Running
+                                               << QAbstractAnimation::Paused)));
+    QCOMPARE(groupSpy.count(), 2);
+}
+
+void tst_QSequentialAnimationGroup::startDelay()
+{
+    QSequentialAnimationGroup group;
+    group.addPause(250);
+    group.addPause(125);
+    QCOMPARE(group.totalDuration(), 375);
+
+    QEventLoop loop;
+    QObject::connect(&group, SIGNAL(finished()), &loop, SLOT(quit()));
+
+    QTime time;
+    time.start();
+    group.start();
+    loop.exec();
+
+    QVERIFY(time.elapsed() >= 375);
+    QVERIFY(time.elapsed() < 1000);
+}
+
+void tst_QSequentialAnimationGroup::clearGroup()
+{
+    QSequentialAnimationGroup group;
+
+    for (int i = 0; i < 10; ++i) {
+        QSequentialAnimationGroup *subGroup = new QSequentialAnimationGroup(&group);
+        group.addPause(100);
+        subGroup->addPause(10);
+    }
+
+    QCOMPARE(group.animationCount(), 20);
+
+    int count = group.animationCount();
+    QPointer<QAbstractAnimation> *children = new QPointer<QAbstractAnimation>[count];
+    for (int i = 0; i < count; ++i) {
+        QVERIFY(group.animationAt(i) != 0);
+        children[i] = group.animationAt(i);
+    }
+
+    group.clearAnimations();
+    QCOMPARE(group.animationCount(), 0);
+    QCOMPARE(group.currentTime(), 0);
+    for (int i = 0; i < count; ++i)
+        QCOMPARE(children[i], QPointer<QAbstractAnimation>());
+
+    delete[] children;
+}
+
+void tst_QSequentialAnimationGroup::groupWithZeroDurationAnimations()
+{
+    QObject o;
+    QObject o2;
+
+    o.setProperty("myProperty", 42);
+    o.setProperty("myOtherProperty", 13);
+    o2.setProperty("myProperty", 42);
+    o2.setProperty("myOtherProperty", 13);
+
+    QSequentialAnimationGroup group;
+
+    QVariantAnimation *a1 = new QPropertyAnimation(&o, "myProperty");
+    a1->setDuration(0);
+    a1->setEndValue(43);
+    group.addAnimation(a1);
+
+    //this should just run fine and change nothing
+    group.setCurrentTime(0);
+    QCOMPARE(group.currentAnimation(), a1);
+
+    QVariantAnimation *a2 = new QPropertyAnimation(&o2, "myOtherProperty");
+    a2->setDuration(500);
+    a2->setEndValue(31);
+    group.addAnimation(a2);
+
+    QVariantAnimation *a3 = new QPropertyAnimation(&o, "myProperty");
+    a3->setDuration(0);
+    a3->setEndValue(44);
+    group.addAnimation(a3);
+
+    QVariantAnimation *a4 = new QPropertyAnimation(&o, "myOtherProperty");
+    a4->setDuration(250);
+    a4->setEndValue(75);
+    group.addAnimation(a4);
+
+    QVariantAnimation *a5 = new QPropertyAnimation(&o2, "myProperty");
+    a5->setDuration(0);
+    a5->setEndValue(12);
+    group.addAnimation(a5);
+
+    QCOMPARE(o.property("myProperty").toInt(), 42);
+    QCOMPARE(o.property("myOtherProperty").toInt(), 13);
+    QCOMPARE(o2.property("myProperty").toInt(), 42);
+    QCOMPARE(o2.property("myOtherProperty").toInt(), 13);
+
+
+    group.start();
+
+    QCOMPARE(o.property("myProperty").toInt(), 43);
+    QCOMPARE(o.property("myOtherProperty").toInt(), 13);
+    QCOMPARE(o2.property("myProperty").toInt(), 42);
+    QCOMPARE(o2.property("myOtherProperty").toInt(), 13);
+
+    QTest::qWait(50);
+
+    int o2val = o2.property("myOtherProperty").toInt();
+    QVERIFY(o2val > 13);
+    QVERIFY(o2val < 31);
+    QCOMPARE(o.property("myProperty").toInt(), 43);
+    QCOMPARE(o.property("myOtherProperty").toInt(), 13);
+
+    QTest::qWait(500);
+
+    QCOMPARE(o.property("myProperty").toInt(), 44);
+    QCOMPARE(o2.property("myProperty").toInt(), 42);
+    QCOMPARE(o2.property("myOtherProperty").toInt(), 31);
+    QCOMPARE(a1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a3->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a4->state(), QAnimationGroup::Running);
+    QCOMPARE(a5->state(), QAnimationGroup::Stopped);
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QTest::qWait(500);
+
+    QTRY_COMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(o.property("myProperty").toInt(), 44);
+    QCOMPARE(o.property("myOtherProperty").toInt(), 75);
+    QCOMPARE(o2.property("myProperty").toInt(), 12);
+    QCOMPARE(o2.property("myOtherProperty").toInt(), 31);
+    QCOMPARE(a1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a2->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a3->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a4->state(), QAnimationGroup::Stopped);
+    QCOMPARE(a5->state(), QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::propagateGroupUpdateToChildren()
+{
+    // this test verifies if group state changes are updating its children correctly
+    QSequentialAnimationGroup group;
+
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation anim1(&o, "ole");
+    anim1.setEndValue(43);
+    anim1.setDuration(100);
+    QVERIFY(!anim1.currentValue().isValid());
+    QCOMPARE(anim1.currentValue().toInt(), 0);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(200);
+
+    QVERIFY(anim2.currentValue().isValid());
+    QCOMPARE(anim2.currentValue().toInt(), 0);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+
+    group.start();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Paused);
+    QCOMPARE(anim1.state(), QAnimationGroup::Paused);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::updateChildrenWithRunningGroup()
+{
+    // assert that its possible to modify a child's state directly while their group is running
+    QSequentialAnimationGroup group;
+
+    TestAnimation anim;
+    anim.setStartValue(0);
+    anim.setEndValue(100);
+    anim.setDuration(200);
+
+    QSignalSpy groupStateChangedSpy(&group, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy childStateChangedSpy(&anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    QCOMPARE(groupStateChangedSpy.count(), 0);
+    QCOMPARE(childStateChangedSpy.count(), 0);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim);
+
+    group.start();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim.state(), QAnimationGroup::Running);
+
+    QCOMPARE(groupStateChangedSpy.count(), 1);
+    QCOMPARE(childStateChangedSpy.count(), 1);
+
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+
+    // starting directly a running child will not have any effect
+    anim.start();
+
+    QCOMPARE(groupStateChangedSpy.count(), 1);
+    QCOMPARE(childStateChangedSpy.count(), 1);
+
+    anim.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim.state(), QAnimationGroup::Paused);
+
+    // in the animation stops directly, the group will still be running
+    anim.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::deleteChildrenWithRunningGroup()
+{
+    // test if children can be activated when their group is stopped
+    QSequentialAnimationGroup group;
+
+    QVariantAnimation *anim1 = new TestAnimation;
+    anim1->setStartValue(0);
+    anim1->setEndValue(100);
+    anim1->setDuration(200);
+    group.addAnimation(anim1);
+
+    QCOMPARE(group.duration(), anim1->duration());
+
+    group.start();
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1->state(), QAnimationGroup::Running);
+
+    QTest::qWait(50);
+    QVERIFY(group.currentTime() > 0);
+
+    delete anim1;
+    QCOMPARE(group.animationCount(), 0);
+    QCOMPARE(group.duration(), 0);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(group.currentTime(), 0); //that's the invariant
+}
+
+void tst_QSequentialAnimationGroup::startChildrenWithStoppedGroup()
+{
+    // test if children can be activated when their group is stopped
+    QSequentialAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(200);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(200);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+
+    group.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    anim1.start();
+    anim2.start();
+    anim2.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+}
+
+void tst_QSequentialAnimationGroup::stopGroupWithRunningChild()
+{
+    // children that started independently will not be affected by a group stop
+    QSequentialAnimationGroup group;
+
+    TestAnimation anim1;
+    anim1.setStartValue(0);
+    anim1.setEndValue(100);
+    anim1.setDuration(200);
+
+    TestAnimation anim2;
+    anim2.setStartValue(0);
+    anim2.setEndValue(100);
+    anim2.setDuration(200);
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(&anim1);
+    group.addAnimation(&anim2);
+
+    anim1.start();
+    anim2.start();
+    anim2.pause();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+
+    group.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Running);
+    QCOMPARE(anim2.state(), QAnimationGroup::Paused);
+
+    anim1.stop();
+    anim2.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::startGroupWithRunningChild()
+{
+    // as the group has precedence over its children, starting a group will restart all the children
+    QSequentialAnimationGroup group;
+
+    TestAnimation *anim1 = new TestAnimation();
+    anim1->setStartValue(0);
+    anim1->setEndValue(100);
+    anim1->setDuration(200);
+
+    TestAnimation *anim2 = new TestAnimation();
+    anim2->setStartValue(0);
+    anim2->setEndValue(100);
+    anim2->setDuration(200);
+
+    QSignalSpy stateChangedSpy1(anim1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy stateChangedSpy2(anim2, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    QCOMPARE(stateChangedSpy1.count(), 0);
+    QCOMPARE(stateChangedSpy2.count(), 0);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2->state(), QAnimationGroup::Stopped);
+
+    group.addAnimation(anim1);
+    group.addAnimation(anim2);
+
+    anim1->start();
+    anim2->start();
+    anim2->pause();
+
+    QVERIFY(compareStates(stateChangedSpy1, (StateList() << QAbstractAnimation::Running)));
+
+    QVERIFY(compareStates(stateChangedSpy2, (StateList() << QAbstractAnimation::Running
+                                                         << QAbstractAnimation::Paused)));
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1->state(), QAnimationGroup::Running);
+    QCOMPARE(anim2->state(), QAnimationGroup::Paused);
+
+    group.start();
+
+    QVERIFY(compareStates(stateChangedSpy1, (StateList() << QAbstractAnimation::Running
+                                                         << QAbstractAnimation::Stopped
+                                                         << QAbstractAnimation::Running)));
+    QVERIFY(compareStates(stateChangedSpy2, (StateList() << QAbstractAnimation::Running
+                                                         << QAbstractAnimation::Paused)));
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1->state(), QAnimationGroup::Running);
+    QCOMPARE(anim2->state(), QAnimationGroup::Paused);
+
+    QTest::qWait(300);
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2->state(), QAnimationGroup::Running);
+
+    QCOMPARE(stateChangedSpy2.count(), 4);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).at(1)),
+             QAnimationGroup::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).at(1)),
+             QAnimationGroup::Running);
+
+    group.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2->state(), QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::zeroDurationAnimation()
+{
+    QSequentialAnimationGroup group;
+
+    TestAnimation *anim1 = new TestAnimation();
+    anim1->setStartValue(0);
+    anim1->setEndValue(100);
+    anim1->setDuration(0);
+
+    TestAnimation *anim2 = new TestAnimation();
+    anim2->setStartValue(0);
+    anim2->setEndValue(100);
+    anim2->setDuration(100);
+
+    AnimationObject o1;
+    QPropertyAnimation *anim3 = new QPropertyAnimation(&o1, "value");
+    anim3->setEndValue(100);
+    anim3->setDuration(0);
+
+    QSignalSpy stateChangedSpy(anim1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    group.addAnimation(anim1);
+    group.addAnimation(anim2);
+    group.addAnimation(anim3);
+    group.setLoopCount(2);
+    group.start();
+
+    QCOMPARE(stateChangedSpy.count(), 2);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).at(1)),
+             QAnimationGroup::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).at(1)),
+             QAnimationGroup::Stopped);
+
+    QCOMPARE(anim1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2->state(), QAnimationGroup::Running);
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+
+    //now let's try to seek to the next loop
+    group.setCurrentTime(group.duration() + 1);
+    QCOMPARE(anim1->state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim2->state(), QAnimationGroup::Running);
+    QCOMPARE(anim3->state(), QAnimationGroup::Stopped);
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(o1.value(), 100); //anim3 should have been run
+}
+
+void tst_QSequentialAnimationGroup::stopUncontrolledAnimations()
+{
+    QSequentialAnimationGroup group;
+
+    AnimationObject o1;
+    UncontrolledAnimation notTimeDriven(&o1, "value");
+    QCOMPARE(notTimeDriven.totalDuration(), -1);
+
+    TestAnimation loopsForever;
+    loopsForever.setStartValue(0);
+    loopsForever.setEndValue(100);
+    loopsForever.setDuration(100);
+    loopsForever.setLoopCount(-1);
+
+    group.addAnimation(&notTimeDriven);
+    group.addAnimation(&loopsForever);
+
+    group.start();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
+    QCOMPARE(loopsForever.state(), QAnimationGroup::Stopped);
+
+    notTimeDriven.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever.state(), QAnimationGroup::Running);
+
+    loopsForever.stop();
+
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
+    QCOMPARE(loopsForever.state(), QAnimationGroup::Stopped);
+}
+
+void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
+{
+    AnimationObject o1;
+
+    //1st case:
+    //first we test a group with one uncontrolled animation
+    QSequentialAnimationGroup group;
+    UncontrolledAnimation notTimeDriven(&o1, "value", &group);
+    QSignalSpy spy(&group, SIGNAL(finished()));
+
+    group.start();
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
+    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(notTimeDriven.currentTime(), 0);
+
+    QTest::qWait(300); //wait for the end of notTimeDriven
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
+    const int actualDuration = notTimeDriven.currentTime();
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(group.currentTime(), actualDuration);
+    QCOMPARE(spy.count(), 1);
+
+    //2nd case:
+    // lets make sure the seeking will work again
+    spy.clear();
+    QPropertyAnimation anim(&group);
+    QSignalSpy animStateChangedSpy(&anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    group.setCurrentTime(300);
+    QCOMPARE(group.state(), QAnimationGroup::Stopped);
+    QCOMPARE(notTimeDriven.currentTime(), actualDuration);
+    QCOMPARE(group.currentAnimation(), &anim);
+
+    //3rd case:
+    //now let's add a perfectly defined animation at the end
+    QCOMPARE(animStateChangedSpy.count(), 0);
+    group.start();
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
+    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(notTimeDriven.currentTime(), 0);
+
+    QCOMPARE(animStateChangedSpy.count(), 0);
+
+    QTest::qWait(300); //wait for the end of notTimeDriven
+    QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
+    QCOMPARE(group.state(), QAnimationGroup::Running);
+    QCOMPARE(anim.state(), QAnimationGroup::Running);
+    QCOMPARE(group.currentAnimation(), &anim);
+    QCOMPARE(animStateChangedSpy.count(), 1);
+    QTest::qWait(300); //wait for the end of anim
+
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim.currentTime(), anim.duration());
+
+    //we should simply be at the end
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(animStateChangedSpy.count(), 2);
+    QCOMPARE(group.currentTime(), notTimeDriven.currentTime() + anim.currentTime());
+}
+
+void tst_QSequentialAnimationGroup::addRemoveAnimation()
+{
+    //this test is specific to the sequential animation group
+    QSequentialAnimationGroup group;
+
+    QCOMPARE(group.duration(), 0);
+    QCOMPARE(group.currentTime(), 0);
+    QVariantAnimation *anim1 = new QPropertyAnimation;
+    group.addAnimation(anim1);
+    QCOMPARE(group.duration(), 250);
+    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentAnimation(), anim1);
+
+    //let's append an animation
+    QVariantAnimation *anim2 = new QPropertyAnimation;
+    group.addAnimation(anim2);
+    QCOMPARE(group.duration(), 500);
+    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentAnimation(), anim1);
+
+    //let's prepend an animation
+    QVariantAnimation *anim0 = new QPropertyAnimation;
+    group.insertAnimationAt(0, anim0);
+    QCOMPARE(group.duration(), 750);
+    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentAnimation(), anim0); //anim0 has become the new currentAnimation
+
+    group.setCurrentTime(300); //anim0 | anim1 | anim2
+    QCOMPARE(group.currentTime(), 300);
+    QCOMPARE(group.currentAnimation(), anim1);
+    QCOMPARE(anim1->currentTime(), 50);
+
+    group.removeAnimation(anim0); //anim1 | anim2
+    QCOMPARE(group.currentTime(), 50);
+    QCOMPARE(group.currentAnimation(), anim1);
+    QCOMPARE(anim1->currentTime(), 50);
+
+    group.setCurrentTime(0);
+    group.insertAnimationAt(0, anim0); //anim0 | anim1 | anim2
+    group.setCurrentTime(300);
+    QCOMPARE(group.currentTime(), 300);
+    QCOMPARE(group.currentAnimation(), anim1);
+    QCOMPARE(anim1->currentTime(), 50);
+
+    group.removeAnimation(anim1); //anim0 | anim2
+    QCOMPARE(group.currentTime(), 250);
+    QCOMPARE(group.currentAnimation(), anim2);
+    QCOMPARE(anim0->currentTime(), 250);
+}
+
+void tst_QSequentialAnimationGroup::currentAnimation()
+{
+    QSequentialAnimationGroup group;
+    QVERIFY(group.currentAnimation() == 0);
+
+    QPropertyAnimation anim;
+    anim.setDuration(0);
+    group.addAnimation(&anim);
+    QCOMPARE(group.currentAnimation(), &anim);
+}
+
+void tst_QSequentialAnimationGroup::currentAnimationWithZeroDuration()
+{
+    QSequentialAnimationGroup group;
+    QVERIFY(group.currentAnimation() == 0);
+
+    QPropertyAnimation zero1;
+    zero1.setDuration(0);
+    QPropertyAnimation zero2;
+    zero2.setDuration(0);
+
+    QPropertyAnimation anim;
+
+    QPropertyAnimation zero3;
+    zero3.setDuration(0);
+    QPropertyAnimation zero4;
+    zero4.setDuration(0);
+
+
+    group.addAnimation(&zero1);
+    group.addAnimation(&zero2);
+    group.addAnimation(&anim);
+    group.addAnimation(&zero3);
+    group.addAnimation(&zero4);
+
+    QCOMPARE(group.currentAnimation(), &zero1);
+
+    group.setCurrentTime(0);
+    QCOMPARE(group.currentAnimation(), &anim);
+
+    group.setCurrentTime(group.duration());
+    QCOMPARE(group.currentAnimation(), &zero4);
+
+    group.setDirection(QAbstractAnimation::Backward);
+
+    group.setCurrentTime(0);
+    QCOMPARE(group.currentAnimation(), &zero1);
+
+    group.setCurrentTime(group.duration());
+    QCOMPARE(group.currentAnimation(), &anim);
+}
+
+void tst_QSequentialAnimationGroup::insertAnimation()
+{
+    QSequentialAnimationGroup group;
+    group.setLoopCount(2);
+    QPropertyAnimation *anim = new QPropertyAnimation(&group);
+    QCOMPARE(group.duration(), anim->duration());
+    group.setCurrentTime(300);
+    QCOMPARE(group.currentLoop(), 1);
+
+    //this will crash if the sequential group calls duration on the created animation
+    new QPropertyAnimation(&group);
+}
+
+
+class SequentialAnimationGroup : public QSequentialAnimationGroup
+{
+    Q_OBJECT
+public slots:
+    void clearAnimations()
+    {
+        QSequentialAnimationGroup::clearAnimations();
+    }
+
+    void refill()
+    {
+        stop();
+        clearAnimations();
+        new QPropertyAnimation(this);
+        start();
+    }
+
+};
+
+
+void tst_QSequentialAnimationGroup::clearAnimations()
+{
+    SequentialAnimationGroup group;
+    QPointer<QAbstractAnimation> anim1 = new QPropertyAnimation(&group);
+    group.connect(anim1, SIGNAL(finished()), SLOT(clearAnimations()));
+    new QPropertyAnimation(&group);
+    QCOMPARE(group.animationCount(), 2);
+
+    group.start();
+    QTest::qWait(anim1->duration() + 100);
+    QCOMPARE(group.animationCount(), 0);
+    QCOMPARE(group.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(group.currentTime(), 0);
+
+    anim1 = new QPropertyAnimation(&group);
+    group.connect(anim1, SIGNAL(finished()), SLOT(refill()));
+    group.start();
+    QTest::qWait(anim1->duration() + 100);
+    QVERIFY(anim1 == 0); //anim1 should have been deleted
+    QCOMPARE(group.state(), QAbstractAnimation::Running);
+}
+
+QTEST_MAIN(tst_QSequentialAnimationGroup)
+#include "tst_qsequentialanimationgroup.moc"
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/qstate/qstate.pro b/tests/auto/qstate/qstate.pro
new file mode 100644
index 0000000..9131fa8
--- /dev/null
+++ b/tests/auto/qstate/qstate.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT = core
+SOURCES  += tst_qstate.cpp
+
+
diff --git a/tests/auto/qstate/tst_qstate.cpp b/tests/auto/qstate/tst_qstate.cpp
new file mode 100644
index 0000000..75b1905
--- /dev/null
+++ b/tests/auto/qstate/tst_qstate.cpp
@@ -0,0 +1,340 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+
+#include "qstate.h"
+#include "qstatemachine.h"
+#include "qsignaltransition.h"
+
+// Will try to wait for the condition while allowing event processing
+#define QTRY_COMPARE(__expr, __expected) \
+    do { \
+        const int __step = 50; \
+        const int __timeout = 5000; \
+        if ((__expr) != (__expected)) { \
+            QTest::qWait(0); \
+        } \
+        for (int __i = 0; __i < __timeout && ((__expr) != (__expected)); __i+=__step) { \
+            QTest::qWait(__step); \
+        } \
+        QCOMPARE(__expr, __expected); \
+    } while(0)
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QState : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QState();
+    virtual ~tst_QState();
+
+private slots:
+#if 0
+    void test();
+#endif
+    void assignProperty();
+    void assignPropertyTwice();
+    void historyInitialState();
+
+private:
+    bool functionCalled;
+};
+
+tst_QState::tst_QState() : functionCalled(false)
+{
+}
+
+tst_QState::~tst_QState()
+{
+}
+
+#if 0
+void tst_QState::test()
+{
+    QStateMachine machine;
+    QState *s1 = new QState(machine.rootState());
+
+    QCOMPARE(s1->machine(), &machine);
+    QCOMPARE(s1->parentState(), machine.rootState());
+    QCOMPARE(s1->initialState(), (QState*)0);
+    QVERIFY(s1->childStates().isEmpty());
+    QVERIFY(s1->transitions().isEmpty());
+
+    QCOMPARE(s1->isFinal(), false);
+    s1->setFinal(true);
+    QCOMPARE(s1->isFinal(), true);
+    s1->setFinal(false);
+    QCOMPARE(s1->isFinal(), false);
+
+    QCOMPARE(s1->isParallel(), false);
+    s1->setParallel(true);
+    QCOMPARE(s1->isParallel(), true);
+    s1->setParallel(false);
+    QCOMPARE(s1->isParallel(), false);
+
+    QCOMPARE(s1->isAtomic(), true);
+    QCOMPARE(s1->isCompound(), false);
+    QCOMPARE(s1->isComplex(), false);
+
+    QState *s11 = new QState(s1);
+    QCOMPARE(s11->parentState(), s1);
+    QCOMPARE(s11->isAtomic(), true);
+    QCOMPARE(s11->isCompound(), false);
+    QCOMPARE(s11->isComplex(), false);
+    QCOMPARE(s11->machine(), s1->machine());
+    QVERIFY(s11->isDescendantOf(s1));
+
+    QCOMPARE(s1->initialState(), (QState*)0);
+    QCOMPARE(s1->childStates().size(), 1);
+    QCOMPARE(s1->childStates().at(0), s11);
+
+    QCOMPARE(s1->isAtomic(), false);
+    QCOMPARE(s1->isCompound(), true);
+    QCOMPARE(s1->isComplex(), true);
+
+    s1->setParallel(true);
+    QCOMPARE(s1->isAtomic(), false);
+    QCOMPARE(s1->isCompound(), false);
+    QCOMPARE(s1->isComplex(), true);
+
+    QState *s12 = new QState(s1);
+    QCOMPARE(s12->parentState(), s1);
+    QCOMPARE(s12->isAtomic(), true);
+    QCOMPARE(s12->isCompound(), false);
+    QCOMPARE(s12->isComplex(), false);
+    QCOMPARE(s12->machine(), s1->machine());
+    QVERIFY(s12->isDescendantOf(s1));
+    QVERIFY(!s12->isDescendantOf(s11));
+
+    QCOMPARE(s1->initialState(), (QState*)0);
+    QCOMPARE(s1->childStates().size(), 2);
+    QCOMPARE(s1->childStates().at(0), s11);
+    QCOMPARE(s1->childStates().at(1), s12);
+
+    QCOMPARE(s1->isAtomic(), false);
+    QCOMPARE(s1->isCompound(), false);
+    QCOMPARE(s1->isComplex(), true);
+
+    s1->setParallel(false);
+    QCOMPARE(s1->isAtomic(), false);
+    QCOMPARE(s1->isCompound(), true);
+    QCOMPARE(s1->isComplex(), true);
+
+    s1->setInitialState(s11);
+    QCOMPARE(s1->initialState(), s11);
+
+    s1->setInitialState(0);
+    QCOMPARE(s1->initialState(), (QState*)0);
+
+    s1->setInitialState(s12);
+    QCOMPARE(s1->initialState(), s12);
+
+    QState *s13 = new QState();
+    s1->setInitialState(s13);
+    QCOMPARE(s13->parentState(), s1);
+    QCOMPARE(s1->childStates().size(), 3);
+    QCOMPARE(s1->childStates().at(0), s11);
+    QCOMPARE(s1->childStates().at(1), s12);
+    QCOMPARE(s1->childStates().at(2), s13);
+    QVERIFY(s13->isDescendantOf(s1));
+
+    QVERIFY(s12->childStates().isEmpty());
+
+    QState *s121 = new QState(s12);
+    QCOMPARE(s121->parentState(), s12);
+    QCOMPARE(s121->isAtomic(), true);
+    QCOMPARE(s121->isCompound(), false);
+    QCOMPARE(s121->isComplex(), false);
+    QCOMPARE(s121->machine(), s12->machine());
+    QVERIFY(s121->isDescendantOf(s12));
+    QVERIFY(s121->isDescendantOf(s1));
+    QVERIFY(!s121->isDescendantOf(s11));
+
+    QCOMPARE(s12->childStates().size(), 1);
+    QCOMPARE(s12->childStates().at(0), (QState*)s121);
+
+    QCOMPARE(s1->childStates().size(), 3);
+    QCOMPARE(s1->childStates().at(0), s11);
+    QCOMPARE(s1->childStates().at(1), s12);
+    QCOMPARE(s1->childStates().at(2), s13);
+
+    s11->addTransition(s12);
+    QCOMPARE(s11->transitions().size(), 1);
+    QCOMPARE(s11->transitions().at(0)->sourceState(), s11);
+    QCOMPARE(s11->transitions().at(0)->targetStates().size(), 1);
+    QCOMPARE(s11->transitions().at(0)->targetStates().at(0), s12);
+    QCOMPARE(s11->transitions().at(0)->eventType(), QEvent::None);
+
+    QState *s14 = new QState();
+    s12->addTransition(QList<QState*>() << s13 << s14);
+    QCOMPARE(s12->transitions().size(), 1);
+    QCOMPARE(s12->transitions().at(0)->sourceState(), s12);
+    QCOMPARE(s12->transitions().at(0)->targetStates().size(), 2);
+    QCOMPARE(s12->transitions().at(0)->targetStates().at(0), s13);
+    QCOMPARE(s12->transitions().at(0)->targetStates().at(1), s14);
+    QCOMPARE(s12->transitions().at(0)->eventType(), QEvent::None);
+
+    s13->addTransition(this, SIGNAL(destroyed()), s14);
+    QCOMPARE(s13->transitions().size(), 1);
+    QCOMPARE(s13->transitions().at(0)->sourceState(), s13);
+    QCOMPARE(s13->transitions().at(0)->targetStates().size(), 1);
+    QCOMPARE(s13->transitions().at(0)->targetStates().at(0), s14);
+    QCOMPARE(s13->transitions().at(0)->eventType(), QEvent::Signal);
+    QVERIFY(qobject_cast<QSignalTransition*>(s13->transitions().at(0)) != 0);
+
+    delete s13->transitions().at(0);
+    QCOMPARE(s13->transitions().size(), 0);
+
+    s12->addTransition(this, SIGNAL(destroyed()), s11);
+    QCOMPARE(s12->transitions().size(), 2);
+}
+#endif
+
+class TestClass: public QObject
+{
+    Q_OBJECT
+public:
+    TestClass() : called(false) {}
+    bool called;
+
+public slots:
+    void slot() { called = true; }
+
+    
+};
+
+void tst_QState::assignProperty()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("fooBar", 10);
+
+    QState *s1 = new QState(machine.rootState());
+    s1->assignProperty(object, "fooBar", 20);
+    
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("fooBar").toInt(), 20);
+}
+
+void tst_QState::assignPropertyTwice()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("fooBar", 10);
+
+    QState *s1 = new QState(machine.rootState());
+    s1->assignProperty(object, "fooBar", 20);
+    s1->assignProperty(object, "fooBar", 30);
+    
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("fooBar").toInt(), 30);
+}
+
+class EventTestTransition: public QAbstractTransition
+{
+public:
+    EventTestTransition(QEvent::Type type, QState *targetState) 
+        : QAbstractTransition(QList<QAbstractState*>() << targetState), m_type(type)
+    {        
+    }
+
+protected:
+    bool eventTest(QEvent *e)
+    {
+        return e->type() == m_type;
+    }
+
+    void onTransition(QEvent *) {}
+
+private:
+    QEvent::Type m_type;
+    
+};
+
+void tst_QState::historyInitialState() 
+{
+    QStateMachine machine;
+
+    QState *s1 = new QState(machine.rootState());
+    
+    QState *s2 = new QState(machine.rootState());
+    QHistoryState *h1 = new QHistoryState(s2);
+    
+    s2->setInitialState(h1);
+
+    QState *s3 = new QState(s2);
+    h1->setDefaultState(s3);
+
+    QState *s4 = new QState(s2);
+
+    s1->addTransition(new EventTestTransition(QEvent::User, s2));
+    s2->addTransition(new EventTestTransition(QEvent::User, s1));
+    s3->addTransition(new EventTestTransition(QEvent::Type(QEvent::User+1), s4));
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s1));
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s3));
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s1));
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s3));
+
+    machine.postEvent(new QEvent(QEvent::Type(QEvent::User+1)));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s4));
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s1));
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s4));
+}
+
+
+QTEST_MAIN(tst_QState)
+#include "tst_qstate.moc"
diff --git a/tests/auto/qstatemachine/qstatemachine.pro b/tests/auto/qstatemachine/qstatemachine.pro
new file mode 100644
index 0000000..e5b32b5
--- /dev/null
+++ b/tests/auto/qstatemachine/qstatemachine.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+QT = core gui
+SOURCES  += tst_qstatemachine.cpp
+
diff --git a/tests/auto/qstatemachine/tst_qstatemachine.cpp b/tests/auto/qstatemachine/tst_qstatemachine.cpp
new file mode 100644
index 0000000..768a683
--- /dev/null
+++ b/tests/auto/qstatemachine/tst_qstatemachine.cpp
@@ -0,0 +1,3730 @@
+/****************************************************************************
+**
+** 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 <QtCore/QCoreApplication>
+#include <QtGui/QPushButton>
+
+#include "qstatemachine.h"
+#include "qstate.h"
+#include "qhistorystate.h"
+#include "qkeyeventtransition.h"
+#include "qmouseeventtransition.h"
+#include "private/qstate_p.h"
+#include "private/qstatemachine_p.h"
+
+// Will try to wait for the condition while allowing event processing
+#define QTRY_COMPARE(__expr, __expected) \
+    do { \
+        const int __step = 50; \
+        const int __timeout = 5000; \
+        if ((__expr) != (__expected)) { \
+            QTest::qWait(0); \
+        } \
+        for (int __i = 0; __i < __timeout && ((__expr) != (__expected)); __i+=__step) { \
+            QTest::qWait(__step); \
+        } \
+        QCOMPARE(__expr, __expected); \
+    } while(0)
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+static int globalTick;
+
+// Run exec for a maximum of TIMEOUT msecs
+#define QCOREAPPLICATION_EXEC(TIMEOUT) \
+{ \
+    QTimer timer; \
+    timer.setSingleShot(true); \
+    timer.setInterval(TIMEOUT); \
+    timer.start(); \
+    connect(&timer, SIGNAL(timeout()), QCoreApplication::instance(), SLOT(quit())); \
+    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
+public:
+    tst_QStateMachine();
+    virtual ~tst_QStateMachine();
+
+private slots:
+    void init();
+    void cleanup();
+
+    void rootState();
+    void addAndRemoveState();
+    void stateEntryAndExit();
+    void assignProperty();
+    void assignPropertyWithAnimation();
+    void postEvent();
+    void stateFinished();
+    void parallelStates();
+    void allSourceToTargetConfigurations();
+    void signalTransitions();
+    void eventTransitions();
+    void historyStates();
+    void startAndStop();
+    void targetStateWithNoParent();
+    void targetStateDeleted();
+    void transitionToRootState();
+    void transitionEntersParent();
+    
+    void defaultErrorState();
+    void customGlobalErrorState();
+    void customLocalErrorStateInBrokenState();
+    void customLocalErrorStateInOtherState();
+    void customLocalErrorStateInParentOfBrokenState();
+    void customLocalErrorStateOverridesParent();
+    void errorStateHasChildren();
+    void errorStateHasErrors();
+    void errorStateIsRootState();
+    void errorStateEntersParentFirst();
+    void customErrorStateIsNull();
+    void clearError();
+    void historyStateHasNowhereToGo();
+    void historyStateAsInitialState();
+    void brokenStateIsNeverEntered();
+    void customErrorStateNotInGraph();
+    void transitionToStateNotInGraph();
+    void restoreProperties();
+    
+    void defaultGlobalRestorePolicy();
+    void globalRestorePolicySetToRestore();
+    void globalRestorePolicySetToDoNotRestore();
+    
+    //void restorePolicyNotInherited();
+    //void mixedRestoreProperties();
+    //void setRestorePolicyToDoNotRestore();    
+    //void setGlobalRestorePolicyToGlobalRestore();
+    //void restorePolicyOnChildState();
+
+    void transitionWithParent();
+    void transitionsFromParallelStateWithNoChildren();
+    void parallelStateTransition();
+    void parallelStateAssignmentsDone();
+    void nestedRestoreProperties();
+    void nestedRestoreProperties2();
+
+    void simpleAnimation();
+    void twoAnimations();
+    void twoAnimatedTransitions();
+    void playAnimationTwice();
+    void nestedTargetStateForAnimation();
+    void animatedGlobalRestoreProperty();
+    void specificTargetValueOfAnimation();
+
+    void addDefaultAnimation();
+    void addDefaultAnimationWithUnusedAnimation();
+    void removeDefaultAnimation();
+    void overrideDefaultAnimationWithSpecific();
+
+//    void addDefaultAnimationForSource();
+//    void addDefaultAnimationForTarget();
+//    void removeDefaultAnimationForSource();
+//    void removeDefaultAnimationForTarget();
+//    void overrideDefaultAnimationWithSource();
+//    void overrideDefaultAnimationWithTarget();    
+//    void overrideDefaultSourceAnimationWithSpecific();
+//    void overrideDefaultTargetAnimationWithSpecific();
+//    void overrideDefaultTargetAnimationWithSource();
+};
+
+tst_QStateMachine::tst_QStateMachine()
+{
+}
+
+tst_QStateMachine::~tst_QStateMachine()
+{
+}
+
+class TestState : public QState
+{
+public:
+    enum Event {
+        Entry,
+        Exit
+    };
+    TestState(QState *parent)
+        : QState(parent) {}
+    QList<QPair<int, Event> > events;
+protected:
+    virtual void onEntry(QEvent *) {
+        events.append(qMakePair(globalTick++, Entry));
+    }
+    virtual void onExit(QEvent *) {
+        events.append(qMakePair(globalTick++, Exit));
+    }
+};
+
+class TestTransition : public QAbstractTransition
+{
+public:
+    TestTransition(QAbstractState *target)
+        : QAbstractTransition(QList<QAbstractState*>() << target) {}
+    QList<int> triggers;
+protected:
+    virtual bool eventTest(QEvent *) {
+        return true;
+    }
+    virtual void onTransition(QEvent *) {
+        triggers.append(globalTick++);
+    }
+};
+
+void tst_QStateMachine::init()
+{
+}
+
+void tst_QStateMachine::cleanup()
+{
+}
+
+class EventTransition : public QAbstractTransition
+{
+public:
+    EventTransition(QEvent::Type type, QAbstractState *target, QState *parent = 0)
+        : QAbstractTransition(QList<QAbstractState*>() << target, parent), m_type(type) {}
+protected:
+    virtual bool eventTest(QEvent *e) {
+        return (e->type() == m_type);
+    }
+    virtual void onTransition(QEvent *) {}
+private:
+    QEvent::Type m_type;
+};
+
+void tst_QStateMachine::transitionToRootState()
+{
+    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();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(initialState));
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(initialState));
+}
+
+void tst_QStateMachine::transitionEntersParent()
+{
+    QStateMachine machine;
+
+    QObject *entryController = new QObject(&machine);
+    entryController->setObjectName("entryController");
+    entryController->setProperty("greatGrandParentEntered", false);
+    entryController->setProperty("grandParentEntered", false);
+    entryController->setProperty("parentEntered", false);
+    entryController->setProperty("stateEntered", false);
+
+    QState *greatGrandParent = new QState();
+    greatGrandParent->setObjectName("grandParent");
+    greatGrandParent->assignProperty(entryController, "greatGrandParentEntered", true);
+    machine.addState(greatGrandParent);
+    machine.setInitialState(greatGrandParent);
+
+    QState *grandParent = new QState(greatGrandParent);
+    grandParent->setObjectName("grandParent");
+    grandParent->assignProperty(entryController, "grandParentEntered", true);
+
+    QState *parent = new QState(grandParent);
+    parent->setObjectName("parent");
+    parent->assignProperty(entryController, "parentEntered", true);
+
+    QState *state = new QState(parent);
+    state->setObjectName("state");
+    state->assignProperty(entryController, "stateEntered", true);
+
+    QState *initialStateOfGreatGrandParent = new QState(greatGrandParent);
+    initialStateOfGreatGrandParent->setObjectName("initialStateOfGreatGrandParent");
+    greatGrandParent->setInitialState(initialStateOfGreatGrandParent);
+
+    initialStateOfGreatGrandParent->addTransition(new EventTransition(QEvent::User, state));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(entryController->property("greatGrandParentEntered").toBool(), true);
+    QCOMPARE(entryController->property("grandParentEntered").toBool(), false);
+    QCOMPARE(entryController->property("parentEntered").toBool(), false);
+    QCOMPARE(entryController->property("stateEntered").toBool(), false);
+    QCOMPARE(machine.configuration().count(), 2);
+    QVERIFY(machine.configuration().contains(greatGrandParent));
+    QVERIFY(machine.configuration().contains(initialStateOfGreatGrandParent));
+
+    entryController->setProperty("greatGrandParentEntered", false);
+    entryController->setProperty("grandParentEntered", false);
+    entryController->setProperty("parentEntered", false);
+    entryController->setProperty("stateEntered", false);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(entryController->property("greatGrandParentEntered").toBool(), false);
+    QCOMPARE(entryController->property("grandParentEntered").toBool(), true);
+    QCOMPARE(entryController->property("parentEntered").toBool(), true);
+    QCOMPARE(entryController->property("stateEntered").toBool(), true);
+    QCOMPARE(machine.configuration().count(), 4);
+    QVERIFY(machine.configuration().contains(greatGrandParent));
+    QVERIFY(machine.configuration().contains(grandParent));
+    QVERIFY(machine.configuration().contains(parent));
+    QVERIFY(machine.configuration().contains(state));
+}
+
+void tst_QStateMachine::defaultErrorState()
+{
+    QStateMachine machine;
+    QVERIFY(machine.errorState() != 0);
+
+    QState *brokenState = new QState();
+    brokenState->setObjectName("MyInitialState");
+
+    machine.addState(brokenState);
+    machine.setInitialState(brokenState);
+
+    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(machine.error(), QStateMachine::NoInitialStateError);
+    QCOMPARE(machine.errorString(), QString::fromLatin1("Missing initial state in compound state 'MyInitialState'"));
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(machine.errorState()));
+}
+
+class CustomErrorState: public QState
+{
+public:
+    CustomErrorState(QStateMachine *machine, QState *parent = 0) 
+        : QState(parent), error(QStateMachine::NoError), m_machine(machine)
+    {
+    }
+
+    void onEntry(QEvent *)
+    {
+        error = m_machine->error();        
+        errorString = m_machine->errorString();
+    }
+
+    QStateMachine::Error error;
+    QString errorString;
+
+private:
+    QStateMachine *m_machine;
+};
+
+void tst_QStateMachine::customGlobalErrorState()
+{
+    QStateMachine machine;
+
+    CustomErrorState *customErrorState = new CustomErrorState(&machine);
+    customErrorState->setObjectName("customErrorState");
+    machine.addState(customErrorState);
+    machine.setErrorState(customErrorState);
+
+    QState *initialState = new QState();
+    initialState->setObjectName("initialState");
+    machine.addState(initialState);
+    machine.setInitialState(initialState);
+
+    QState *brokenState = new QState();
+    brokenState->setObjectName("brokenState");
+    machine.addState(brokenState);
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.errorState(), customErrorState);
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(initialState));
+
+    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(initialState));
+
+    QCoreApplication::processEvents();
+    
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(customErrorState));
+    QCOMPARE(customErrorState->error, QStateMachine::NoInitialStateError);
+    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'"));
+}
+
+void tst_QStateMachine::customLocalErrorStateInBrokenState()
+{    
+    QStateMachine machine;
+    CustomErrorState *customErrorState = new CustomErrorState(&machine);
+    machine.addState(customErrorState);
+
+    QState *initialState = new QState();
+    initialState->setObjectName("initialState");
+    machine.addState(initialState);
+    machine.setInitialState(initialState);
+
+    QState *brokenState = new QState();
+    brokenState->setObjectName("brokenState");
+    machine.addState(brokenState);        
+    brokenState->setErrorState(customErrorState);    
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
+
+    machine.start();    
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(customErrorState));
+    QCOMPARE(customErrorState->error, QStateMachine::NoInitialStateError);
+}
+
+void tst_QStateMachine::customLocalErrorStateInOtherState()
+{
+    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);
+
+    QState *brokenState = new QState();
+    brokenState->setObjectName("brokenState");
+    
+    machine.addState(brokenState);    
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    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();
+
+    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(machine.errorState()));
+}
+
+void tst_QStateMachine::customLocalErrorStateInParentOfBrokenState()
+{
+    QStateMachine machine;
+    CustomErrorState *customErrorState = new CustomErrorState(&machine);
+    machine.addState(customErrorState);
+
+    QState *initialState = new QState();
+    initialState->setObjectName("initialState");
+    machine.addState(initialState);
+    machine.setInitialState(initialState);
+
+    QState *parentOfBrokenState = new QState();
+    machine.addState(parentOfBrokenState);
+    parentOfBrokenState->setObjectName("parentOfBrokenState");
+    parentOfBrokenState->setErrorState(customErrorState);    
+
+    QState *brokenState = new QState(parentOfBrokenState);
+    brokenState->setObjectName("brokenState");
+    parentOfBrokenState->setInitialState(brokenState);
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(customErrorState));
+}
+
+void tst_QStateMachine::customLocalErrorStateOverridesParent()
+{
+    QStateMachine machine;
+    CustomErrorState *customErrorStateForParent = new CustomErrorState(&machine);
+    machine.addState(customErrorStateForParent);
+
+    CustomErrorState *customErrorStateForBrokenState = new CustomErrorState(&machine);
+    machine.addState(customErrorStateForBrokenState);
+
+    QState *initialState = new QState();
+    initialState->setObjectName("initialState");
+    machine.addState(initialState);
+    machine.setInitialState(initialState);
+
+    QState *parentOfBrokenState = new QState();
+    machine.addState(parentOfBrokenState);
+    parentOfBrokenState->setObjectName("parentOfBrokenState");
+    parentOfBrokenState->setErrorState(customErrorStateForParent);
+    
+    QState *brokenState = new QState(parentOfBrokenState);
+    brokenState->setObjectName("brokenState");
+    brokenState->setErrorState(customErrorStateForBrokenState);
+    parentOfBrokenState->setInitialState(brokenState);
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(customErrorStateForBrokenState));
+    QCOMPARE(customErrorStateForBrokenState->error, QStateMachine::NoInitialStateError);
+    QCOMPARE(customErrorStateForParent->error, QStateMachine::NoError);
+}
+
+void tst_QStateMachine::errorStateHasChildren()
+{
+    QStateMachine machine;
+    CustomErrorState *customErrorState = new CustomErrorState(&machine);
+    customErrorState->setObjectName("customErrorState");
+    machine.addState(customErrorState);
+
+    machine.setErrorState(customErrorState);
+
+    QState *childOfErrorState = new QState(customErrorState);
+    childOfErrorState->setObjectName("childOfErrorState");
+    customErrorState->setInitialState(childOfErrorState);
+
+    QState *initialState = new QState();
+    initialState->setObjectName("initialState");
+    machine.addState(initialState);
+    machine.setInitialState(initialState);    
+
+    QState *brokenState = new QState();
+    brokenState->setObjectName("brokenState");    
+    machine.addState(brokenState);
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 2);
+    QVERIFY(machine.configuration().contains(customErrorState));
+    QVERIFY(machine.configuration().contains(childOfErrorState)); 
+}
+
+
+void tst_QStateMachine::errorStateHasErrors()
+{
+    QStateMachine machine;
+    CustomErrorState *customErrorState = new CustomErrorState(&machine);
+    customErrorState->setObjectName("customErrorState");
+    machine.addState(customErrorState);
+
+    QAbstractState *oldErrorState = machine.errorState();
+    machine.setErrorState(customErrorState);
+
+    QState *childOfErrorState = new QState(customErrorState);
+    childOfErrorState->setObjectName("childOfErrorState");
+
+    QState *initialState = new QState();
+    initialState->setObjectName("initialState");
+    machine.addState(initialState);
+    machine.setInitialState(initialState);    
+
+    QState *brokenState = new QState();
+    brokenState->setObjectName("brokenState");    
+    machine.addState(brokenState);
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
+
+    machine.start();
+    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'"));
+}
+
+void tst_QStateMachine::errorStateIsRootState()
+{
+    QStateMachine machine;
+    QTest::ignoreMessage(QtWarningMsg, "QStateMachine::setErrorState: root state cannot be error state");
+    machine.setErrorState(machine.rootState());
+
+    QState *initialState = new QState();
+    initialState->setObjectName("initialState");
+    machine.addState(initialState);
+    machine.setInitialState(initialState);    
+    
+    QState *brokenState = new QState();
+    brokenState->setObjectName("brokenState");    
+    machine.addState(brokenState);
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));
+
+    machine.start();
+    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);    
+    QVERIFY(machine.configuration().contains(machine.errorState()));
+}
+
+void tst_QStateMachine::errorStateEntersParentFirst()
+{
+    QStateMachine machine;
+
+    QObject *entryController = new QObject(&machine);
+    entryController->setObjectName("entryController");
+    entryController->setProperty("greatGrandParentEntered", false);
+    entryController->setProperty("grandParentEntered", false);
+    entryController->setProperty("parentEntered", false);
+    entryController->setProperty("errorStateEntered", false);
+
+    QState *greatGrandParent = new QState();
+    greatGrandParent->setObjectName("greatGrandParent");
+    greatGrandParent->assignProperty(entryController, "greatGrandParentEntered", true);
+    machine.addState(greatGrandParent);
+    machine.setInitialState(greatGrandParent);
+
+    QState *grandParent = new QState(greatGrandParent);
+    grandParent->setObjectName("grandParent");
+    grandParent->assignProperty(entryController, "grandParentEntered", true);    
+
+    QState *parent = new QState(grandParent);
+    parent->setObjectName("parent");
+    parent->assignProperty(entryController, "parentEntered", true);
+
+    QState *errorState = new QState(parent);
+    errorState->setObjectName("errorState");
+    errorState->assignProperty(entryController, "errorStateEntered", true);
+    machine.setErrorState(errorState);
+
+    QState *initialStateOfGreatGrandParent = new QState(greatGrandParent);
+    initialStateOfGreatGrandParent->setObjectName("initialStateOfGreatGrandParent");
+    greatGrandParent->setInitialState(initialStateOfGreatGrandParent);
+
+    QState *brokenState = new QState(greatGrandParent);    
+    brokenState->setObjectName("brokenState");
+
+    QState *childState = new QState(brokenState);
+    childState->setObjectName("childState");
+
+    initialStateOfGreatGrandParent->addTransition(new EventTransition(QEvent::User, brokenState));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(entryController->property("greatGrandParentEntered").toBool(), true);
+    QCOMPARE(entryController->property("grandParentEntered").toBool(), false);
+    QCOMPARE(entryController->property("parentEntered").toBool(), false);
+    QCOMPARE(entryController->property("errorStateEntered").toBool(), false);
+    QCOMPARE(machine.configuration().count(), 2);
+    QVERIFY(machine.configuration().contains(greatGrandParent));
+    QVERIFY(machine.configuration().contains(initialStateOfGreatGrandParent));
+
+    entryController->setProperty("greatGrandParentEntered", false);
+    entryController->setProperty("grandParentEntered", false);
+    entryController->setProperty("parentEntered", false);
+    entryController->setProperty("errorStateEntered", false);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(entryController->property("greatGrandParentEntered").toBool(), false);
+    QCOMPARE(entryController->property("grandParentEntered").toBool(), true);
+    QCOMPARE(entryController->property("parentEntered").toBool(), true);
+    QCOMPARE(entryController->property("errorStateEntered").toBool(), true);
+    QCOMPARE(machine.configuration().count(), 4);
+    QVERIFY(machine.configuration().contains(greatGrandParent));
+    QVERIFY(machine.configuration().contains(grandParent));
+    QVERIFY(machine.configuration().contains(parent));
+    QVERIFY(machine.configuration().contains(errorState));
+}
+
+void tst_QStateMachine::customErrorStateIsNull()
+{
+    QStateMachine machine;
+    QAbstractState *oldErrorState = machine.errorState();
+    machine.rootState()->setErrorState(0);
+
+    QState *initialState = new QState();
+    machine.addState(initialState);
+    machine.setInitialState(initialState);
+
+    QState *brokenState = new QState();
+    machine.addState(brokenState);
+
+    new QState(brokenState);
+    initialState->addTransition(new EventTransition(QEvent::User, brokenState));
+
+    machine.start();
+    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));
+}
+
+void tst_QStateMachine::clearError()
+{
+    QStateMachine machine;    
+    machine.setErrorState(new QState(machine.rootState())); // avoid warnings
+    
+    QState *brokenState = new QState(machine.rootState());
+    brokenState->setObjectName("brokenState");
+    machine.setInitialState(brokenState);
+    new QState(brokenState);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.error(), QStateMachine::NoInitialStateError);
+    QCOMPARE(machine.errorString(), QString::fromLatin1("Missing initial state in compound state 'brokenState'"));
+
+    machine.clearError();
+
+    QCOMPARE(machine.error(), QStateMachine::NoError);
+    QVERIFY(machine.errorString().isEmpty());
+}
+
+void tst_QStateMachine::historyStateAsInitialState()
+{
+    QStateMachine machine;
+
+    QHistoryState *hs = new QHistoryState(machine.rootState());
+    machine.setInitialState(hs);
+
+    QState *s1 = new QState(machine.rootState());
+    hs->setDefaultState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+
+    QHistoryState *s2h = new QHistoryState(s2);
+    s2->setInitialState(s2h);
+    
+    QState *s21 = new QState(s2);
+    s2h->setDefaultState(s21);
+    
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s1));
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s21));
+}
+
+void tst_QStateMachine::historyStateHasNowhereToGo()
+{
+    QStateMachine machine;
+
+    QState *initialState = new QState(machine.rootState());
+    machine.setInitialState(initialState);
+    machine.setErrorState(new QState(machine.rootState())); // avoid warnings
+
+    QState *brokenState = new QState(machine.rootState());
+    brokenState->setObjectName("brokenState");
+    brokenState->setInitialState(new QState(brokenState));
+
+    QHistoryState *historyState = new QHistoryState(brokenState);
+    historyState->setObjectName("historyState");
+    initialState->addTransition(new EventTransition(QEvent::User, historyState));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().count(), 1);
+    QVERIFY(machine.configuration().contains(machine.errorState()));
+    QCOMPARE(machine.error(), QStateMachine::NoDefaultStateInHistoryStateError);
+    QCOMPARE(machine.errorString(), QString::fromLatin1("Missing default state in history state 'historyState'"));
+}
+
+void tst_QStateMachine::brokenStateIsNeverEntered()
+{
+    QStateMachine machine;
+
+    QObject *entryController = new QObject(&machine);
+    entryController->setProperty("brokenStateEntered", false);
+    entryController->setProperty("childStateEntered", false);
+    entryController->setProperty("errorStateEntered", false);
+
+    QState *initialState = new QState(machine.rootState());    
+    machine.setInitialState(initialState);
+
+    QState *errorState = new QState(machine.rootState());
+    errorState->assignProperty(entryController, "errorStateEntered", true);
+    machine.setErrorState(errorState); 
+
+    QState *brokenState = new QState(machine.rootState());
+    brokenState->assignProperty(entryController, "brokenStateEntered", true);
+    brokenState->setObjectName("brokenState");
+    
+    QState *childState = new QState(brokenState);
+    childState->assignProperty(entryController, "childStateEntered", true);
+
+    initialState->addTransition(new EventTransition(QEvent::User, brokenState));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(entryController->property("errorStateEntered").toBool(), true);
+    QCOMPARE(entryController->property("brokenStateEntered").toBool(), false);
+    QCOMPARE(entryController->property("childStateEntered").toBool(), false);
+}
+
+void tst_QStateMachine::transitionToStateNotInGraph()
+{
+    QStateMachine machine;    
+
+    QState *initialState = new QState(machine.rootState());
+    initialState->setObjectName("initialState");
+    machine.setInitialState(initialState);
+
+    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);
+    QVERIFY(machine.configuration().contains(qobject_cast<QState*>(machine.rootState())->errorState()));
+}
+
+void tst_QStateMachine::customErrorStateNotInGraph()
+{
+    QStateMachine machine;
+
+    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");
+    machine.setInitialState(initialBrokenState);
+    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);
+    QVERIFY(machine.configuration().contains(machine.errorState()));        
+}
+
+void tst_QStateMachine::restoreProperties()
+{
+    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);
+    machine.addState(S1);
+
+    QState *S2 = new QState();
+    S2->setObjectName("S2");
+    S2->assignProperty(object, "b", 5);
+    machine.addState(S2);
+
+    QState *S3 = new QState();
+    S3->setObjectName("S3");
+    machine.addState(S3);
+
+    QFinalState *S4 = new QFinalState();
+    machine.addState(S4);
+
+    S1->addTransition(new EventTransition(QEvent::User, S2));
+    S2->addTransition(new EventTransition(QEvent::User, S3));
+    S3->addTransition(S4);
+
+    machine.setInitialState(S1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("a").toInt(), 3);
+    QCOMPARE(object->property("b").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("a").toInt(), 1);
+    QCOMPARE(object->property("b").toInt(), 5);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("a").toInt(), 1);
+    QCOMPARE(object->property("b").toInt(), 2);
+}
+
+void tst_QStateMachine::rootState()
+{
+    QStateMachine machine;
+    QVERIFY(machine.rootState() != 0);
+    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());
+
+    QState *s2 = new QState();
+    s2->setParent(&machine);
+    QCOMPARE(s2->parentState(), machine.rootState());
+}
+
+void tst_QStateMachine::addAndRemoveState()
+{
+    QStateMachine machine;
+    QStatePrivate *root_d = QStatePrivate::get(machine.rootState());
+    QCOMPARE(root_d->childStates().size(), 1); // the error state
+    QCOMPARE(root_d->childStates().at(0), (QAbstractState*)machine.errorState());
+
+    QTest::ignoreMessage(QtWarningMsg, "QStateMachine::addState: cannot add null state");
+    machine.addState(0);
+
+    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());
+    QCOMPARE(root_d->childStates().at(1), (QAbstractState*)s1);
+
+    QTest::ignoreMessage(QtWarningMsg, "QStateMachine::addState: state has already been added to this machine");
+    machine.addState(s1);
+
+    QState *s2 = new QState();
+    QCOMPARE(s2->parentState(), (QState*)0);
+    machine.addState(s2);
+    QCOMPARE(s2->parentState(), machine.rootState());
+    QCOMPARE(root_d->childStates().size(), 3);
+    QCOMPARE(root_d->childStates().at(0), (QAbstractState*)machine.errorState());
+    QCOMPARE(root_d->childStates().at(1), (QAbstractState*)s1);
+    QCOMPARE(root_d->childStates().at(2), (QAbstractState*)s2);
+
+    QTest::ignoreMessage(QtWarningMsg, "QStateMachine::addState: state has already been added to this machine");
+    machine.addState(s2);
+
+    machine.removeState(s1);
+    QCOMPARE(s1->parentState(), (QState*)0);
+    QCOMPARE(root_d->childStates().size(), 2);
+    QCOMPARE(root_d->childStates().at(0), (QAbstractState*)machine.errorState());
+    QCOMPARE(root_d->childStates().at(1), (QAbstractState*)s2);
+
+    machine.removeState(s2);
+    QCOMPARE(s2->parentState(), (QState*)0);
+    QCOMPARE(root_d->childStates().size(), 1);
+    QCOMPARE(root_d->childStates().at(0), (QAbstractState*)machine.errorState());
+
+    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?
+    // machine.removeState(machine.errorState());
+}
+
+void tst_QStateMachine::stateEntryAndExit()
+{
+    // Two top-level states
+    {
+        QStateMachine machine;
+
+        TestState *s1 = new TestState(machine.rootState());
+        QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: cannot add transition to null state");
+        s1->addTransition((QAbstractState*)0);
+        QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: cannot add null transition");
+        s1->addTransition((QAbstractTransition*)0);
+        QTest::ignoreMessage(QtWarningMsg, "QState::removeTransition: cannot remove null transition");
+        s1->removeTransition((QAbstractTransition*)0);
+
+        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);
+            QCOMPARE(s2->addTransition(trans), trans);
+            QCOMPARE(trans->sourceState(), (QAbstractState*)s2);
+        }
+
+        QSignalSpy startedSpy(&machine, SIGNAL(started()));
+        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());
+        machine.start();
+
+        QTRY_COMPARE(startedSpy.count(), 1);
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QTRY_COMPARE(stoppedSpy.count(), 0);
+        QCOMPARE(machine.configuration().count(), 1);
+        QVERIFY(machine.configuration().contains(s3));
+
+        // s1 is entered
+        QCOMPARE(s1->events.count(), 2);
+        QCOMPARE(s1->events.at(0).first, 0);
+        QCOMPARE(s1->events.at(0).second, TestState::Entry);
+        // s1 is exited
+        QCOMPARE(s1->events.at(1).first, 1);
+        QCOMPARE(s1->events.at(1).second, TestState::Exit);
+        // t is triggered
+        QCOMPARE(t->triggers.count(), 1);
+        QCOMPARE(t->triggers.at(0), 2);
+        // s2 is entered
+        QCOMPARE(s2->events.count(), 2);
+        QCOMPARE(s2->events.at(0).first, 3);
+        QCOMPARE(s2->events.at(0).second, TestState::Entry);
+        // s2 is exited
+        QCOMPARE(s2->events.at(1).first, 4);
+        QCOMPARE(s2->events.at(1).second, TestState::Exit);
+    }
+    // Two top-level states, one has two child states
+    {
+        QStateMachine machine;
+
+        TestState *s1 = new TestState(machine.rootState());
+        TestState *s11 = new TestState(s1);
+        TestState *s12 = new TestState(s1);
+        TestState *s2 = new TestState(machine.rootState());
+        QFinalState *s3 = new QFinalState(machine.rootState());
+        s1->setInitialState(s11);
+        TestTransition *t1 = new TestTransition(s12);
+        s11->addTransition(t1);
+        TestTransition *t2 = new TestTransition(s2);
+        s12->addTransition(t2);
+        s2->addTransition(s3);
+
+        QSignalSpy startedSpy(&machine, SIGNAL(started()));
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s1);
+        globalTick = 0;
+        machine.start();
+
+        QTRY_COMPARE(startedSpy.count(), 1);
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(machine.configuration().count(), 1);
+        QVERIFY(machine.configuration().contains(s3));
+
+        // s1 is entered
+        QCOMPARE(s1->events.count(), 2);
+        QCOMPARE(s1->events.at(0).first, 0);
+        QCOMPARE(s1->events.at(0).second, TestState::Entry);
+        // s11 is entered
+        QCOMPARE(s11->events.count(), 2);
+        QCOMPARE(s11->events.at(0).first, 1);
+        QCOMPARE(s11->events.at(0).second, TestState::Entry);
+        // s11 is exited
+        QCOMPARE(s11->events.at(1).first, 2);
+        QCOMPARE(s11->events.at(1).second, TestState::Exit);
+        // t1 is triggered
+        QCOMPARE(t1->triggers.count(), 1);
+        QCOMPARE(t1->triggers.at(0), 3);
+        // s12 is entered
+        QCOMPARE(s12->events.count(), 2);
+        QCOMPARE(s12->events.at(0).first, 4);
+        QCOMPARE(s12->events.at(0).second, TestState::Entry);
+        // s12 is exited
+        QCOMPARE(s12->events.at(1).first, 5);
+        QCOMPARE(s12->events.at(1).second, TestState::Exit);
+        // s1 is exited
+        QCOMPARE(s1->events.at(1).first, 6);
+        QCOMPARE(s1->events.at(1).second, TestState::Exit);
+        // t2 is triggered
+        QCOMPARE(t2->triggers.count(), 1);
+        QCOMPARE(t2->triggers.at(0), 7);
+        // s2 is entered
+        QCOMPARE(s2->events.count(), 2);
+        QCOMPARE(s2->events.at(0).first, 8);
+        QCOMPARE(s2->events.at(0).second, TestState::Entry);
+        // s2 is exited
+        QCOMPARE(s2->events.at(1).first, 9);
+        QCOMPARE(s2->events.at(1).second, TestState::Exit);
+    }
+}
+
+void tst_QStateMachine::assignProperty()
+{
+    QStateMachine machine;
+    QState *s1 = new QState(machine.rootState());
+
+    QTest::ignoreMessage(QtWarningMsg, "QState::assignProperty: cannot assign property 'foo' of null object");
+    s1->assignProperty(0, "foo", QVariant());
+
+    s1->assignProperty(s1, "objectName", "s1");
+    QFinalState *s2 = new QFinalState(machine.rootState());
+    s1->addTransition(s2);
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+    QCOMPARE(s1->objectName(), QString::fromLatin1("s1"));
+
+    s1->assignProperty(s1, "objectName", "foo");
+    machine.start();
+    QCoreApplication::processEvents();
+    QCOMPARE(s1->objectName(), QString::fromLatin1("foo"));
+
+    s1->assignProperty(s1, "noSuchProperty", 123);
+    machine.start();
+    QCoreApplication::processEvents();
+    QCOMPARE(s1->objectName(), QString::fromLatin1("foo"));
+    QCOMPARE(s1->dynamicPropertyNames().size(), 1);
+    QCOMPARE(s1->dynamicPropertyNames().at(0), QByteArray("noSuchProperty"));
+
+    QSignalSpy polishedSpy(s1, SIGNAL(polished()));
+    machine.start();
+    QCoreApplication::processEvents();
+    QCOMPARE(polishedSpy.count(), 1);
+}
+
+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);
+        QState *s1 = new QState(machine.rootState());
+        s1->assignProperty(&obj, "foo", 123);
+        QState *s2 = new QState(machine.rootState());
+        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);
+
+        machine.setInitialState(s1);
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.start();
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(obj.property("foo").toInt(), 456);
+        QCOMPARE(obj.property("bar").toInt(), 789);
+    }
+    // Two animations
+    {
+        QStateMachine machine;
+        QObject obj;
+        obj.setProperty("foo", 321);
+        obj.setProperty("bar", 654);
+        QState *s1 = new QState(machine.rootState());
+        s1->assignProperty(&obj, "foo", 123);
+        QState *s2 = new QState(machine.rootState());
+        s2->assignProperty(&obj, "foo", 456);
+        s2->assignProperty(&obj, "bar", 789);
+        QAbstractTransition *trans = s1->addTransition(s2);
+        QPropertyAnimation anim(&obj, "foo");
+        anim.setDuration(150);
+        trans->addAnimation(&anim);
+        QPropertyAnimation anim2(&obj, "bar");
+        anim2.setDuration(150);
+        trans->addAnimation(&anim2);
+        QFinalState *s3 = new QFinalState(machine.rootState());
+        s2->addTransition(s2, SIGNAL(polished()), s3);
+
+        machine.setInitialState(s1);
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.start();
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(obj.property("foo").toInt(), 456);
+        QCOMPARE(obj.property("bar").toInt(), 789);
+    }
+    // Animation group
+    {
+        QStateMachine machine;
+        QObject obj;
+        obj.setProperty("foo", 321);
+        obj.setProperty("bar", 654);
+        QState *s1 = new QState(machine.rootState());
+        s1->assignProperty(&obj, "foo", 123);
+        s1->assignProperty(&obj, "bar", 321);
+        QState *s2 = new QState(machine.rootState());
+        s2->assignProperty(&obj, "foo", 456);
+        s2->assignProperty(&obj, "bar", 654);
+        s2->assignProperty(&obj, "baz", 789);
+        QAbstractTransition *trans = s1->addTransition(s2);
+        QSequentialAnimationGroup group;
+        group.addAnimation(new QPropertyAnimation(&obj, "foo"));
+        group.addAnimation(new QPropertyAnimation(&obj, "bar"));
+        trans->addAnimation(&group);
+        QFinalState *s3 = new QFinalState(machine.rootState());
+        s2->addTransition(s2, SIGNAL(polished()), s3);
+
+        machine.setInitialState(s1);
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.start();
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(obj.property("foo").toInt(), 456);
+        QCOMPARE(obj.property("bar").toInt(), 654);
+        QCOMPARE(obj.property("baz").toInt(), 789);
+    }
+    // Nested states
+    {
+        QStateMachine machine;
+        QObject obj;
+        obj.setProperty("foo", 321);
+        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);
+        s1->assignProperty(&obj, "bar", 456);
+        QState *s2 = new QState(machine.rootState());
+        s2->setObjectName("s2");
+        s2->assignProperty(&obj, "foo", 321);
+        QState *s21 = new QState(s2);
+        s21->setObjectName("s21");
+        s21->assignProperty(&obj, "bar", 654);
+        QState *s22 = new QState(s2);
+        s22->setObjectName("s22");
+        s22->assignProperty(&obj, "bar", 789);
+        s2->setInitialState(s21);
+        QCOMPARE(s2->initialState(), (QAbstractState*)s21);
+
+        QAbstractTransition *trans = s1->addTransition(s2);
+        QPropertyAnimation anim(&obj, "foo");
+        anim.setDuration(500);
+        trans->addAnimation(&anim);
+        QPropertyAnimation anim2(&obj, "bar");
+        anim2.setDuration(250);
+        trans->addAnimation(&anim2);
+
+        s21->addTransition(s21, SIGNAL(polished()), s22);
+
+        QFinalState *s3 = new QFinalState(machine.rootState());
+        s22->addTransition(s2, SIGNAL(polished()), s3);
+
+        machine.setInitialState(s1);
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.start();
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        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
+{
+public:
+    StringEvent(const QString &val)
+        : QEvent(QEvent::Type(QEvent::User+2)),
+          value(val) {}
+
+    QString value;
+};
+
+class StringTransition : public QAbstractTransition
+{
+public:
+    StringTransition(const QString &value, QAbstractState *target)
+        : QAbstractTransition(QList<QAbstractState*>() << target), m_value(value) {}
+
+protected:
+    virtual bool eventTest(QEvent *e) 
+    {
+        if (e->type() != QEvent::Type(QEvent::User+2))
+            return false;
+        StringEvent *se = static_cast<StringEvent*>(e);
+        return (m_value == se->value) && (!m_cond.isValid() || (m_cond.indexIn(m_value) != -1));
+    }
+    virtual void onTransition(QEvent *) {}
+
+private:
+    QString m_value;
+    QRegExp m_cond;
+};
+
+class StringEventPoster : public QState
+{
+public:
+    StringEventPoster(QStateMachine *machine, const QString &value, QState *parent = 0)
+        : 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_delay);
+    }
+    virtual void onExit(QEvent *) {}
+
+private:
+    QStateMachine *m_machine;
+    QString m_value;
+    int m_delay;
+};
+
+void tst_QStateMachine::postEvent()
+{
+    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));
+    }
+}
+
+void tst_QStateMachine::stateFinished()
+{
+    QStateMachine machine;
+    QState *s1 = new QState(machine.rootState());
+    QState *s1_1 = new QState(s1);
+    QFinalState *s1_2 = new QFinalState(s1);
+    s1_1->addTransition(s1_2);
+    s1->setInitialState(s1_1);
+    QFinalState *s2 = new QFinalState(machine.rootState());
+    s1->addTransition(s1, SIGNAL(finished()), 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));
+}
+
+void tst_QStateMachine::parallelStates()
+{
+    QStateMachine machine;
+
+    QState *s1 = new QState(QState::ParallelStates);
+    QCOMPARE(s1->childMode(), QState::ParallelStates);
+      QState *s1_1 = new QState(s1);
+        QState *s1_1_1 = new QState(s1_1);
+        QFinalState *s1_1_f = new QFinalState(s1_1);
+        s1_1_1->addTransition(s1_1_f);
+      s1_1->setInitialState(s1_1_1);
+      QState *s1_2 = new QState(s1);
+        QState *s1_2_1 = new QState(s1_2);
+        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();
+    machine.addState(s2);
+
+    s1->addTransition(s1, SIGNAL(finished()), 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));
+}
+
+void tst_QStateMachine::allSourceToTargetConfigurations()
+{
+    QStateMachine machine;
+    QState *s0 = new QState(machine.rootState());
+    s0->setObjectName("s0");
+    QState *s1 = new QState(s0);
+    s1->setObjectName("s1");
+    QState *s11 = new QState(s1);
+    s11->setObjectName("s11");
+    QState *s2 = new QState(s0);
+    s2->setObjectName("s2");
+    QState *s21 = new QState(s2);
+    s21->setObjectName("s21");
+    QState *s211 = new QState(s21);
+    s211->setObjectName("s211");
+    QFinalState *f = new QFinalState(machine.rootState());
+    f->setObjectName("f");
+
+    s0->setInitialState(s1);
+    s1->setInitialState(s11);
+    s2->setInitialState(s21);
+    s21->setInitialState(s211);
+
+    s11->addTransition(new StringTransition("g", s211));
+    s1->addTransition(new StringTransition("a", s1));
+    s1->addTransition(new StringTransition("b", s11));
+    s1->addTransition(new StringTransition("c", s2));
+    s1->addTransition(new StringTransition("d", s0));
+    s1->addTransition(new StringTransition("f", s211));
+    s211->addTransition(new StringTransition("d", s21));
+    s211->addTransition(new StringTransition("g", s0));
+    s211->addTransition(new StringTransition("h", f));
+    s21->addTransition(new StringTransition("b", s211));
+    s2->addTransition(new StringTransition("c", s1));
+    s2->addTransition(new StringTransition("f", s11));
+    s0->addTransition(new StringTransition("e", s211));
+
+    QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+    machine.setInitialState(s0);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new StringEvent("a"));
+    QCoreApplication::processEvents();
+    machine.postEvent(new StringEvent("b"));
+    QCoreApplication::processEvents();
+    machine.postEvent(new StringEvent("c"));
+    QCoreApplication::processEvents();
+    machine.postEvent(new StringEvent("d"));
+    QCoreApplication::processEvents();
+    machine.postEvent(new StringEvent("e"));
+    QCoreApplication::processEvents();
+    machine.postEvent(new StringEvent("f"));
+    QCoreApplication::processEvents();
+    machine.postEvent(new StringEvent("g"));
+    QCoreApplication::processEvents();
+    machine.postEvent(new StringEvent("h"));
+    QCoreApplication::processEvents();
+
+    QTRY_COMPARE(finishedSpy.count(), 1);
+}
+
+class TestSignalTransition : public QSignalTransition
+{
+public:
+    TestSignalTransition(QState *sourceState = 0)
+        : QSignalTransition(sourceState) {}
+    TestSignalTransition(QObject *sender, const char *signal,
+                         QAbstractState *target)
+        : QSignalTransition(sender, signal, QList<QAbstractState*>() << target) {}
+    QVariantList argumentsReceived() const {
+        return m_args;
+    }
+protected:
+    bool eventTest(QEvent *e) {
+        if (!QSignalTransition::eventTest(e))
+            return false;
+        QSignalEvent *se = static_cast<QSignalEvent*>(e);
+        const_cast<TestSignalTransition*>(this)->m_args = se->arguments();
+        return true;
+    }
+private:
+    QVariantList m_args;
+};
+
+void tst_QStateMachine::signalTransitions()
+{
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: sender cannot be null");
+        QCOMPARE(s0->addTransition(0, SIGNAL(noSuchSignal()), 0), (QObject*)0);
+
+        SignalEmitter emitter;
+        QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: signal cannot be null");
+        QCOMPARE(s0->addTransition(&emitter, 0, 0), (QObject*)0);
+
+        QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: cannot add transition to null state");
+        QCOMPARE(s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), 0), (QObject*)0);
+
+        QFinalState *s1 = new QFinalState(machine.rootState());
+        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())));
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        emitter.emitSignalWithNoArg();
+
+        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;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+        SignalEmitter emitter;
+        TestSignalTransition *trans = new TestSignalTransition(&emitter, SIGNAL(signalWithIntArg(int)), s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        emitter.emitSignalWithIntArg(123);
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(trans->argumentsReceived().size(), 1);
+        QCOMPARE(trans->argumentsReceived().at(0).toInt(), 123);
+    }
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+        SignalEmitter emitter;
+        TestSignalTransition *trans = new TestSignalTransition(&emitter, SIGNAL(signalWithStringArg(QString)), s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        QString testString = QString::fromLatin1("hello");
+        emitter.emitSignalWithStringArg(testString);
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+        QCOMPARE(trans->argumentsReceived().size(), 1);
+        QCOMPARE(trans->argumentsReceived().at(0).toString(), testString);
+    }
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+
+        TestSignalTransition *trans = new TestSignalTransition();
+        QCOMPARE(trans->senderObject(), (QObject*)0);
+        QCOMPARE(trans->signal(), QByteArray());
+
+        SignalEmitter emitter;
+        trans->setSenderObject(&emitter);
+        QCOMPARE(trans->senderObject(), (QObject*)&emitter);
+        trans->setSignal(SIGNAL(signalWithNoArg()));
+        QCOMPARE(trans->signal(), QByteArray(SIGNAL(signalWithNoArg())));
+        trans->setTargetState(s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        emitter.emitSignalWithNoArg();
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+    }
+    // Multiple transitions for same (object,signal)
+    {
+        QStateMachine machine;
+        SignalEmitter emitter;
+        QState *s0 = new QState(machine.rootState());
+        QState *s1 = new QState(machine.rootState());
+        QSignalTransition *t0 = s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), s1);
+        QSignalTransition *t1 = s1->addTransition(&emitter, SIGNAL(signalWithNoArg()), s0);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        emitter.emitSignalWithNoArg();
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s1));
+
+        s0->removeTransition(t0);
+        emitter.emitSignalWithNoArg();
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        emitter.emitSignalWithNoArg();
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        s1->removeTransition(t1);
+        emitter.emitSignalWithNoArg();
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        s0->addTransition(t0);
+        s1->addTransition(t1);
+        emitter.emitSignalWithNoArg();
+        QCoreApplication::processEvents();
+        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;
+        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);
+        QCOMPARE(trans->targetState(), (QAbstractState*)s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        QTest::mousePress(&button, Qt::LeftButton);
+        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;
+        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);
+        QCOMPARE(trans->eventType(), QEvent::MouseButtonPress);
+        QCOMPARE(trans->targetState(), (QAbstractState*)s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        QTest::mousePress(&button, Qt::LeftButton);
+        QCoreApplication::processEvents();
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+    }
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+
+        QMouseEventTransition *trans = new QMouseEventTransition();
+        QCOMPARE(trans->eventObject(), (QObject*)0);
+        QCOMPARE(trans->eventType(), QEvent::None);
+        QCOMPARE(trans->button(), Qt::NoButton);
+        trans->setEventObject(&button);
+        trans->setEventType(QEvent::MouseButtonPress);
+        trans->setButton(Qt::LeftButton);
+        trans->setTargetState(s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        QTest::mousePress(&button, Qt::LeftButton);
+        QCoreApplication::processEvents();
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+    }
+
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+
+        QKeyEventTransition *trans = new QKeyEventTransition(&button, QEvent::KeyPress, Qt::Key_A);
+        QCOMPARE(trans->eventType(), QEvent::KeyPress);
+        QCOMPARE(trans->key(), (int)Qt::Key_A);
+        trans->setTargetState(s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        QTest::keyPress(&button, Qt::Key_A);
+        QCoreApplication::processEvents();
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+    }
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QFinalState *s1 = new QFinalState(machine.rootState());
+
+        QKeyEventTransition *trans = new QKeyEventTransition();
+        QCOMPARE(trans->eventObject(), (QObject*)0);
+        QCOMPARE(trans->eventType(), QEvent::None);
+        QCOMPARE(trans->key(), 0);
+        trans->setEventObject(&button);
+        trans->setEventType(QEvent::KeyPress);
+        trans->setKey(Qt::Key_A);
+        trans->setTargetState(s1);
+        s0->addTransition(trans);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+
+        QTest::keyPress(&button, Qt::Key_A);
+        QCoreApplication::processEvents();
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+    }
+    // Multiple transitions for same (object,event)
+    {
+        QStateMachine machine;
+        QState *s0 = new QState(machine.rootState());
+        QState *s1 = new QState(machine.rootState());
+        QEventTransition *t0 = new QEventTransition(&button, QEvent::MouseButtonPress);
+        t0->setTargetState(s1);
+        s0->addTransition(t0);
+        QEventTransition *t1 = new QEventTransition(&button, QEvent::MouseButtonPress);
+        t1->setTargetState(s0);
+        s1->addTransition(t1);
+
+        QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+        machine.setInitialState(s0);
+        machine.start();
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        QTest::mousePress(&button, Qt::LeftButton);
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s1));
+
+        s0->removeTransition(t0);
+        QTest::mousePress(&button, Qt::LeftButton);
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        QTest::mousePress(&button, Qt::LeftButton);
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        s1->removeTransition(t1);
+        QTest::mousePress(&button, Qt::LeftButton);
+        QCoreApplication::processEvents();
+        QCOMPARE(machine.configuration().size(), 1);
+        QVERIFY(machine.configuration().contains(s0));
+
+        s0->addTransition(t0);
+        s1->addTransition(t1);
+        QTest::mousePress(&button, Qt::LeftButton);
+        QCoreApplication::processEvents();
+        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()
+{
+    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));
+
+        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("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));
+
+        QTRY_COMPARE(finishedSpy.count(), 1);
+    }
+}
+
+void tst_QStateMachine::startAndStop()
+{
+    QStateMachine machine;
+    QSignalSpy startedSpy(&machine, SIGNAL(started()));
+    QSignalSpy stoppedSpy(&machine, SIGNAL(stopped()));
+    QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+    QVERIFY(!machine.isRunning());
+    QTest::ignoreMessage(QtWarningMsg, "QStateMachine::start: No initial state set for machine. Refusing to start.");
+    machine.start();
+    QCOMPARE(startedSpy.count(), 0);
+    QCOMPARE(stoppedSpy.count(), 0);
+    QCOMPARE(finishedSpy.count(), 0);
+    QVERIFY(!machine.isRunning());
+    machine.stop();
+    QCOMPARE(startedSpy.count(), 0);
+    QCOMPARE(stoppedSpy.count(), 0);
+    QCOMPARE(finishedSpy.count(), 0);
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+    machine.start();
+    QTRY_COMPARE(machine.isRunning(), true);
+    QTRY_COMPARE(startedSpy.count(), 1);
+    QCOMPARE(stoppedSpy.count(), 0);
+    QCOMPARE(finishedSpy.count(), 0);
+    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);
+    QCOMPARE(startedSpy.count(), 1);
+    QCOMPARE(finishedSpy.count(), 0);
+
+    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()
+{
+    QStateMachine machine;
+    QState *s1 = new QState(machine.rootState());
+    s1->setObjectName("s1");
+    QState s2;
+    s1->addTransition(&s2);
+    machine.setInitialState(s1);
+    QSignalSpy startedSpy(&machine, SIGNAL(started()));
+    QSignalSpy stoppedSpy(&machine, SIGNAL(stopped()));
+    QSignalSpy finishedSpy(&machine, SIGNAL(finished()));
+    machine.start();
+    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: No common ancestor for targets and source of transition from state 's1'");
+    QTRY_COMPARE(machine.isRunning(), true);
+    QTRY_COMPARE(startedSpy.count(), 1);
+    QCOMPARE(stoppedSpy.count(), 0);
+    QCOMPARE(finishedSpy.count(), 0);
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(machine.errorState()));
+    QCOMPARE(machine.error(), QStateMachine::NoCommonAncestorForTransitionError);
+}
+
+void tst_QStateMachine::targetStateDeleted()
+{
+    QStateMachine machine;
+    QState *s1 = new QState(machine.rootState());
+    s1->setObjectName("s1");
+    QState *s2 = new QState(machine.rootState());
+    QAbstractTransition *trans = s1->addTransition(s2);
+    delete s2;
+    QCOMPARE(trans->targetState(), (QAbstractState*)0);
+    QVERIFY(trans->targetStates().isEmpty());
+}
+
+void tst_QStateMachine::defaultGlobalRestorePolicy()
+{
+    QStateMachine machine;    
+
+    QObject *propertyHolder = new QObject(&machine);
+    propertyHolder->setProperty("a", 1);
+    propertyHolder->setProperty("b", 2);
+
+    QState *s1 = new QState(machine.rootState());
+    s1->assignProperty(propertyHolder, "a", 3);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(propertyHolder, "b", 4);
+
+    QState *s3 = new QState(machine.rootState());
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s2->addTransition(new EventTransition(QEvent::User, s3));
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+    
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);    
+}
+
+/*
+void tst_QStateMachine::restorePolicyNotInherited()
+{
+    QStateMachine machine;    
+
+    QObject *propertyHolder = new QObject();
+    propertyHolder->setProperty("a", 1);
+    propertyHolder->setProperty("b", 2);
+
+    QState *parentState = new QState(machine.rootState());
+    parentState->setObjectName("parentState");
+    parentState->setRestorePolicy(QState::RestoreProperties);
+
+    QState *s1 = new QState(parentState);
+    s1->setObjectName("s1");
+    s1->assignProperty(propertyHolder, "a", 3);
+    parentState->setInitialState(s1);
+
+    QState *s2 = new QState(parentState);
+    s2->setObjectName("s2");
+    s2->assignProperty(propertyHolder, "b", 4);
+
+    QState *s3 = new QState(parentState);
+    s3->setObjectName("s3");
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s2->addTransition(new EventTransition(QEvent::User, s3));
+
+    machine.setInitialState(parentState);
+    machine.start();
+    QCoreApplication::processEvents();
+    
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);    
+
+}*/
+
+void tst_QStateMachine::globalRestorePolicySetToDoNotRestore()
+{
+    QStateMachine machine;
+    machine.setGlobalRestorePolicy(QStateMachine::DoNotRestoreProperties);
+
+    QObject *propertyHolder = new QObject(&machine);
+    propertyHolder->setProperty("a", 1);
+    propertyHolder->setProperty("b", 2);
+
+    QState *s1 = new QState(machine.rootState());
+    s1->assignProperty(propertyHolder, "a", 3);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(propertyHolder, "b", 4);
+
+    QState *s3 = new QState(machine.rootState());
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s2->addTransition(new EventTransition(QEvent::User, s3));
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+    
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);       
+}
+
+/*
+void tst_QStateMachine::setRestorePolicyToDoNotRestore()
+{
+    QObject *object = new QObject();
+    object->setProperty("a", 1);
+    object->setProperty("b", 2);
+
+    QStateMachine machine;
+
+    QState *S1 = new QState();
+    S1->setObjectName("S1");
+    S1->assignProperty(object, "a", 3);
+    S1->setRestorePolicy(QState::DoNotRestoreProperties);
+    machine.addState(S1);
+
+    QState *S2 = new QState();
+    S2->setObjectName("S2");
+    S2->assignProperty(object, "b", 5);
+    S2->setRestorePolicy(QState::DoNotRestoreProperties);
+    machine.addState(S2);
+
+    QState *S3 = new QState();
+    S3->setObjectName("S3");
+    S3->setRestorePolicy(QState::DoNotRestoreProperties);
+    machine.addState(S3);
+
+    QFinalState *S4 = new QFinalState();
+    machine.addState(S4);
+
+    S1->addTransition(new EventTransition(QEvent::User, S2));
+    S2->addTransition(new EventTransition(QEvent::User, S3));
+    S3->addTransition(S4);
+
+    machine.setInitialState(S1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("a").toInt(), 3);
+    QCOMPARE(object->property("b").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("a").toInt(), 3);
+    QCOMPARE(object->property("b").toInt(), 5);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(object->property("a").toInt(), 3);
+    QCOMPARE(object->property("b").toInt(), 5);
+}
+
+void tst_QStateMachine::setGlobalRestorePolicyToGlobalRestore()
+{
+    s_countWarnings = false;
+    QStateMachine machine;
+    machine.setGlobalRestorePolicy(QStateMachine::GlobalRestorePolicy);
+
+    QCOMPARE(machine.globalRestorePolicy(), QStateMachine::DoNotRestoreProperties);
+    QCOMPARE(s_msgType, QtWarningMsg);
+
+    s_msgType = QtDebugMsg;
+    machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
+    machine.setGlobalRestorePolicy(QStateMachine::GlobalRestorePolicy);
+
+    QCOMPARE(machine.globalRestorePolicy(), QStateMachine::RestoreProperties);
+    QCOMPARE(s_msgType, QtWarningMsg);
+}
+
+
+void tst_QStateMachine::restorePolicyOnChildState()
+{
+    QStateMachine machine;
+
+    QObject *propertyHolder = new QObject();
+    propertyHolder->setProperty("a", 1);
+    propertyHolder->setProperty("b", 2);
+
+    QState *parentState = new QState(machine.rootState());
+    parentState->setObjectName("parentState");
+
+    QState *s1 = new QState(parentState);
+    s1->setRestorePolicy(QState::RestoreProperties);
+    s1->setObjectName("s1");
+    s1->assignProperty(propertyHolder, "a", 3);
+    parentState->setInitialState(s1);
+
+    QState *s2 = new QState(parentState);
+    s2->setRestorePolicy(QState::RestoreProperties);
+    s2->setObjectName("s2");
+    s2->assignProperty(propertyHolder, "b", 4);
+
+    QState *s3 = new QState(parentState);
+    s3->setRestorePolicy(QState::RestoreProperties);
+    s3->setObjectName("s3");
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s2->addTransition(new EventTransition(QEvent::User, s3));
+
+    machine.setInitialState(parentState);
+    machine.start();
+    QCoreApplication::processEvents();
+    
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 1);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 1);
+    QCOMPARE(propertyHolder->property("b").toInt(), 2);    
+}
+*/
+
+void tst_QStateMachine::globalRestorePolicySetToRestore()
+{
+    QStateMachine machine;    
+    machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
+
+    QObject *propertyHolder = new QObject(&machine);
+    propertyHolder->setProperty("a", 1);
+    propertyHolder->setProperty("b", 2);
+
+    QState *s1 = new QState(machine.rootState());
+    s1->assignProperty(propertyHolder, "a", 3);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(propertyHolder, "b", 4);
+
+    QState *s3 = new QState(machine.rootState());
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s2->addTransition(new EventTransition(QEvent::User, s3));
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+    
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+    QCOMPARE(propertyHolder->property("b").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 1);
+    QCOMPARE(propertyHolder->property("b").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("a").toInt(), 1);
+    QCOMPARE(propertyHolder->property("b").toInt(), 2);    
+}
+
+/*
+void tst_QStateMachine::mixedRestoreProperties()
+{
+    QStateMachine machine;    
+
+    QObject *propertyHolder = new QObject();
+    propertyHolder->setProperty("a", 1);    
+
+    QState *s1 = new QState(machine.rootState());
+    s1->setRestorePolicy(QState::RestoreProperties);
+    s1->assignProperty(propertyHolder, "a", 3);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(propertyHolder, "a", 4);
+
+    QState *s3 = new QState(machine.rootState());
+
+    QState *s4 = new QState(machine.rootState());
+    s4->assignProperty(propertyHolder, "a", 5);
+
+    QState *s5 = new QState(machine.rootState());
+    s5->setRestorePolicy(QState::RestoreProperties);
+    s5->assignProperty(propertyHolder, "a", 6);
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s2->addTransition(new EventTransition(QEvent::User, s3));
+    s3->addTransition(new EventTransition(QEvent::User, s4));
+    s4->addTransition(new EventTransition(QEvent::User, s5));
+    s5->addTransition(new EventTransition(QEvent::User, s3));
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+    
+    // Enter s1, save current
+    QCOMPARE(propertyHolder->property("a").toInt(), 3);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    // Enter s2, restorePolicy == DoNotRestore, so restore all properties
+    QCOMPARE(propertyHolder->property("a").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    // Enter s3
+    QCOMPARE(propertyHolder->property("a").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    // Enter s4
+    QCOMPARE(propertyHolder->property("a").toInt(), 5);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    // Enter s5, save current
+    QCOMPARE(propertyHolder->property("a").toInt(), 6);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    // Enter s3, restore
+    QCOMPARE(propertyHolder->property("a").toInt(), 5);
+}
+*/
+
+void tst_QStateMachine::transitionWithParent()
+{
+    QStateMachine machine;
+    QState *s1 = new QState(machine.rootState());
+    QState *s2 = new QState(machine.rootState());
+    EventTransition *trans = new EventTransition(QEvent::User, s2, s1);
+    QCOMPARE(trans->sourceState(), s1);
+    QCOMPARE(trans->targetState(), (QAbstractState*)s2);
+    QCOMPARE(trans->targetStates().size(), 1);
+    QCOMPARE(trans->targetStates().at(0), (QAbstractState*)s2);
+}
+
+void tst_QStateMachine::simpleAnimation()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("fooBar", 1.0);
+
+    QState *s1 = new QState(machine.rootState());
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "fooBar", 2.0);
+
+    EventTransition *et = new EventTransition(QEvent::User, s2);
+    QPropertyAnimation *animation = new QPropertyAnimation(object, "fooBar", s2);
+    et->addAnimation(animation);
+    s1->addTransition(et);
+
+    QState *s3 = new QState(machine.rootState());
+    s2->addTransition(animation, SIGNAL(finished()), s3);
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("fooBar").toDouble(), 2.0);    
+}
+
+class SlotCalledCounter: public QObject
+{
+    Q_OBJECT
+public:
+    SlotCalledCounter() : counter(0) {}
+
+    int counter;
+
+public slots:
+    void slot() { counter++; }
+};
+
+void tst_QStateMachine::twoAnimations()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+    object->setProperty("bar", 3.0);
+
+    QState *s1 = new QState(machine.rootState());
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+    s2->assignProperty(object, "bar", 10.0);
+
+    QPropertyAnimation *animationFoo = new QPropertyAnimation(object, "foo", s2);
+    QPropertyAnimation *animationBar = new QPropertyAnimation(object, "bar", s2);
+    animationBar->setDuration(900);
+
+    SlotCalledCounter counter;
+    connect(animationFoo, SIGNAL(finished()), &counter, SLOT(slot())); 
+    connect(animationBar, SIGNAL(finished()), &counter, SLOT(slot()));
+
+    EventTransition *et = new EventTransition(QEvent::User, s2);
+    et->addAnimation(animationFoo);
+    et->addAnimation(animationBar);
+    s1->addTransition(et);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    s2->addTransition(s2, SIGNAL(polished()), s3);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+    QCOMPARE(object->property("bar").toDouble(), 10.0);
+    
+    QCOMPARE(counter.counter, 2);
+}
+
+void tst_QStateMachine::twoAnimatedTransitions()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+
+    QState *s1 = new QState(machine.rootState());
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 5.0);
+    QPropertyAnimation *fooAnimation = new QPropertyAnimation(object, "foo", s2);
+    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(fooAnimation);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    s2->addTransition(fooAnimation, SIGNAL(finished()), s3);
+
+    QState *s4 = new QState(machine.rootState());
+    s4->assignProperty(object, "foo", 2.0);
+    QPropertyAnimation *fooAnimation2 = new QPropertyAnimation(object, "foo", s4);
+    s3->addTransition(new EventTransition(QEvent::User, s4))->addAnimation(fooAnimation2);
+
+    QState *s5 = new QState(machine.rootState());
+    QObject::connect(s5, SIGNAL(entered()), QApplication::instance(), SLOT(quit()));
+    s4->addTransition(fooAnimation2, SIGNAL(finished()), s5);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 5.0);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s5));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+}
+
+void tst_QStateMachine::playAnimationTwice()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+
+    QState *s1 = new QState(machine.rootState());
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 5.0);
+    QPropertyAnimation *fooAnimation = new QPropertyAnimation(object, "foo", s2);
+    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(fooAnimation);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    s2->addTransition(fooAnimation, SIGNAL(finished()), s3);
+
+    QState *s4 = new QState(machine.rootState());
+    s4->assignProperty(object, "foo", 2.0);
+    s3->addTransition(new EventTransition(QEvent::User, s4))->addAnimation(fooAnimation);
+
+    QState *s5 = new QState(machine.rootState());
+    QObject::connect(s5, SIGNAL(entered()), QApplication::instance(), SLOT(quit()));
+    s4->addTransition(fooAnimation, SIGNAL(finished()), s5);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 5.0);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s5));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+}
+
+void tst_QStateMachine::nestedTargetStateForAnimation()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+    object->setProperty("bar", 3.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    QState *s2 = new QState(machine.rootState());
+
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s2Child = new QState(s2);
+    s2Child->assignProperty(object, "bar", 10.0);
+    s2->setInitialState(s2Child);
+
+    QState *s2Child2 = new QState(s2);
+    s2Child2->assignProperty(object, "bar", 11.0);
+    QAbstractTransition *at = s2Child->addTransition(new EventTransition(QEvent::User, s2Child2));
+    
+    QPropertyAnimation *animation = new QPropertyAnimation(object, "bar", s2);
+    animation->setDuration(2000);
+    connect(animation, SIGNAL(finished()), &counter, SLOT(slot()));
+    at->addAnimation(animation);
+    
+    at = s1->addTransition(new EventTransition(QEvent::User, s2));
+
+    animation = new QPropertyAnimation(object, "foo", s2);
+    connect(animation, SIGNAL(finished()), &counter, SLOT(slot()));
+    at->addAnimation(animation);
+
+    animation = new QPropertyAnimation(object, "bar", s2);
+    connect(animation, SIGNAL(finished()), &counter, SLOT(slot()));
+    at->addAnimation(animation);
+    
+    QState *s3 = new QState(machine.rootState());
+    s2->addTransition(s2Child, SIGNAL(polished()), s3);
+
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+    machine.postEvent(new QEvent(QEvent::User));
+
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+    QCOMPARE(object->property("bar").toDouble(), 10.0);
+    QCOMPARE(counter.counter, 2);
+}
+
+void tst_QStateMachine::animatedGlobalRestoreProperty()
+{
+    QStateMachine machine;
+    machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+
+    QState *s4 = new QState(machine.rootState());
+    QObject::connect(s4, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    QPropertyAnimation *pa = new QPropertyAnimation(object, "foo", s2);
+    connect(pa, SIGNAL(finished()), &counter, SLOT(slot()));
+    at->addAnimation(pa);
+   
+    at = s2->addTransition(pa, SIGNAL(finished()), s3);
+    pa = new QPropertyAnimation(object, "foo", s3);
+    connect(pa, SIGNAL(finished()), &counter, SLOT(slot()));
+    at->addAnimation(pa);
+
+    at = s3->addTransition(pa, SIGNAL(finished()), s4);
+    pa = new QPropertyAnimation(object, "foo", s4);
+    connect(pa, SIGNAL(finished()), &counter, SLOT(slot()));
+    at->addAnimation(pa);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s4));
+    QCOMPARE(object->property("foo").toDouble(), 1.0);
+    QCOMPARE(counter.counter, 2);
+}
+
+void tst_QStateMachine::specificTargetValueOfAnimation()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+
+    QState *s1 = new QState(machine.rootState());
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QPropertyAnimation *anim = new QPropertyAnimation(object, "foo");
+    anim->setEndValue(10.0);
+    s1->addTransition(new EventTransition(QEvent::User, s2))->addAnimation(anim);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    s2->addTransition(anim, SIGNAL(finished()), s3);    
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+    QCOMPARE(anim->endValue().toDouble(), 10.0);
+}
+
+void tst_QStateMachine::addDefaultAnimation()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    QState *s1 = new QState(machine.rootState());
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+
+    QPropertyAnimation *pa = new QPropertyAnimation(object, "foo", &machine);
+    machine.addDefaultAnimation(pa);
+    s2->addTransition(pa, SIGNAL(finished()), s3);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+}
+
+void tst_QStateMachine::addDefaultAnimationWithUnusedAnimation()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+    object->setProperty("bar", 2.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+
+    QPropertyAnimation *pa = new QPropertyAnimation(object, "foo", &machine);
+    connect(pa, SIGNAL(finished()), &counter, SLOT(slot()));
+    machine.addDefaultAnimation(pa);
+    s2->addTransition(pa, SIGNAL(finished()), s3);
+
+    pa = new QPropertyAnimation(object, "bar", &machine);
+    connect(pa, SIGNAL(finished()), &counter, SLOT(slot()));
+    machine.addDefaultAnimation(pa);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+    QCOMPARE(counter.counter, 1);
+}
+
+void tst_QStateMachine::removeDefaultAnimation()
+{
+    QStateMachine machine;
+
+    QObject propertyHolder;
+    propertyHolder.setProperty("foo", 0);
+
+    QCOMPARE(machine.defaultAnimations().size(), 0);
+
+    QPropertyAnimation *anim = new QPropertyAnimation(&propertyHolder, "foo");
+
+    machine.addDefaultAnimation(anim);
+
+    QCOMPARE(machine.defaultAnimations().size(), 1);
+    QVERIFY(machine.defaultAnimations().contains(anim));
+
+    machine.removeDefaultAnimation(anim);
+
+    QCOMPARE(machine.defaultAnimations().size(), 0);
+
+    machine.addDefaultAnimation(anim);
+    
+    QPropertyAnimation *anim2 = new QPropertyAnimation(&propertyHolder, "foo");
+    machine.addDefaultAnimation(anim2);
+
+    QCOMPARE(machine.defaultAnimations().size(), 2);
+    QVERIFY(machine.defaultAnimations().contains(anim));
+    QVERIFY(machine.defaultAnimations().contains(anim2));
+
+    machine.removeDefaultAnimation(anim);
+
+    QCOMPARE(machine.defaultAnimations().size(), 1);
+    QVERIFY(machine.defaultAnimations().contains(anim2));
+
+    machine.removeDefaultAnimation(anim2);
+    QCOMPARE(machine.defaultAnimations().size(), 0);
+}
+
+void tst_QStateMachine::overrideDefaultAnimationWithSpecific()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject(&machine);
+    object->setProperty("foo", 1.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    
+    QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");    
+    connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    QPropertyAnimation *moreSpecificAnimation = new QPropertyAnimation(object, "foo");
+    s2->addTransition(moreSpecificAnimation, SIGNAL(finished()), s3);
+    connect(moreSpecificAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    machine.addDefaultAnimation(defaultAnimation);
+    at->addAnimation(moreSpecificAnimation);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(counter.counter, 2); // specific animation started and stopped
+}
+
+/*
+void tst_QStateMachine::addDefaultAnimationForSource()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    QState *s1 = new QState(machine.rootState());
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+
+    QPropertyAnimation *pa = new QPropertyAnimation(object, "foo", &machine);
+    machine.addDefaultAnimationForSourceState(s1, pa);
+    s2->addTransition(pa, SIGNAL(finished()), s3);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+}
+
+void tst_QStateMachine::addDefaultAnimationForTarget()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    QState *s1 = new QState(machine.rootState());
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+    
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+
+    QPropertyAnimation *pa = new QPropertyAnimation(object, "foo", &machine);
+    machine.addDefaultAnimationForTargetState(s2, pa);
+    s2->addTransition(pa, SIGNAL(finished()), s3);
+
+    machine.setInitialState(s1);
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(object->property("foo").toDouble(), 2.0);
+}
+
+void tst_QStateMachine::removeDefaultAnimationForSource()
+{
+    QStateMachine machine;
+
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 0);
+
+    QPropertyAnimation *anim = new QPropertyAnimation(this, "foo");
+
+    machine.addDefaultAnimationForSourceState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimations().size(), 0);
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 0);
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 1);
+    QVERIFY(machine.defaultAnimationsForSourceState(machine.rootState()).contains(anim));
+
+    machine.removeDefaultAnimationForTargetState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimations().size(), 0);
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 0);
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 1);
+    QVERIFY(machine.defaultAnimationsForSourceState(machine.rootState()).contains(anim));
+
+    machine.removeDefaultAnimationForSourceState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 0);
+
+    machine.addDefaultAnimationForSourceState(machine.rootState(), anim);
+    
+    QPropertyAnimation *anim2 = new QPropertyAnimation(this, "foo");
+    machine.addDefaultAnimationForSourceState(machine.rootState(), anim2);
+
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 2);
+    QVERIFY(machine.defaultAnimationsForSourceState(machine.rootState()).contains(anim));
+    QVERIFY(machine.defaultAnimationsForSourceState(machine.rootState()).contains(anim2));
+
+    machine.removeDefaultAnimationForSourceState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 1);
+    QVERIFY(machine.defaultAnimationsForSourceState(machine.rootState()).contains(anim2));
+
+    machine.removeDefaultAnimationForSourceState(machine.rootState(), anim2);
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 0);
+}
+
+void tst_QStateMachine::removeDefaultAnimationForTarget()
+{
+    QStateMachine machine;
+
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 0);
+
+    QPropertyAnimation *anim = new QPropertyAnimation(this, "foo");
+
+    machine.addDefaultAnimationForTargetState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimations().size(), 0);
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 0);
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 1);
+    QVERIFY(machine.defaultAnimationsForTargetState(machine.rootState()).contains(anim));
+
+    machine.removeDefaultAnimationForSourceState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimations().size(), 0);
+    QCOMPARE(machine.defaultAnimationsForSourceState(machine.rootState()).size(), 0);
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 1);
+    QVERIFY(machine.defaultAnimationsForTargetState(machine.rootState()).contains(anim));
+
+    machine.removeDefaultAnimationForTargetState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 0);
+
+    machine.addDefaultAnimationForTargetState(machine.rootState(), anim);
+    
+    QPropertyAnimation *anim2 = new QPropertyAnimation(this, "foo");
+    machine.addDefaultAnimationForTargetState(machine.rootState(), anim2);
+
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 2);
+    QVERIFY(machine.defaultAnimationsForTargetState(machine.rootState()).contains(anim));
+    QVERIFY(machine.defaultAnimationsForTargetState(machine.rootState()).contains(anim2));
+
+    machine.removeDefaultAnimationForTargetState(machine.rootState(), anim);
+
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 1);
+    QVERIFY(machine.defaultAnimationsForTargetState(machine.rootState()).contains(anim2));
+
+    machine.removeDefaultAnimationForTargetState(machine.rootState(), anim2);
+    QCOMPARE(machine.defaultAnimationsForTargetState(machine.rootState()).size(), 0);
+}
+
+void tst_QStateMachine::overrideDefaultAnimationWithSource()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));    
+    
+    QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");    
+    connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    QPropertyAnimation *moreSpecificAnimation = new QPropertyAnimation(object, "foo");
+    s2->addTransition(moreSpecificAnimation, SIGNAL(finished()), s3);
+    connect(moreSpecificAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    machine.addDefaultAnimation(defaultAnimation);
+    machine.addDefaultAnimationForSourceState(s1, moreSpecificAnimation);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(counter.counter, 2); // specific animation started and stopped
+}
+
+void tst_QStateMachine::overrideDefaultAnimationWithTarget()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));    
+    
+    QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");    
+    connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    QPropertyAnimation *moreSpecificAnimation = new QPropertyAnimation(object, "foo");
+    s2->addTransition(moreSpecificAnimation, SIGNAL(finished()), s3);
+    connect(moreSpecificAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    machine.addDefaultAnimation(defaultAnimation);
+    machine.addDefaultAnimationForTargetState(s2, moreSpecificAnimation);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(counter.counter, 2); // specific animation started and stopped
+
+}
+
+void tst_QStateMachine::overrideDefaultSourceAnimationWithSpecific()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    
+    QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");    
+    connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    QPropertyAnimation *moreSpecificAnimation = new QPropertyAnimation(object, "foo");
+    s2->addTransition(moreSpecificAnimation, SIGNAL(finished()), s3);
+    connect(moreSpecificAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    machine.addDefaultAnimationForSourceState(s1, defaultAnimation);
+    at->addAnimation(moreSpecificAnimation);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(counter.counter, 2); // specific animation started and stopped
+}
+
+void tst_QStateMachine::overrideDefaultTargetAnimationWithSpecific()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    QAbstractTransition *at = s1->addTransition(new EventTransition(QEvent::User, s2));
+    
+    QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");    
+    connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    QPropertyAnimation *moreSpecificAnimation = new QPropertyAnimation(object, "foo");
+    s2->addTransition(moreSpecificAnimation, SIGNAL(finished()), s3);
+    connect(moreSpecificAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    machine.addDefaultAnimationForTargetState(s2, defaultAnimation);
+    at->addAnimation(moreSpecificAnimation);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(counter.counter, 2); // specific animation started and stopped
+}
+
+void tst_QStateMachine::overrideDefaultTargetAnimationWithSource()
+{
+    QStateMachine machine;
+
+    QObject *object = new QObject();
+    object->setProperty("foo", 1.0);
+
+    SlotCalledCounter counter;
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(object, "foo", 2.0);
+
+    QState *s3 = new QState(machine.rootState());
+    QObject::connect(s3, SIGNAL(entered()), QCoreApplication::instance(), SLOT(quit()));
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    
+    QPropertyAnimation *defaultAnimation = new QPropertyAnimation(object, "foo");    
+    connect(defaultAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    QPropertyAnimation *moreSpecificAnimation = new QPropertyAnimation(object, "foo");
+    s2->addTransition(moreSpecificAnimation, SIGNAL(finished()), s3);
+    connect(moreSpecificAnimation, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), &counter, SLOT(slot()));
+
+    machine.addDefaultAnimationForTargetState(s2, defaultAnimation);
+    machine.addDefaultAnimationForSourceState(s1, moreSpecificAnimation);
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCOREAPPLICATION_EXEC(5000);
+
+    QVERIFY(machine.configuration().contains(s3));
+    QCOMPARE(counter.counter, 2); // specific animation started and stopped
+}
+
+*/
+
+void tst_QStateMachine::parallelStateAssignmentsDone()
+{
+    QStateMachine machine;
+
+    QObject *propertyHolder = new QObject(&machine);
+    propertyHolder->setProperty("foo", 123);
+    propertyHolder->setProperty("bar", 456);
+    propertyHolder->setProperty("zoot", 789);
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *parallelState = new QState(QState::ParallelStates, machine.rootState());
+    parallelState->assignProperty(propertyHolder, "foo", 321);
+
+    QState *s2 = new QState(parallelState);
+    s2->assignProperty(propertyHolder, "bar", 654);
+
+    QState *s3 = new QState(parallelState);
+    s3->assignProperty(propertyHolder, "zoot", 987);
+
+    s1->addTransition(new EventTransition(QEvent::User, parallelState));
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("foo").toInt(), 123);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 456);
+    QCOMPARE(propertyHolder->property("zoot").toInt(), 789);
+    
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(propertyHolder->property("foo").toInt(), 321);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 654);
+    QCOMPARE(propertyHolder->property("zoot").toInt(), 987);
+}
+
+void tst_QStateMachine::transitionsFromParallelStateWithNoChildren()
+{
+    QStateMachine machine;
+    
+    QState *parallelState = new QState(QState::ParallelStates, machine.rootState());
+    machine.setInitialState(parallelState);
+
+    QState *s1 = new QState(machine.rootState());    
+    parallelState->addTransition(new EventTransition(QEvent::User, s1));
+    
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(1, machine.configuration().size());
+    QVERIFY(machine.configuration().contains(parallelState));
+
+    machine.postEvent(new QEvent(QEvent::User));
+
+    QCoreApplication::processEvents();
+
+    QCOMPARE(1, machine.configuration().size());
+    QVERIFY(machine.configuration().contains(s1));
+}
+
+void tst_QStateMachine::parallelStateTransition()
+{
+    QStateMachine machine;
+
+    QState *parallelState = new QState(QState::ParallelStates, machine.rootState());
+    machine.setInitialState(parallelState);
+
+    QState *s1 = new QState(parallelState);
+    QState *s2 = new QState(parallelState);
+
+    QState *s1InitialChild = new QState(s1);
+    s1->setInitialState(s1InitialChild);
+
+    QState *s2InitialChild = new QState(s2);
+    s2->setInitialState(s2InitialChild);
+
+    QState *s1OtherChild = new QState(s1);    
+
+    s1->addTransition(new EventTransition(QEvent::User, s1OtherChild));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QVERIFY(machine.configuration().contains(parallelState));
+    QVERIFY(machine.configuration().contains(s1));
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s1InitialChild));
+    QVERIFY(machine.configuration().contains(s2InitialChild));
+    QCOMPARE(machine.configuration().size(), 5);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QVERIFY(machine.configuration().contains(parallelState));
+
+    QVERIFY(machine.configuration().contains(s1));
+    
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s1OtherChild));
+    QVERIFY(machine.configuration().contains(s2InitialChild));
+    QCOMPARE(machine.configuration().size(), 5);
+    
+}
+
+void tst_QStateMachine::nestedRestoreProperties()
+{
+    QStateMachine machine;
+    machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
+
+    QObject *propertyHolder = new QObject(&machine);
+    propertyHolder->setProperty("foo", 1);
+    propertyHolder->setProperty("bar", 2);
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(propertyHolder, "foo", 3);
+
+    QState *s21 = new QState(s2);
+    s21->assignProperty(propertyHolder, "bar", 4);
+    s2->setInitialState(s21);
+
+    QState *s22 = new QState(s2);
+    s22->assignProperty(propertyHolder, "bar", 5);
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s21->addTransition(new EventTransition(QEvent::User, s22));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s1));
+    QCOMPARE(propertyHolder->property("foo").toInt(), 1);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s21));
+    QCOMPARE(propertyHolder->property("foo").toInt(), 3);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s22));
+    QCOMPARE(propertyHolder->property("foo").toInt(), 3);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 5);
+}
+
+void tst_QStateMachine::nestedRestoreProperties2()
+{
+    QStateMachine machine;
+    machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);
+
+    QObject *propertyHolder = new QObject(&machine);
+    propertyHolder->setProperty("foo", 1);
+    propertyHolder->setProperty("bar", 2);
+
+    QState *s1 = new QState(machine.rootState());
+    machine.setInitialState(s1);
+
+    QState *s2 = new QState(machine.rootState());
+    s2->assignProperty(propertyHolder, "foo", 3);
+
+    QState *s21 = new QState(s2);
+    s21->assignProperty(propertyHolder, "bar", 4);    
+    s2->setInitialState(s21);
+
+    QState *s22 = new QState(s2);
+    s22->assignProperty(propertyHolder, "foo", 6);
+    s22->assignProperty(propertyHolder, "bar", 5);
+
+    s1->addTransition(new EventTransition(QEvent::User, s2));
+    s21->addTransition(new EventTransition(QEvent::User, s22));
+    s22->addTransition(new EventTransition(QEvent::User, s21));
+
+    machine.start();
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 1);
+    QVERIFY(machine.configuration().contains(s1));
+    QCOMPARE(propertyHolder->property("foo").toInt(), 1);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 2);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s21));
+    QCOMPARE(propertyHolder->property("foo").toInt(), 3);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 4);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s22));
+    QCOMPARE(propertyHolder->property("foo").toInt(), 6);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 5);
+
+    machine.postEvent(new QEvent(QEvent::User));
+    QCoreApplication::processEvents();
+
+    QCOMPARE(machine.configuration().size(), 2);
+    QVERIFY(machine.configuration().contains(s2));
+    QVERIFY(machine.configuration().contains(s21));
+    QCOMPARE(propertyHolder->property("foo").toInt(), 3);
+    QCOMPARE(propertyHolder->property("bar").toInt(), 4);
+
+}
+
+
+QTEST_MAIN(tst_QStateMachine)
+#include "tst_qstatemachine.moc"
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"