Merge commit 'qt/master-stable'

Conflicts:
	src/corelib/kernel/qobject.cpp
	src/corelib/tools/qsharedpointer_impl.h
	src/gui/widgets/qdatetimeedit.cpp
	src/gui/widgets/qlinecontrol.cpp
	src/gui/widgets/qlineedit.cpp
	tests/auto/qcssparser/qcssparser.pro
	tests/auto/qicoimageformat/tst_qicoimageformat.cpp
	tests/auto/qmultiscreen/qmultiscreen.pro
	tests/auto/qresourceengine/qresourceengine.pro
	tests/auto/qresourceengine/tst_qresourceengine.cpp
	tests/auto/qscriptv8testsuite/tst_qscriptv8testsuite.cpp

18 files changed, 2742 insertions, 7 deletions

diff --git a/tools/qtestlib/wince/cetcpsync/cetcpsync.pro b/tools/qtestlib/wince/cetcpsync/cetcpsync.pro
new file mode 100644
index 0000000..d1d7c99
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsync/cetcpsync.pro
@@ -0,0 +1,22 @@
+TARGET   = cetcpsync
+DESTDIR = ../../../../bin
+CONFIG   += console
+CONFIG   -= app_bundle
+QT       += network
+QT       -= gui
+TEMPLATE = app
+
+build_all:!build_pass {
+    CONFIG -= build_all
+    CONFIG += release
+}
+
+INCLUDEPATH += ../cetcpsyncserver
+
+SOURCES += main.cpp \
+           remoteconnection.cpp \
+           qtcesterconnection.cpp
+
+HEADERS += \
+           remoteconnection.h \
+           qtcesterconnection.h
diff --git a/tools/qtestlib/wince/cetcpsync/main.cpp b/tools/qtestlib/wince/cetcpsync/main.cpp
new file mode 100644
index 0000000..73c7350
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsync/main.cpp
@@ -0,0 +1,191 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <iostream>
+#include "qtcesterconnection.h"
+
+using namespace std;
+
+static void showUsage()
+{
+    cout    << "cetcpsync is meant to be used by cetest internally." << endl
+            << "For usage instructions remoteconnection.h could be useful." << endl;
+}
+
+const int debugLevel = 0;
+void debugOutput(const QString& text, int level)
+{
+    if (level <= debugLevel)
+        cout << qPrintable(text) << endl;
+}
+
+class Exception
+{
+public:
+    Exception(const QString& msg = QString())
+        : m_message(msg)
+    {}
+
+    QString message() { return m_message; }
+
+protected:
+    QString m_message;
+};
+
+class TooFewParametersException : public Exception
+{
+public:
+    TooFewParametersException(const QLatin1String& cmd, int expectedParameterCount)
+    {
+        m_message = QLatin1String("Command ") + cmd + QLatin1String(" needs at least ");
+        m_message.append(QString::number(expectedParameterCount));
+        m_message.append(QLatin1String(" parameters."));
+    }
+};
+
+static void fileTimeFromString(FILETIME& ft, const QString& str)
+{
+    int idx = str.indexOf("*");
+    if (idx <= 0)
+        return;
+    ft.dwLowDateTime = str.left(idx).toULong();
+    ft.dwHighDateTime = str.mid(idx+1).toULong();
+}
+
+static QString fileTimeToString(FILETIME& ft)
+{
+    return QString::number(ft.dwLowDateTime) + "*" + QString::number(ft.dwHighDateTime);
+}
+
+static int execCommand(const QLatin1String& cmd, int argc, char* argv[])
+{
+    int retval = 0;
+    bool success = true;
+    QtCesterConnection connection;
+    if (cmd == "copyFileToDevice") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.copyFileToDevice(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "copyDirectoryToDevice") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.copyDirectoryToDevice(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "copyFileFromDevice") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.copyFileFromDevice(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "copyDirectoryFromDevice") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.copyDirectoryFromDevice(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "timeStampForLocalFileTime") {
+        if (argc < 1)
+            throw TooFewParametersException(cmd, 1);
+        FILETIME ft;
+        fileTimeFromString(ft, argv[0]);
+        success = connection.timeStampForLocalFileTime(&ft);
+        if (success)
+            cout << qPrintable(fileTimeToString(ft));
+    } else if (cmd == "fileCreationTime") {
+        if (argc < 1)
+            throw TooFewParametersException(cmd, 1);
+        FILETIME ft;
+        success = connection.fileCreationTime(argv[0], &ft);
+        if (success)
+            cout << qPrintable(fileTimeToString(ft));
+    } else if (cmd == "copyFile") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.copyFile(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "copyDirectory") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.copyDirectory(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "deleteFile") {
+        if (argc < 1)
+            throw TooFewParametersException(cmd, 1);
+        success = connection.deleteFile(argv[0]);
+    } else if (cmd == "deleteDirectory") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.deleteDirectory(argv[0], argv[1] == "true", argv[2] == "true");
+    } else if (cmd == "moveFile") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.moveFile(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "moveDirectory") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        success = connection.moveDirectory(argv[0], argv[1], argv[2] == "true");
+    } else if (cmd == "createDirectory") {
+        if (argc < 2)
+            throw TooFewParametersException(cmd, 2);
+        success = connection.createDirectory(argv[0], argv[1] == "true");
+    } else if (cmd == "execute") {
+        if (argc < 3)
+            throw TooFewParametersException(cmd, 3);
+        int timeout = QString(argv[2]).toInt();
+        success = connection.execute(argv[0], argv[1], timeout, &retval);
+    } else if (cmd == "noop") {
+        // do nothing :)
+        success = true;
+    } else {
+        throw Exception("unknown command");
+    }
+
+    return success ? retval : 1;
+}
+
+int main(int argc, char *argv[])
+{
+    if (argc <= 1) {
+        showUsage();
+        return 0;
+    }
+
+    QLatin1String param(argv[1]);
+    int result = 1;
+    try {
+        result = execCommand(param, argc - 2, argv + 2);
+    } catch (Exception e) {
+        cerr << "Error: " << qPrintable(e.message());
+    }
+    return result;
+}
diff --git a/tools/qtestlib/wince/cetcpsync/qtcesterconnection.cpp b/tools/qtestlib/wince/cetcpsync/qtcesterconnection.cpp
new file mode 100644
index 0000000..76d3b4b
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsync/qtcesterconnection.cpp
@@ -0,0 +1,552 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qtcesterconnection.h"
+#include <transfer_global.h>
+#include <QtCore/QDir>
+#include <QtCore/QFile>
+#include <QtCore/QFileInfo>
+#include <QtNetwork/QTcpSocket>
+#include <QtNetwork/QHostAddress>
+
+extern void debugOutput(const QString& text, int level);
+
+#pragma warning(disable:4996)
+
+#define END_ERROR(s, a) \
+            if(a) qDebug() << a; \
+            _freeSocket(s); \
+            return false;
+
+QtCesterConnection::QtCesterConnection()
+        : AbstractRemoteConnection()
+{
+}
+
+QtCesterConnection::~QtCesterConnection()
+{
+}
+
+bool QtCesterConnection::connect(QVariantList&)
+{
+    // We connect with each command, so this is always true
+    // The command itself will fail then
+    connected = true;
+    return true;
+}
+
+void QtCesterConnection::disconnect()
+{
+    connected = false;
+}
+
+bool QtCesterConnection::isConnected() const
+{
+    return connected;
+}
+
+bool QtCesterConnection::copyFileToDevice(const QString &localSource, const QString &deviceDest, bool failIfExists)
+{
+    debugOutput( qPrintable(QString::fromLatin1("Copy File: %1 -> %2").arg(localSource).arg(deviceDest)),0);
+    QFile localFile(localSource);
+    QFileInfo info(localSource);
+    if (!localFile.exists() || !localFile.open(QIODevice::ReadOnly)) {
+        qDebug() << "Could not open File!";
+        return false;
+    }
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_CREATE_FILE)) {
+        END_ERROR(socket, "Could not initialized command");
+    }
+    
+    CreateFileOptions option;
+    strcpy(option.fileName, qPrintable(deviceDest));
+#ifdef Q_OS_WIN
+    // Copy FileTime for update verification
+    FILETIME creationTime, accessTime, writeTime;
+    HANDLE localHandle = CreateFile(localSource.utf16(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
+    if (localHandle != INVALID_HANDLE_VALUE) {
+        if (GetFileTime(localHandle, &creationTime, &accessTime, &writeTime)) {
+            LocalFileTimeToFileTime(&writeTime, &writeTime);
+            option.fileTime = writeTime;
+        }
+        CloseHandle(localHandle);
+    }
+    DWORD attributes = GetFileAttributes(localSource.utf16());
+    if (attributes != -1 )
+        option.fileAttributes = attributes;
+#endif
+    option.fileSize = info.size();
+    option.overwriteExisting = !failIfExists;
+    
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send options...");
+    }
+
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Server did not accept configuration");
+    }
+    
+    int bytesWritten = 0;
+    const int bufferSize = 1024;
+    QByteArray data;
+    while (bytesWritten < option.fileSize) {
+        data = localFile.read(bufferSize);
+        bytesWritten += data.size();
+#ifdef Q_OS_WIN
+        wprintf( L"%s -> %s (%d / %d) %d %%\r", localSource.utf16() , deviceDest.utf16(),
+                 bytesWritten , option.fileSize, (100*bytesWritten)/option.fileSize );
+#endif
+        if (!_sendData(socket, data.constData(), data.size())) {
+            END_ERROR(socket, "Error during file transfer");
+        }
+        if (!_checkResult(socket)) {
+            END_ERROR(socket, "Got some strange result");
+        }
+    }
+#ifdef Q_OS_WIN
+    wprintf( L"\n"); // We should jump to next line...
+#endif
+    if (bytesWritten != option.fileSize) {
+        END_ERROR(socket, "Did not send sufficient data");
+    }
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::copyDirectoryToDevice(const QString &localSource, const QString &deviceDest, bool recursive)
+{
+    QTcpSocket* socket = NULL;
+    QFileInfo info(localSource);
+    if (!info.exists() || !info.isDir()) {
+        END_ERROR(socket, "Input directory invalid");
+    }
+    
+    createDirectory(deviceDest, true);
+    QDir dir(localSource);
+    QFileInfoList list = dir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
+    foreach(QFileInfo item, list) {
+        QString targetName = deviceDest + QLatin1String("\\") + item.fileName();
+        if (item.isDir()) {
+            if (recursive) {
+                if (!copyDirectoryToDevice(item.absoluteFilePath() , targetName, recursive))
+                    return false;
+            }
+        } else {
+            if (!copyFileToDevice(item.absoluteFilePath(), targetName))
+                return false;
+        }
+    }
+    return true;
+}
+
+bool QtCesterConnection::copyFileFromDevice(const QString &deviceSource, const QString &localDest, bool failIfExists)
+{
+    QFile targetFile(localDest);
+    QTcpSocket* socket = 0;
+    if (targetFile.exists() && failIfExists) {
+        END_ERROR(socket, "Local file not supposed to be overwritten");
+    }
+    
+    if (!targetFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+        END_ERROR(socket, "Could not open local file for writing");
+    }
+    
+    if (!_initCommand(socket, COMMAND_READ_FILE)) {
+        END_ERROR(socket, "Could not establish connection");
+    }
+    
+    ReadFileOptions option;
+    strcpy(option.fileName, qPrintable(deviceSource));
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send options");
+    }
+    
+    QByteArray data;
+    if (!_receiveData(socket, data)) {
+        END_ERROR(socket, "Did not receive any data");
+    }
+    
+    ReadFileReply* reply = (ReadFileReply*) data.data();
+    if (!reply->fileValid) {
+        END_ERROR(socket, "Requested file invalid");
+    }
+    
+    int fileSize = reply->fileSize;
+    int currentSize = 0;
+    // ### TODO: make a little bit more error-prone
+    do {
+        _sendData(socket, COMMAND_SUCCESS, strlen(COMMAND_SUCCESS));
+        _receiveData(socket, data);
+        currentSize += data.size();
+        targetFile.write(data);
+    } while(currentSize < fileSize);
+    
+    _freeSocket(socket);
+    targetFile.close();
+    return true;
+}
+ 
+bool QtCesterConnection::copyDirectoryFromDevice(const QString& /*deviceSource*/
+                                                 , const QString& /*localDest*/
+                                                 , bool /*recursive*/)
+{
+    qDebug() << "To be implemented!! Should not be needed for autotest system";
+    exit(-1);
+    return false;
+}
+
+bool QtCesterConnection::copyFile(const QString &srcFile, const QString &destFile, bool failIfExists)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_COPY_FILE)) {
+        END_ERROR(socket, "Could not establish connection for copy");
+    }
+    
+    CopyFileOptions option;
+    strcpy(option.from, qPrintable(srcFile));
+    strcpy(option.to, qPrintable(destFile));
+    option.overwriteExisting = !failIfExists;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send copy options");
+    }
+    
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Copy failed");
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::copyDirectory(const QString &srcDirectory, const QString &destDirectory,
+                                      bool recursive)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_COPY_DIRECTORY)) {
+        END_ERROR(socket, "Could not establish connection for dir copy");
+    }
+    
+    CopyDirectoryOptions option;
+    strcpy(option.from, qPrintable(srcDirectory));
+    strcpy(option.to, qPrintable(destDirectory));
+    option.recursive = recursive;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send dir copy options");
+    }
+    
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Dir Copy failed");
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::deleteFile(const QString &fileName)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_DELETE_FILE)) {
+        END_ERROR(socket, "Could not establish connection for file deletion");
+    }
+    
+    DeleteFileOptions option;
+    strcpy(option.fileName, qPrintable(fileName));
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send file options");
+    }
+    
+    if (!_checkResult(socket)) {
+        //END_ERROR(socket, "File Deletion failed");
+        // This is actually not an error so ignore it.
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::deleteDirectory(const QString &directory, bool recursive, bool failIfContentExists)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_DELETE_DIRECTORY)) {
+        END_ERROR(socket, "Could not establish connection for dir deletion");
+    }
+    
+    DeleteDirectoryOptions option;
+    strcpy(option.dirName, qPrintable(directory));
+    option.recursive = recursive;
+    option.failIfContentExists = failIfContentExists;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send dir options");
+    }
+    
+    if (!_checkResult(socket)) {
+        // we do not write an error as this will fail a lot on recursive.
+        END_ERROR(socket, 0);
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::execute(QString program,
+                                 QString arguments,
+                                 int timeout,
+                                 int *returnValue)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_EXECUTE)) {
+        END_ERROR(socket, "Could not establish connection for dir deletion");
+    }
+
+    ExecuteOptions options;
+    strcpy(options.appName, qPrintable(program));
+    QStringList argList = arguments.split(QLatin1Char(' '));
+    options.argumentsCount = qMin(argList.size(), MAX_ARGUMENTS);
+    options.waitForFinished = true;
+    options.timeout = timeout;
+    if (!_sendData(socket, (char*) &options, sizeof(options))) {
+        END_ERROR(socket, "Could not send dir options");
+    }
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Did not receive an answer");
+    }
+
+    for (int i=0; i < options.argumentsCount; ++i) {
+        char someData[MAX_NAME_LENGTH];
+        strcpy(someData, qPrintable(argList[i]));
+        if (!_sendData(socket, someData, MAX_NAME_LENGTH)) {
+            END_ERROR(socket, "Could not send argument");
+        }
+        if (!_checkResult(socket)) {
+            END_ERROR(socket, "Failure in argument send");
+        }
+    }
+
+    // trigger the startup
+    if (!_sendData(socket, COMMAND_SUCCESS, strlen(COMMAND_SUCCESS))) {
+        END_ERROR(socket, "Could not trigger startup");
+    }
+    
+    const int waitTime = 60 * 60 * 1000;
+    if (!socket->waitForReadyRead(waitTime)) {
+        END_ERROR(socket, "Process timed out");
+    }
+    
+    QByteArray result = socket->readAll();
+    if (result != COMMAND_SUCCESS) {
+        if (returnValue)
+            *returnValue = -1; // just some at least
+        END_ERROR(socket, "Application did not start or returned error");
+    }
+    
+    if (returnValue)
+        *returnValue = 0;
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::createDirectory(const QString &path, bool deleteBefore)
+{
+    if (deleteBefore)
+        deleteDirectory(path, true, true);
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_CREATE_DIRECTORY)) {
+        END_ERROR(socket, "Could not establish connection for dir creation");
+    }
+    
+    CreateDirectoryOptions option;
+    strcpy(option.dirName, qPrintable(path));
+    option.recursively = true;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send dir options");
+    }
+    
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Dir creation failed");
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::timeStampForLocalFileTime(FILETIME* fTime) const
+{
+    if (!fTime)
+        return false;
+    
+    FILETIME copyTime = *fTime;
+    LocalFileTimeToFileTime(&copyTime, &copyTime);
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_TIME_STAMP)) {
+        END_ERROR(socket, "Could not establish time stamp connection");
+    }
+    
+    if (!_sendData(socket, (char*) &copyTime, sizeof(copyTime))) {
+        END_ERROR(socket, "Could not send stamp time");
+    }
+    
+    QByteArray data;
+    if (!_receiveData(socket, data)) {
+        END_ERROR(socket, "Did not receive time stamp or connection interrupted");
+    }
+    
+    copyTime = *((FILETIME*)data.data());
+    if (copyTime.dwLowDateTime == -1 && copyTime.dwHighDateTime == -1) {
+        END_ERROR(socket, "remote Time stamp failed!");
+    }
+    
+    *fTime = copyTime;
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::fileCreationTime(const QString &fileName, FILETIME* deviceCreationTime) const
+{
+    if (!deviceCreationTime)
+        return false;
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_FILE_TIME)) {
+        END_ERROR(socket, "Could not establish connection for file time access");
+    }
+    
+    FileTimeOptions option;
+    strcpy(option.fileName, qPrintable(fileName));
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send file time name");
+    }
+    
+    QByteArray data;
+    if (!_receiveData(socket, data)) {
+        END_ERROR(socket, "File Time request failed");
+    }
+    
+    FILETIME* resultTime = (FILETIME*) data.data();
+    if (resultTime->dwLowDateTime == -1 && resultTime->dwHighDateTime == -1) {
+        END_ERROR(socket, 0);
+        debugOutput("Could not access file time", 0);
+    }
+    
+    *deviceCreationTime = *resultTime;
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::_createSocket(QTcpSocket*& result) const
+{
+    QTcpSocket* sock = new QTcpSocket();
+    QByteArray ipAddress = qgetenv("DEVICE_IP");
+    if (ipAddress.isEmpty()) {
+        qWarning("Error: You need to have DEVICE_IP set");
+        exit(0);
+    }
+    sock->connectToHost(QHostAddress(QString(ipAddress)), 12145);
+    
+    if (!sock->waitForConnected()) {
+        qDebug() << "connection timeout...";
+        result = NULL;
+        return false;
+    }
+    result = sock;
+    return true;
+}
+
+void QtCesterConnection::_freeSocket(QTcpSocket*& sock) const
+{
+    if (!sock)
+        return;
+    if (sock->state() == QAbstractSocket::ConnectedState) {
+        sock->disconnectFromHost();
+        // seems like no need to wait
+        //sock->waitForDisconnected();
+    }
+    delete sock;
+    sock = NULL;
+#ifdef Q_OS_WIN
+    Sleep(100);
+#endif
+}
+
+bool QtCesterConnection::_initCommand(QTcpSocket*& sock, const char* command) const
+{
+    QTcpSocket* socket = NULL;
+    if (!_createSocket(socket)) {
+        END_ERROR(socket, "Could not connect to server");
+    }
+    
+    if (!_sendData(socket, command, strlen(command)) || 
+        !_checkResult(socket)) {
+        END_ERROR(socket, "Cound not send command");
+    }
+    sock = socket;
+    return true;
+}
+
+bool QtCesterConnection::_sendData(QTcpSocket*& sock, const char* data, int dataSize) const
+{
+    int amount = sock->write(data, dataSize);
+    if (amount != dataSize) {
+        fprintf(stderr, "*******COULD NOT SEND ENOUGH DATA*************\n");
+    }
+    return sock->waitForBytesWritten();
+}
+
+bool QtCesterConnection::_receiveData(QTcpSocket*& sock, QByteArray& data) const
+{
+    if (!sock->waitForReadyRead()) {
+        qDebug() << "did not receive any data";
+        return false;
+    }
+    data = sock->readAll();
+    return true;
+}
+
+bool QtCesterConnection::_checkResult(QTcpSocket*& sock) const
+{
+    QByteArray response;
+    if (!_receiveData(sock, response) || response != COMMAND_SUCCESS)
+        return false;
+    return true;
+}
+
diff --git a/tools/qtestlib/wince/cetcpsync/qtcesterconnection.h b/tools/qtestlib/wince/cetcpsync/qtcesterconnection.h
new file mode 100644
index 0000000..d7b8393
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsync/qtcesterconnection.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef ACTIVESYNC_REMOTECONNECTION_H
+#define ACTIVESYNC_REMOTECONNECTION_H
+
+#include "remoteconnection.h"
+
+class QTcpSocket;
+
+class QtCesterConnection : public AbstractRemoteConnection
+{
+public:
+    QtCesterConnection();
+    virtual ~QtCesterConnection();
+
+    bool connect(QVariantList &list = QVariantList());
+    void disconnect();
+    bool isConnected() const;
+
+    // These functions are designed for transfer between desktop and device
+    // Caution: deviceDest path has to be device specific (eg. no drive letters for CE)
+    bool copyFileToDevice(const QString &localSource, const QString &deviceDest, bool failIfExists = false);
+    bool copyDirectoryToDevice(const QString &localSource, const QString &deviceDest, bool recursive = true);
+    bool copyFileFromDevice(const QString &deviceSource, const QString &localDest, bool failIfExists = false);
+    bool copyDirectoryFromDevice(const QString &deviceSource, const QString &localDest, bool recursive = true);
+
+    bool timeStampForLocalFileTime(FILETIME*) const;
+    bool fileCreationTime(const QString &fileName, FILETIME*) const;
+
+    // These functions only work on files existing on the device
+    bool copyFile(const QString&, const QString&, bool failIfExists = false);
+    bool copyDirectory(const QString&, const QString&, bool recursive = true);
+    bool deleteFile(const QString&);
+    bool deleteDirectory(const QString&, bool recursive = true, bool failIfContentExists = false);
+    bool createDirectory(const QString&, bool deleteBefore=false);
+
+    bool execute(QString program, QString arguments = QString(), int timeout = -1, int *returnValue = NULL);
+private:
+    bool _createSocket(QTcpSocket*&) const;
+    void _freeSocket(QTcpSocket*&) const;
+    bool _initCommand(QTcpSocket*&, const char*) const;
+    bool _sendData(QTcpSocket*&, const char* data, int dataSize) const;
+    bool _receiveData(QTcpSocket*&, QByteArray&) const;
+    bool _checkResult(QTcpSocket*&) const;
+    bool connected;
+};
+
+#endif
diff --git a/tools/qtestlib/wince/cetcpsync/remoteconnection.cpp b/tools/qtestlib/wince/cetcpsync/remoteconnection.cpp
new file mode 100644
index 0000000..b197c5c
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsync/remoteconnection.cpp
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "remoteconnection.h"
+
+AbstractRemoteConnection::AbstractRemoteConnection()
+{
+}
+
+AbstractRemoteConnection::~AbstractRemoteConnection()
+{
+}
+
+// Slow but should be ok...
+bool AbstractRemoteConnection::moveFile(const QString &src, const QString &dest, bool FailIfExists)
+{
+    bool result = copyFile(src, dest, FailIfExists);
+    deleteFile(src);
+    return result;
+}
+
+// Slow but should be ok...
+bool AbstractRemoteConnection::moveDirectory(const QString &src, const QString &dest, bool recursive)
+{
+    bool result = copyDirectory(src, dest, true);
+    deleteDirectory(src, recursive);
+    return result;
+}
diff --git a/tools/qtestlib/wince/cetcpsync/remoteconnection.h b/tools/qtestlib/wince/cetcpsync/remoteconnection.h
new file mode 100644
index 0000000..fae6f7f
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsync/remoteconnection.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef REMOTECONNECTION_H
+#define REMOTECONNECTION_H
+
+#include <QtCore/QString>
+#include <QtCore/QVariant>
+#include <windows.h>
+class AbstractRemoteConnection
+{
+public:
+    AbstractRemoteConnection();
+    virtual ~AbstractRemoteConnection();
+
+    virtual bool connect(QVariantList&) = 0;
+    virtual void disconnect() = 0;
+    virtual bool isConnected() const = 0;
+
+    // These functions are designed for transfer between desktop and device
+    // Caution: deviceDest path has to be device specific (eg. no drive letters for CE)
+    virtual bool copyFileToDevice(const QString &localSource, const QString &deviceDest, bool failIfExists = false) = 0;
+    virtual bool copyDirectoryToDevice(const QString &localSource, const QString &deviceDest, bool recursive = true) = 0;
+    virtual bool copyFileFromDevice(const QString &deviceSource, const QString &localDest, bool failIfExists = false) = 0;
+    virtual bool copyDirectoryFromDevice(const QString &deviceSource, const QString &localDest, bool recursive = true) = 0;
+
+    // For "intelligent deployment" we need to investigate on filetimes on the device
+    virtual bool timeStampForLocalFileTime(FILETIME*) const = 0;
+    virtual bool fileCreationTime(const QString &fileName, FILETIME*) const = 0;
+    
+    // These functions only work on files existing on the device
+    virtual bool copyFile(const QString&, const QString&, bool failIfExists = false) = 0;
+    virtual bool copyDirectory(const QString&, const QString&, bool recursive = true) = 0;
+    virtual bool deleteFile(const QString&) = 0;
+    virtual bool deleteDirectory(const QString&, bool recursive = true, bool failIfContentExists = false) = 0;
+    bool moveFile(const QString&, const QString&, bool FailIfExists = false);
+    bool moveDirectory(const QString&, const QString&, bool recursive = true);
+
+    virtual bool createDirectory(const QString&, bool deleteBefore=false) = 0;
+
+    virtual bool execute(QString program, QString arguments = QString(), int timeout = -1, int *returnValue = NULL) = 0;
+};
+
+#endif
diff --git a/tools/qtestlib/wince/cetcpsyncserver/cetcpsyncserver.pro b/tools/qtestlib/wince/cetcpsyncserver/cetcpsyncserver.pro
new file mode 100644
index 0000000..bd01d2d
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsyncserver/cetcpsyncserver.pro
@@ -0,0 +1,17 @@
+TEMPLATE = app
+TARGET = cetcpsyncsvr
+DEPENDPATH += .
+QT -= gui
+QT += network
+
+CONFIG += console
+
+HEADERS +=  \
+            connectionmanager.h \
+            commands.h \
+            transfer_global.h
+
+SOURCES +=  \
+            connectionmanager.cpp \
+            commands.cpp \
+            main.cpp
diff --git a/tools/qtestlib/wince/cetcpsyncserver/commands.cpp b/tools/qtestlib/wince/cetcpsyncserver/commands.cpp
new file mode 100644
index 0000000..0c4d3bc
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsyncserver/commands.cpp
@@ -0,0 +1,686 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "commands.h"
+#include <QtCore/QDebug>
+#include <QtCore/QFileInfo>
+#include <QtCore/QDir>
+#include <QtCore/QProcess>
+
+#ifdef Q_OS_WINCE
+#include <windows.h>
+#endif
+
+/////////////////////////////////////////////////////
+//       Abstract Command Implementation           //
+/////////////////////////////////////////////////////
+AbstractCommand::AbstractCommand()
+: m_socket(0)
+{
+}
+
+AbstractCommand::~AbstractCommand()
+{
+}
+
+void AbstractCommand::reportSuccess()
+{
+    m_socket->write(COMMAND_SUCCESS, strlen(COMMAND_SUCCESS));
+    m_socket->waitForBytesWritten();
+}
+
+void AbstractCommand::reportError()
+{
+    m_socket->write(COMMAND_ERROR, strlen(COMMAND_ERROR));
+    m_socket->waitForBytesWritten();
+}
+
+void AbstractCommand::dataReceived(QByteArray&)
+{
+    debugOutput(1, "AbstractCommand::dataReceived NOT SUPPOSED TO BE HERE");
+}
+
+void AbstractCommand::commandFinished()
+{
+    debugOutput(1, "AbstractCommand::commandFinished()NOT SUPPOSED TO BE HERE");
+}
+
+void AbstractCommand::setSocket(QTcpSocket* socket) 
+{
+    debugOutput(0, "AbstractCommand::setSocket()");
+    Q_ASSERT(socket);
+    m_socket = socket;
+    connect(m_socket, SIGNAL(readyRead()), this, SLOT(_readData()));
+    reportSuccess();
+}
+
+QTcpSocket* AbstractCommand::socket() 
+{ 
+    return m_socket; 
+}
+
+void AbstractCommand::_readData()
+{
+    QByteArray arr = m_socket->readAll();
+    dataReceived(arr);
+}
+
+void AbstractCommand::_disconnect()
+{
+}
+
+/////////////////////////////////////////////////////
+//       Create File Command Implementation        //
+/////////////////////////////////////////////////////
+CreateFileCommand::CreateFileCommand()
+: m_dataCount(0)
+{
+    debugOutput(0, "CreateFileCommand::CreateFileCommand");
+    m_options.fileSize= -1;
+}
+
+CreateFileCommand::~CreateFileCommand()
+{
+    debugOutput(0, "CreateFileCommand::~CreateFileCommand");
+    if (m_file.isOpen()) {
+        fprintf(stderr, "****************FILE IS STILL OPENED AND HAVENT FINISHED WRITING**********************\n");
+        fprintf(stderr, "Current: %d Expected: %d\n", m_dataCount , m_options.fileSize);
+        m_file.close();
+    }
+}
+
+void CreateFileCommand::dataReceived(QByteArray &data)
+{
+    bool successful = true;
+    // If we haven't received the options yet
+    if (m_options.fileSize == -1) {
+        CreateFileOptions* opt = (CreateFileOptions*) data.data();
+        memcpy(&m_options , opt , sizeof(CreateFileOptions));
+
+        if (QFileInfo(QString::fromLatin1(m_options.fileName)).exists()) {
+            if (m_options.overwriteExisting) {
+#ifdef Q_OS_WINCE
+                SetFileAttributes(QFileInfo(m_options.fileName).absoluteFilePath().utf16(), FILE_ATTRIBUTE_NORMAL);
+#endif
+                QFile::remove(m_options.fileName);
+            } else
+                successful = false;
+        }
+        m_file.setFileName(QString::fromLatin1(m_options.fileName));
+        if (!m_file.open(QIODevice::WriteOnly))
+            successful = false;
+        else
+            debugOutput(3, QString::fromLatin1("Creating file: %1").arg(m_options.fileName));
+    } else { // write buffer on disc
+        if (!m_file.isOpen())
+            return;
+        m_file.write(data);
+        m_dataCount += data.size();
+        if (m_dataCount >= m_options.fileSize) {
+            // We do not care about more data than announced
+            m_file.close();
+        }
+    }
+    
+    if (successful)
+        reportSuccess();
+    else
+        reportError();
+}
+
+void CreateFileCommand::commandFinished()
+{
+    debugOutput(0, "CreateFileCommand::commandFinished");
+#ifdef Q_OS_WIN
+    // We need to set the file attributes for intelligent time comparisons
+    QString tmpFile = QString::fromLatin1(m_options.fileName);
+    HANDLE handle = CreateFile(tmpFile.utf16(), GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+    if (handle != INVALID_HANDLE_VALUE) {
+        SetFileTime(handle, &(m_options.fileTime), NULL, NULL);
+        CloseHandle(handle);
+    }
+    SetFileAttributes(tmpFile.utf16(), m_options.fileAttributes);
+#endif
+}
+
+/////////////////////////////////////////////////////
+//    Create Directory Command Implementation      //
+/////////////////////////////////////////////////////
+CreateDirectoryCommand::CreateDirectoryCommand()
+        : AbstractCommand()
+{
+    debugOutput(0, "CreateDirectoryCommand::CreateDirectoryCommand");
+}
+
+CreateDirectoryCommand::~CreateDirectoryCommand()
+{
+    debugOutput(0, "CreateDirectoryCommand::~CreateDirectoryCommand()");
+}
+
+void CreateDirectoryCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "CreateDirectoryCommand::dataReceived()");
+    CreateDirectoryOptions* options = (CreateDirectoryOptions*) data.data();
+    debugOutput(3, QString::fromLatin1("Creating directory: %1").arg(options->dirName));
+    bool success = true;
+    QDir dir;
+    if (options->recursively)
+        success = dir.mkpath(options->dirName);
+    else
+        success = dir.mkdir(options->dirName);
+    
+    if (success)
+        reportSuccess();
+    else
+        reportError();
+}
+
+void CreateDirectoryCommand::commandFinished()
+{
+    debugOutput(0, "CreateDirectoryCommand::commandFinished()");
+}
+
+/////////////////////////////////////////////////////
+//        Copy File Command Implementation         //
+/////////////////////////////////////////////////////
+CopyFileCommand::CopyFileCommand()
+        : AbstractCommand()
+{
+    debugOutput(0, "CopyFileCommand::CopyFileCommand()");
+}
+
+CopyFileCommand::~CopyFileCommand()
+{
+    debugOutput(0, "CopyFileCommand::~CopyFileCommand()");
+}
+
+void CopyFileCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "CopyFileCommand::dataReceived()");
+    CopyFileOptions* options = (CopyFileOptions*) data.data();
+    debugOutput(3, QString::fromLatin1("Copy File: %1 ->  %2").arg(options->from).arg(options->to));
+    bool success = true;
+    if (QFileInfo(options->to).exists()) {
+        if (options->overwriteExisting)
+            QFile::remove(options->to);
+        else
+            success = false;
+    }
+    if (success)
+        if (!QFile::copy(options->from , options->to))
+            success = false;
+    
+    if (success)
+        reportSuccess();
+    else
+        reportError();
+}
+
+void CopyFileCommand::commandFinished()
+{
+    debugOutput(0, "CopyFileCommand::commandFinished()");
+}
+
+/////////////////////////////////////////////////////
+//      Copy Directory Command Implementation      //
+/////////////////////////////////////////////////////
+CopyDirectoryCommand::CopyDirectoryCommand()
+        : AbstractCommand()
+{
+    debugOutput(0, "CopyDirectoryCommand::CopyDirectoryCommand()");
+}
+
+CopyDirectoryCommand::~CopyDirectoryCommand()
+{
+    debugOutput(0, "CopyDirectoryCommand::~CopyDirectoryCommand()");
+}
+
+void CopyDirectoryCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "CopyDirectoryCommand::dataReceived()");
+    CopyDirectoryOptions* options = (CopyDirectoryOptions*) data.data();
+    debugOutput(3, QString::fromLatin1("Copy Directory: %1 %2").arg(options->from).arg(options->to));
+    if (copyDir(QLatin1String(options->from) , QLatin1String(options->to) , options->recursive))
+        reportSuccess();
+    else
+        reportError();
+}
+
+void CopyDirectoryCommand::commandFinished()
+{
+    debugOutput(0, "CopyDirectoryCommand::commandFinished()");
+}
+
+bool CopyDirectoryCommand::copyDir(const QString &from, const QString &to, bool recursive)
+{
+    QDir().mkpath(to);
+    QDir sourceDir(from);
+    QDir destDir(to);
+    QStringList entries = sourceDir.entryList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
+    foreach (QString item , entries) {
+        QString itemFrom = sourceDir.absoluteFilePath(item);
+        QString itemTo = destDir.absoluteFilePath(item);
+        if (QFileInfo(item).isDir()) {
+            if (recursive && !copyDir(itemFrom, itemTo, recursive))
+                return false;
+        } else {
+            if (!QFile::copy(itemFrom, itemTo))
+                return false;
+        }
+    }
+    return true;
+}
+
+/////////////////////////////////////////////////////
+//        Delete File Command Implementation       //
+/////////////////////////////////////////////////////
+DeleteFileCommand::DeleteFileCommand()
+        : AbstractCommand()
+{
+    debugOutput(0, "DeleteFileCommand::DeleteFileCommand()");
+}
+
+DeleteFileCommand::~DeleteFileCommand()
+{
+    debugOutput(0, "DeleteFileCommand::~DeleteFileCommand()");
+}
+
+void DeleteFileCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "DeleteFileCommand::dataReceived()");
+    DeleteFileOptions* options = (DeleteFileOptions*) data.data();
+    debugOutput(3, QString::fromLatin1("Delete File: %1").arg(options->fileName));
+    bool success = true;
+    QFile file(options->fileName);
+    if (file.exists()) {
+#ifdef Q_OS_WINCE
+        SetFileAttributes(QFileInfo(options->fileName).absoluteFilePath().utf16(), FILE_ATTRIBUTE_NORMAL);
+#endif
+        success = file.remove();
+    } else
+        success = false;
+
+    if (success)
+        reportSuccess();
+    else
+        reportError();
+}
+
+void DeleteFileCommand::commandFinished()
+{
+    debugOutput(0, "DeleteFileCommand::commandFinished()");
+}
+
+/////////////////////////////////////////////////////
+//     Delete Directory Command Implementation     //
+/////////////////////////////////////////////////////
+DeleteDirectoryCommand::DeleteDirectoryCommand()
+        : AbstractCommand()
+{
+    debugOutput(0, "DeleteDirectoryCommand::DeleteDirectoryCommand()");
+}
+
+DeleteDirectoryCommand::~DeleteDirectoryCommand()
+{
+    debugOutput(0, "DeleteDirectoryCommand::~DeleteDirectoryCommand()");
+}
+
+void DeleteDirectoryCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "DeleteDirectoryCommand::dataReceived()");
+    DeleteDirectoryOptions* options = (DeleteDirectoryOptions*) data.data();
+    debugOutput(3, QString::fromLatin1("Delete directory: %1").arg(options->dirName));
+    if (deleteDirectory(QLatin1String(options->dirName), options->recursive, options->failIfContentExists))
+        reportSuccess();
+    else
+        reportError();
+}
+
+void DeleteDirectoryCommand::commandFinished()
+{
+    debugOutput(0, "DeleteDirectoryCommand::commandFinished()");
+}
+
+bool DeleteDirectoryCommand::deleteDirectory(const QString &dirName, bool recursive, bool failIfContentExists)
+{
+    QDir dir(dirName);
+    if (!dir.exists())
+        return false;
+
+    QStringList itemList = dir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
+    if (itemList.size() > 0 && failIfContentExists)
+        return false;
+
+    foreach (QString item, itemList) {
+        QString itemName = dir.absoluteFilePath(item);
+        if (QFileInfo(itemName).isDir()) {
+            if (recursive && !deleteDirectory(itemName, recursive, failIfContentExists))
+                return false;
+        } else {
+            if (!dir.remove(item))
+                return false;
+        }
+    }
+    QString lastName = dir.dirName();
+    dir.cdUp();
+    dir.rmpath(lastName);
+    return true;
+}
+
+/////////////////////////////////////////////////////
+//         Execute Command Implementation          //
+/////////////////////////////////////////////////////
+ExecuteCommand::ExecuteCommand()
+        : AbstractCommand()
+        , m_argumentCount(0)
+        , m_timeout(-1)
+{
+    debugOutput(0, "ExecuteCommand::ExecuteCommand()");
+}
+
+ExecuteCommand::~ExecuteCommand()
+{
+    debugOutput(0, "ExecuteCommand::~ExecuteCommand()");
+}
+
+void ExecuteCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "ExecuteCommand::dataReceived()");
+    
+    if (m_argumentCount == 0) {
+        ExecuteOptions* options = (ExecuteOptions*) data.data();
+        if (!QFileInfo(options->appName).exists()) {
+            debugOutput(1, "Error execute: application does not exist");
+            reportError();
+            return;
+        }
+    
+        m_program = QLatin1String(options->appName);
+        m_argumentCount = options->argumentsCount;
+        m_waitFinished = options->waitForFinished;
+        m_timeout = options->timeout;
+        if (m_argumentCount == 0)
+            m_argumentCount = -1; // to trigger startup on next receive
+        reportSuccess();
+    } else if (m_arguments.size() < m_argumentCount) {
+        m_arguments += data;
+        reportSuccess();
+    } else { // do the execution
+        if (data == COMMAND_SUCCESS)
+            _doExecute();
+    }
+}
+
+void ExecuteCommand::_doExecute()
+{
+    debugOutput(0, "ExecuteCommand::_doExecute()");
+    debugOutput(3, QString::fromLatin1("Execute: %1 %2").arg(m_program).arg(m_arguments.join(" ")));
+    if (m_waitFinished) {
+        QProcess process;
+        process.start(m_program, m_arguments);
+        if (process.waitForFinished(m_timeout) == false || process.exitCode() < 0)
+            reportError();
+        else
+            reportSuccess();
+    } else {
+        if (QProcess::startDetached(m_program, m_arguments))
+            reportSuccess();
+        else
+            reportError();
+    }
+}
+void ExecuteCommand::commandFinished()
+{
+    debugOutput(0,"ExecuteCommand::commandFinished()");
+}
+
+/////////////////////////////////////////////////////
+//           Read File Implementation              //
+/////////////////////////////////////////////////////
+ReadFileCommand::ReadFileCommand()
+        : AbstractCommand()
+        , m_currentPos(0)
+{
+    debugOutput(0, "ReadFileCommand::ReadFileCommand()");
+    m_fileName.clear();
+}
+
+ReadFileCommand::~ReadFileCommand()
+{
+    debugOutput(0, "ReadFileCommand::~ReadFileCommand()");
+    if (m_file.isOpen())
+        m_file.close();
+}
+
+void ReadFileCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "ReadFileCommand::dataReceived()");
+    if (m_fileName.isEmpty()) {
+        ReadFileOptions* option = (ReadFileOptions*) data.data();
+        m_fileName = QLatin1String(option->fileName);
+        QFileInfo info(m_fileName);
+        m_file.setFileName(m_fileName);
+        ReadFileReply reply;
+        if (!info.exists() || !info.isFile() || !m_file.open(QIODevice::ReadOnly))
+            reply.fileValid = false;
+        else
+            reply.fileValid = true;
+        reply.fileSize = info.size();
+        m_fileSize = reply.fileSize;
+        socket()->write((char*) &reply, sizeof(reply));
+        debugOutput(3, QString::fromLatin1("Reading file: %1").arg(m_fileName));
+    } else {
+        QTcpSocket* sock = socket(); // design failure???
+        if (data != COMMAND_SUCCESS || m_currentPos >= m_fileSize) {
+            sock->disconnectFromHost();
+            return;
+        }
+        const int bufferSize = 1024;
+        QByteArray buffer = m_file.read(bufferSize);
+        m_currentPos += buffer.size();
+        sock->write(buffer);
+        sock->waitForBytesWritten();
+    }
+}
+
+void ReadFileCommand::commandFinished()
+{
+    debugOutput(0, "ReadFileCommand::commandFinished()");
+}
+
+/////////////////////////////////////////////////////
+//        Read Directory Implementation            //
+/////////////////////////////////////////////////////
+ReadDirectoryCommand::ReadDirectoryCommand()
+        : AbstractCommand()
+        , m_iterator(0)
+{
+    debugOutput(0, "ReadDirectoryCommand::ReadDirectoryCommand");
+    m_dirName.clear();
+}
+
+ReadDirectoryCommand::~ReadDirectoryCommand()
+{
+    debugOutput(0, "ReadDirectoryCommand::~ReadDirectoryCommand()");
+    delete m_iterator;
+}
+
+void ReadDirectoryCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "ReadDirectoryCommand::dataReceived()");
+    QTcpSocket* sock = socket();
+    if (m_dirName.isEmpty()) {
+        ReadDirectoryOptions* option = (ReadDirectoryOptions*) data.data();
+        QFileInfo info(QLatin1String(option->dirName));
+        debugOutput(3, QString::fromLatin1("Reading Directory entries: %1").arg(option->dirName));
+        ReadDirectoryReply reply;
+        if (!info.exists() || !info.isDir()) {
+            reply.itemCount = -1;
+            reply.entryValid = false;
+        } else {
+            m_dirName = QLatin1String(option->dirName);
+            m_dir.setPath(m_dirName);
+            m_iterator = new QDirIterator(m_dir);
+            reply.itemCount = m_dir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot).size();
+            reply.entryValid = true;
+        }
+        sock->write((char*) &reply, sizeof(reply));
+        sock->waitForBytesWritten();
+    } else {
+        if (data != COMMAND_SUCCESS) {
+            qDebug() << "Something went wrong in the meantime";
+            return;
+        }
+        ReadDirectoryItem reply;
+        if (m_iterator->hasNext()) {
+            m_iterator->next();
+            QFileInfo info = m_iterator->fileInfo();
+            strcpy(reply.name, qPrintable(info.absoluteFilePath()));
+            reply.isDirectory = info.isDir();
+            if (!reply.isDirectory)
+                reply.size = info.size();
+        }
+        reply.hasMore = m_iterator->hasNext();
+        sock->write((char*) &reply, sizeof(reply));
+        sock->waitForBytesWritten();
+    }
+}
+
+void ReadDirectoryCommand::commandFinished()
+{
+    debugOutput(0, "ReadDirectoryCommand::commandFinished()");
+}
+
+/////////////////////////////////////////////////////
+//           File Time Implementation              //
+/////////////////////////////////////////////////////
+FileTimeCommand::FileTimeCommand()
+        : AbstractCommand()
+{
+    debugOutput(0, "FileTimeCommand::FileTimeCommand()");
+}
+
+FileTimeCommand::~FileTimeCommand()
+{
+    debugOutput(0, "FileTimeCommand::~FileTimeCommand()");
+}
+
+void FileTimeCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "FileTimeCommand::dataReceived()");
+    FileTimeOptions* option = (FileTimeOptions*) data.data();
+
+    FILETIME resultTime;
+    resultTime.dwLowDateTime = -1;
+    resultTime.dwHighDateTime = -1;
+    
+#ifdef Q_OS_WIN
+    QString fileName = QLatin1String(option->fileName);
+    HANDLE deviceHandle = CreateFile(fileName.utf16(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
+    debugOutput(3, QString::fromLatin1("Asking FileTime: %1").arg(fileName));
+    if (deviceHandle != INVALID_HANDLE_VALUE) {
+        FILETIME deviceCreationTime;
+        if (GetFileTime(deviceHandle, &deviceCreationTime, NULL, NULL)) {
+            resultTime = deviceCreationTime;
+        }
+        CloseHandle(deviceHandle);
+    }
+#endif
+    QTcpSocket* sock = socket();
+    sock->write((char*) &resultTime, sizeof(resultTime));
+    sock->waitForBytesWritten();
+}
+
+void FileTimeCommand::commandFinished()
+{
+    debugOutput(0, "FileTimeCommand::commandFinished()");
+}
+
+/////////////////////////////////////////////////////
+//           Time Stamp Implementation             //
+/////////////////////////////////////////////////////
+TimeStampCommand::TimeStampCommand()
+        : AbstractCommand()
+{
+    debugOutput(0, "TimeStampCommand::TimeStampCommand()");
+}
+
+TimeStampCommand::~TimeStampCommand()
+{
+    debugOutput(0, "TimeStampCommand::~TimeStampCommand()");
+}
+
+void TimeStampCommand::dataReceived(QByteArray &data)
+{
+    debugOutput(0, "TimeStampCommand::dataReceived()");
+    FILETIME resultTime;
+    resultTime.dwLowDateTime = -1;
+    resultTime.dwHighDateTime = -1;
+    
+#ifdef Q_OS_WIN
+    FILETIME stampTime = *((FILETIME*)data.data());
+    
+    QString tmpFile = QString::fromLatin1("\\qt_tmp_ftime_convert");
+    HANDLE remoteHandle = CreateFile(tmpFile.utf16(), GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+    if (remoteHandle != INVALID_HANDLE_VALUE) {
+        if (!SetFileTime(remoteHandle, &stampTime, NULL, NULL)) {
+            CloseHandle(remoteHandle);
+        } else {
+            CloseHandle(remoteHandle);
+            remoteHandle = CreateFile(tmpFile.utf16(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
+            if (remoteHandle != INVALID_HANDLE_VALUE) {
+                if (GetFileTime(remoteHandle, &stampTime, NULL, NULL))
+                    resultTime = stampTime;
+                CloseHandle(remoteHandle);
+                DeleteFile(tmpFile.utf16());
+            }
+        }
+    }
+    debugOutput(3, QString::fromLatin1("Asking TimeStamp"));
+#endif
+    QTcpSocket* sock = socket();
+    sock->write((char*) &resultTime, sizeof(resultTime));
+    sock->waitForBytesWritten();
+}
+
+void TimeStampCommand::commandFinished()
+{
+    debugOutput(0, "TimeStampCommand::commandFinished()");
+}
diff --git a/tools/qtestlib/wince/cetcpsyncserver/commands.h b/tools/qtestlib/wince/cetcpsyncserver/commands.h
new file mode 100644
index 0000000..356c1aa
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsyncserver/commands.h
@@ -0,0 +1,292 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef COMMANDS_INCL
+#define COMMANDS_INCL
+
+#include "transfer_global.h"
+
+#include <QtNetwork/QTcpSocket>
+#include <QtCore/QString>
+#include <QtCore/QFile>
+#include <QtCore/QDir>
+#include <QtCore/QDirIterator>
+#include <windows.h>
+
+// debug output
+#define DEBUG_LEVEL 2
+inline void debugOutput(int level, const char* text)
+{
+    if (level >= DEBUG_LEVEL)
+        qDebug() << text;
+}
+
+inline void debugOutput(int level, const QString &text)
+{
+    if (level >= DEBUG_LEVEL)
+        qDebug() << text;
+}
+// Basic abtract command class
+class AbstractCommand : public QObject
+{
+    Q_OBJECT
+public:
+    AbstractCommand();
+    virtual ~AbstractCommand();
+
+    void setSocket(QTcpSocket*);
+    QTcpSocket* socket();
+
+    void reportSuccess();
+    void reportError();
+
+public slots:
+    virtual void dataReceived(QByteArray&);
+    virtual void commandFinished();
+
+private slots:
+    void _readData();
+    void _disconnect();
+
+private:
+    QTcpSocket* m_socket;
+};
+
+// File Creation class
+class CreateFileCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    CreateFileCommand();
+    ~CreateFileCommand();
+
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+
+private:
+    CreateFileOptions m_options;
+    QFile m_file;
+    int m_dataCount;
+};
+
+inline AbstractCommand* instCreateFile() { return new CreateFileCommand(); }
+
+// Directory Creation class
+class CreateDirectoryCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    CreateDirectoryCommand();
+    ~CreateDirectoryCommand();
+    
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+};
+inline AbstractCommand* instCreateDirectory() { return new CreateDirectoryCommand(); }
+
+// File copy class
+class CopyFileCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    CopyFileCommand();
+    ~CopyFileCommand();
+    
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+};
+inline AbstractCommand* instCopyFile() { return new CopyFileCommand(); }
+
+// Copy directory class
+class CopyDirectoryCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    CopyDirectoryCommand();
+    ~CopyDirectoryCommand();
+
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+private:
+    bool copyDir(const QString &from, const QString &to, bool recursive);
+};
+inline AbstractCommand* instCopyDirectory() { return new CopyDirectoryCommand(); }
+
+// Delete File class
+class DeleteFileCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    DeleteFileCommand();
+    ~DeleteFileCommand();
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+};
+inline AbstractCommand* instDeleteFile() { return new DeleteFileCommand(); }
+
+// Delete Directory class
+class DeleteDirectoryCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    DeleteDirectoryCommand();
+    ~DeleteDirectoryCommand();
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+private:
+    bool deleteDirectory(const QString &dirName, bool recursive, bool failIfContentExists);
+};
+inline AbstractCommand* instDeleteDirectory() { return new DeleteDirectoryCommand(); }
+
+// Execute application class
+class ExecuteCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    ExecuteCommand();
+    ~ExecuteCommand();
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+private:
+    void _doExecute();
+    QString m_program;
+    QStringList m_arguments;
+    int m_argumentCount;
+    bool m_waitFinished;
+    int m_timeout;
+};
+inline AbstractCommand* instExecution() { return new ExecuteCommand(); }
+
+// Read File class
+class ReadFileCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    ReadFileCommand();
+    ~ReadFileCommand();
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+private:
+    QString m_fileName;
+    QFile m_file;
+    qint64 m_currentPos;
+    qint64 m_fileSize;
+};
+inline AbstractCommand* instReadFile() { return new ReadFileCommand(); }
+
+// Read Directory class
+class ReadDirectoryCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    ReadDirectoryCommand();
+    ~ReadDirectoryCommand();
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+private:
+    QString m_dirName;
+    QDir m_dir;
+    QDirIterator* m_iterator;
+};
+inline AbstractCommand* instReadDirectory() { return new ReadDirectoryCommand(); }
+
+// Read File Time class
+class FileTimeCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    FileTimeCommand();
+    ~FileTimeCommand();
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+};
+inline AbstractCommand* instFileTime() { return new FileTimeCommand(); }
+
+// Time stamp class
+class TimeStampCommand : public AbstractCommand
+{
+    Q_OBJECT
+public:
+    TimeStampCommand();
+    ~TimeStampCommand();
+public slots:
+    void dataReceived(QByteArray&);
+    void commandFinished();
+};
+inline AbstractCommand* instTimeStamp() { return new TimeStampCommand(); }
+
+// Access part
+typedef AbstractCommand* (*instantiator)();
+
+struct CommandInfo
+{
+    CommandInfo(const QString &name, instantiator func) : commandName(name) , commandFunc(func) { }
+    QString commandName;
+    instantiator commandFunc;
+};
+
+inline QList<CommandInfo> availableCommands()
+{
+    QList<CommandInfo> list;
+    list.append(CommandInfo(QLatin1String(COMMAND_CREATE_FILE), instCreateFile));
+    list.append(CommandInfo(QLatin1String(COMMAND_CREATE_DIRECTORY), instCreateDirectory));
+    list.append(CommandInfo(QLatin1String(COMMAND_COPY_FILE), instCopyFile));
+    list.append(CommandInfo(QLatin1String(COMMAND_COPY_DIRECTORY), instCopyDirectory));
+    list.append(CommandInfo(QLatin1String(COMMAND_DELETE_FILE), instDeleteFile));
+    list.append(CommandInfo(QLatin1String(COMMAND_DELETE_DIRECTORY), instDeleteDirectory));
+    list.append(CommandInfo(QLatin1String(COMMAND_EXECUTE), instExecution));
+    list.append(CommandInfo(QLatin1String(COMMAND_READ_FILE), instReadFile));
+    list.append(CommandInfo(QLatin1String(COMMAND_READ_DIRECTORY), instReadDirectory));
+    list.append(CommandInfo(QLatin1String(COMMAND_FILE_TIME), instFileTime));
+    list.append(CommandInfo(QLatin1String(COMMAND_TIME_STAMP), instTimeStamp));
+    return list;
+}
+
+#endif
diff --git a/tools/qtestlib/wince/cetcpsyncserver/connectionmanager.cpp b/tools/qtestlib/wince/cetcpsyncserver/connectionmanager.cpp
new file mode 100644
index 0000000..901cd12
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsyncserver/connectionmanager.cpp
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "connectionmanager.h"
+#include "commands.h"
+#include <QtCore/QDebug>
+
+ConnectionManager::ConnectionManager()
+    : QObject()
+    , m_server(0)
+{
+    debugOutput(0, "ConnectionManager::ConnectionManager()");
+}
+
+ConnectionManager::~ConnectionManager()
+{
+    debugOutput(0, "ConnectionManager::~ConnectionManager()");
+    cleanUp();
+}
+
+bool ConnectionManager::init()
+{
+    debugOutput(0, "ConnectionManager::init()");
+    debugOutput(3, "Initializing server...");
+    cleanUp();
+    m_server = new QTcpServer(this);
+    connect(m_server, SIGNAL(newConnection()), this, SLOT(newConnection()));
+    bool result = m_server->listen(QHostAddress::Any, SERVER_PORT);
+    if (!result)
+        debugOutput(3, QString::fromLatin1("   Error: Server start failed:") + m_server->errorString());
+    debugOutput(3, "   Waiting for action");
+    return result;
+}
+
+void ConnectionManager::cleanUp()
+{
+    debugOutput(0, "ConnectionManager::cleanUp()");
+
+    if (m_server) {
+        debugOutput(1, "Removing server instance...");
+        disconnect(m_server, SIGNAL(newConnection()), this, SLOT(newConnection()));
+        delete m_server;
+        m_server = 0;
+    }
+}
+
+void ConnectionManager::newConnection()
+{
+    debugOutput(0, "ConnectionManager::newConnection()");
+
+    QTcpSocket* connection = m_server->nextPendingConnection();
+    if (!connection) {
+        debugOutput(3, "Received connection has empty socket");
+        return;
+    }
+    debugOutput(0, QString::fromLatin1("   received a connection: %1").arg((int) connection));
+    new Connection(connection);
+}
+
+Connection::Connection(QTcpSocket *socket)
+        : QObject()
+        , m_connection(socket)
+        , m_command(0)
+{
+    connect(m_connection, SIGNAL(readyRead()), this, SLOT(receiveCommand()));
+    connect(m_connection, SIGNAL(disconnected()), this, SLOT(closedConnection()));
+}
+
+Connection::~Connection()
+{
+    if (m_command) {
+        m_command->commandFinished();
+        delete m_command;
+        m_command = 0;
+    }
+    delete m_connection;
+}
+
+void Connection::receiveCommand()
+{
+    QByteArray arr = m_connection->readAll();
+    debugOutput(1, QString::fromLatin1("Command received: ") + (arr));
+    QList<CommandInfo> commands = availableCommands();
+    for(QList<CommandInfo>::iterator it = commands.begin(); it != commands.end(); ++it) {
+        if (it->commandName == QString::fromLatin1(arr)) {
+            debugOutput(1, "Found command in list");
+            disconnect(m_connection, SIGNAL(readyRead()), this, SLOT(receiveCommand()));
+            AbstractCommand* command = (*it).commandFunc();
+            command->setSocket(m_connection);
+            m_command = command;
+            return;
+        }
+    }
+    debugOutput(2, QString::fromLatin1("Unknown command received: ") + (arr));
+}
+
+void Connection::closedConnection()
+{
+    debugOutput(0, "connection being closed...");
+    this->deleteLater();
+}
diff --git a/tools/qtestlib/wince/cetcpsyncserver/connectionmanager.h b/tools/qtestlib/wince/cetcpsyncserver/connectionmanager.h
new file mode 100644
index 0000000..21183ac
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsyncserver/connectionmanager.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef CONNECTION_MANAGER_INCL
+#define CONNECTION_MANAGER_INCL
+
+#include "transfer_global.h"
+#include "commands.h"
+
+#include <QtNetwork/QTcpServer>
+#include <QtNetwork/QTcpSocket>
+
+class Connection : public QObject
+{
+    Q_OBJECT
+public:
+    Connection(QTcpSocket* socket);
+    ~Connection();
+
+public slots:
+    void receiveCommand();
+    void closedConnection();
+
+private:
+    QTcpSocket* m_connection;
+    AbstractCommand* m_command;
+};
+
+class ConnectionManager : public QObject
+{
+    Q_OBJECT
+public:
+    ConnectionManager();
+    ~ConnectionManager();
+
+    bool init();
+
+public slots:
+    void cleanUp();
+    void newConnection();
+
+private:
+    QTcpServer* m_server;
+};
+
+#endif
diff --git a/tools/qtestlib/wince/cetcpsyncserver/main.cpp b/tools/qtestlib/wince/cetcpsyncserver/main.cpp
new file mode 100644
index 0000000..19d38ea
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsyncserver/main.cpp
@@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "connectionmanager.h"
+
+#include <QtCore>
+#include <QtNetwork>
+
+void messageOutput(QtMsgType type, const char *msg)
+{
+    switch(type) {
+        case QtDebugMsg: fprintf(stderr, "Debug: %s\n", msg); break;
+        case QtWarningMsg: fprintf(stderr, "Warning: %s\n", msg); break;
+        default: fprintf(stderr, "Some Msg: %s\n", msg); break;
+    }
+}
+
+int main(int argc, char **argv)
+{
+    qInstallMsgHandler(messageOutput);
+    
+    QCoreApplication app(argc, argv);
+    ConnectionManager manager;
+    manager.init();
+    return app.exec();
+}
diff --git a/tools/qtestlib/wince/cetcpsyncserver/transfer_global.h b/tools/qtestlib/wince/cetcpsyncserver/transfer_global.h
new file mode 100644
index 0000000..5b6ff23
--- /dev/null
+++ b/tools/qtestlib/wince/cetcpsyncserver/transfer_global.h
@@ -0,0 +1,159 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef TRANSFER_GLOBAL_H
+#define TRANSFER_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+#ifdef Q_OS_WIN
+#include <windows.h>
+#endif
+
+#define SERVER_PORT 12145
+
+#define MAX_NAME_LENGTH 512
+#define MAX_ARGUMENTS 10
+
+// Defines for commands sent/received
+#define COMMAND_CREATE_FILE "CREATEFILE"
+#define COMMAND_CREATE_DIRECTORY "CREATEDIR"
+#define COMMAND_COPY_FILE "COPYFILE"
+#define COMMAND_COPY_DIRECTORY "COPYDIR"
+#define COMMAND_DELETE_FILE "DELETEFILE"
+#define COMMAND_DELETE_DIRECTORY "DELETEDIR"
+#define COMMAND_EXECUTE "EXECUTE"
+#define COMMAND_QUIT_SERVER "QUIT"
+#define COMMAND_FILE_TIME "FILETIME"
+#define COMMAND_TIME_STAMP "TIMESTAMP"
+
+// Report back commands
+#define COMMAND_SUCCESS "SUCCESS"
+#define COMMAND_ERROR "ERROR"
+
+// Defines for commands that send data back to requester
+#define COMMAND_READ_FILE "READFILE"
+#define COMMAND_READ_DIRECTORY "READDIR"
+
+#include <QtCore/qglobal.h>
+// Option-Structures for commands
+
+struct CreateFileOptions
+{
+    char fileName[MAX_NAME_LENGTH];
+#ifdef Q_OS_WIN
+    FILETIME fileTime;
+    DWORD fileAttributes;
+#endif
+    int fileSize;
+    bool overwriteExisting;
+};
+
+struct CreateDirectoryOptions
+{
+    char dirName[MAX_NAME_LENGTH];
+    bool recursively; // in case of \foo\bar create \foo if it does not exist
+};
+
+struct CopyFileOptions
+{
+    char from[MAX_NAME_LENGTH];
+    char to[MAX_NAME_LENGTH];
+    bool overwriteExisting;
+};
+
+struct CopyDirectoryOptions
+{
+    char from[MAX_NAME_LENGTH];
+    char to[MAX_NAME_LENGTH];
+    bool recursive;
+};
+
+struct DeleteFileOptions
+{
+    char fileName[MAX_NAME_LENGTH];
+};
+
+struct DeleteDirectoryOptions
+{
+    char dirName[MAX_NAME_LENGTH];
+    bool recursive;
+    bool failIfContentExists;
+};
+
+struct ExecuteOptions
+{
+    char appName[MAX_NAME_LENGTH];
+    int argumentsCount;
+    bool waitForFinished;
+    int timeout;
+};
+
+struct ReadFileOptions
+{
+    char fileName[MAX_NAME_LENGTH];
+};
+
+struct ReadFileReply
+{
+    qint64 fileSize;
+    bool fileValid;
+};
+
+struct ReadDirectoryOptions
+{
+    char dirName[MAX_NAME_LENGTH];
+};
+
+struct ReadDirectoryItem
+{
+    char name[MAX_NAME_LENGTH];
+    qint64 size;
+    bool isDirectory;
+    bool hasMore;
+};
+
+#define FileTimeOptions ReadFileOptions
+
+struct ReadDirectoryReply
+{
+    bool entryValid;
+    int itemCount; // might change during iteration
+};
+#endif
diff --git a/tools/qtestlib/wince/cetest/cetcpsyncconnection.cpp b/tools/qtestlib/wince/cetest/cetcpsyncconnection.cpp
new file mode 100644
index 0000000..621a6ac
--- /dev/null
+++ b/tools/qtestlib/wince/cetest/cetcpsyncconnection.cpp
@@ -0,0 +1,200 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "CeTcpSyncConnection.h"
+#include <qdir.h>
+#include <qfile.h>
+#include <qfileinfo>
+
+static const QString ceTcpSyncProgram = "cetcpsync";
+extern void debugOutput(const QString& text, int level);
+
+CeTcpSyncConnection::CeTcpSyncConnection()
+        : AbstractRemoteConnection()
+        , connected(false)
+{
+}
+
+CeTcpSyncConnection::~CeTcpSyncConnection()
+{
+    if (isConnected())
+        disconnect();
+}
+
+bool CeTcpSyncConnection::connect(QVariantList&)
+{
+    // We connect with each command, so this is always true
+    // The command itself will fail then
+    const QString cmd = ceTcpSyncProgram + " noop";
+    if (system(qPrintable(cmd)) != 0)
+        return false;
+    connected = true;
+    return true;
+}
+
+void CeTcpSyncConnection::disconnect()
+{
+    connected = false;
+}
+
+bool CeTcpSyncConnection::isConnected() const
+{
+    return connected;
+}
+
+inline QString boolToString(bool b)
+{
+    return b ? "true" : "false";
+}
+
+static bool fileTimeFromString(FILETIME& ft, const QString& str)
+{
+    int idx = str.indexOf("*");
+    if (idx <= 0)
+        return false;
+    bool ok;
+    ft.dwLowDateTime = str.left(idx).toULong(&ok);
+    if (!ok)
+        return false;
+    ft.dwHighDateTime = str.mid(idx+1).toULong(&ok);
+    return ok;
+}
+
+static QString fileTimeToString(FILETIME& ft)
+{
+    return QString::number(ft.dwLowDateTime) + "*" + QString::number(ft.dwHighDateTime);
+}
+
+bool CeTcpSyncConnection::copyFileToDevice(const QString &localSource, const QString &deviceDest, bool failIfExists)
+{
+    QString cmd = ceTcpSyncProgram + " copyFileToDevice \"" + localSource + "\" \"" + deviceDest + "\" " + boolToString(failIfExists);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::copyDirectoryToDevice(const QString &localSource, const QString &deviceDest, bool recursive)
+{
+    QString cmd = ceTcpSyncProgram + " copyDirectoryToDevice \"" + localSource + "\" \"" + deviceDest + "\" " + boolToString(recursive);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::copyFileFromDevice(const QString &deviceSource, const QString &localDest, bool failIfExists)
+{
+    QString cmd = ceTcpSyncProgram + " copyFileFromDevice \"" + deviceSource + "\" \"" + localDest + "\" " + boolToString(failIfExists);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::copyDirectoryFromDevice(const QString &deviceSource, const QString &localDest, bool recursive)
+{
+    QString cmd = ceTcpSyncProgram + " copyDirectoryFromDevice \"" + deviceSource + "\" \"" + localDest + "\" " + boolToString(recursive);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::copyFile(const QString &srcFile, const QString &destFile, bool failIfExists)
+{
+    QString cmd = ceTcpSyncProgram + " copyFile \"" + srcFile + "\" \"" + destFile + "\" " + boolToString(failIfExists);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::copyDirectory(const QString &srcDirectory, const QString &destDirectory,
+                                        bool recursive)
+{
+    QString cmd = ceTcpSyncProgram + " copyDirectory \"" + srcDirectory + "\" \"" + destDirectory + "\" " + boolToString(recursive);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::deleteFile(const QString &fileName)
+{
+    QString cmd = ceTcpSyncProgram + " deleteFile \"" + fileName + "\"";
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::deleteDirectory(const QString &directory, bool recursive, bool failIfContentExists)
+{
+    QString cmd = ceTcpSyncProgram + " deleteDirectory \"" + directory + "\" " + boolToString(recursive) + " " + boolToString(failIfContentExists);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::execute(QString program, QString arguments, int timeout, int *returnValue)
+{
+    QString cmd = ceTcpSyncProgram + " execute \"" + program + "\" \"" + arguments + "\" " + QString::number(timeout);
+    int exitCode = system(qPrintable(cmd));
+    if (returnValue)
+        *returnValue = exitCode;
+    return true;
+}
+
+bool CeTcpSyncConnection::createDirectory(const QString &path, bool deleteBefore)
+{
+    QString cmd = ceTcpSyncProgram + " createDirectory \"" + path + "\" " + boolToString(deleteBefore);
+    return system(qPrintable(cmd)) == 0;
+}
+
+bool CeTcpSyncConnection::timeStampForLocalFileTime(FILETIME* fTime) const
+{
+    QString cmd = ceTcpSyncProgram + " timeStampForLocalFileTime " + fileTimeToString(*fTime) + " >qt_cetcpsyncdata.txt";
+    if (system(qPrintable(cmd)) != 0)
+        return false;
+
+    QFile file("qt_cetcpsyncdata.txt");
+    if (!file.open(QIODevice::ReadOnly))
+        return false;
+
+    bool result = fileTimeFromString(*fTime, file.readLine());
+    file.close();
+    file.remove();
+    return result;
+}
+
+bool CeTcpSyncConnection::fileCreationTime(const QString &fileName, FILETIME* deviceCreationTime) const
+{
+    QString cmd = ceTcpSyncProgram + " fileCreationTime \"" + fileName + "\" >qt_cetcpsyncdata.txt";
+    if (system(qPrintable(cmd)) != 0)
+        return false;
+
+    QFile file("qt_cetcpsyncdata.txt");
+    if (!file.open(QIODevice::ReadOnly))
+        return false;
+
+    bool result = fileTimeFromString(*deviceCreationTime, file.readLine());
+    file.close();
+    file.remove();
+    return result;
+}
diff --git a/tools/qtestlib/wince/cetest/cetcpsyncconnection.h b/tools/qtestlib/wince/cetest/cetcpsyncconnection.h
new file mode 100644
index 0000000..1ef8423
--- /dev/null
+++ b/tools/qtestlib/wince/cetest/cetcpsyncconnection.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef CETCPSYNC_REMOTECONNECTION_H
+#define CETCPSYNC_REMOTECONNECTION_H
+
+#include "remoteconnection.h"
+
+class CeTcpSyncConnection : public AbstractRemoteConnection
+{
+public:
+    CeTcpSyncConnection();
+    virtual ~CeTcpSyncConnection();
+
+    bool connect(QVariantList &list = QVariantList());
+    void disconnect();
+    bool isConnected() const;
+
+    // These functions are designed for transfer between desktop and device
+    // Caution: deviceDest path has to be device specific (eg. no drive letters for CE)
+    bool copyFileToDevice(const QString &localSource, const QString &deviceDest, bool failIfExists = false);
+    bool copyDirectoryToDevice(const QString &localSource, const QString &deviceDest, bool recursive = true);
+    bool copyFileFromDevice(const QString &deviceSource, const QString &localDest, bool failIfExists = false);
+    bool copyDirectoryFromDevice(const QString &deviceSource, const QString &localDest, bool recursive = true);
+
+    bool timeStampForLocalFileTime(FILETIME*) const;
+    bool fileCreationTime(const QString &fileName, FILETIME*) const;
+
+    // These functions only work on files existing on the device
+    bool copyFile(const QString&, const QString&, bool failIfExists = false);
+    bool copyDirectory(const QString&, const QString&, bool recursive = true);
+    bool deleteFile(const QString&);
+    bool deleteDirectory(const QString&, bool recursive = true, bool failIfContentExists = false);
+    bool moveFile(const QString&, const QString&, bool FailIfExists = false);
+    bool moveDirectory(const QString&, const QString&, bool recursive = true);
+
+    bool createDirectory(const QString&, bool deleteBefore=false);
+
+    bool execute(QString program, QString arguments = QString(), int timeout = -1, int *returnValue = NULL);
+private:
+    bool connected;
+};
+
+#endif
diff --git a/tools/qtestlib/wince/cetest/cetest.pro b/tools/qtestlib/wince/cetest/cetest.pro
index d66fa33..a6b79da 100644
--- a/tools/qtestlib/wince/cetest/cetest.pro
+++ b/tools/qtestlib/wince/cetest/cetest.pro
@@ -28,20 +28,27 @@ DEPENDPATH += $$QT_BUILD_TREE/src/corelib/tools $$QT_BUILD_TREE/src/corelib/io
 # Input
 HEADERS += \
         remoteconnection.h \
-        activesyncconnection.h \
         deployment.h
 
 SOURCES += \
         remoteconnection.cpp \
-        activesyncconnection.cpp \
         deployment.cpp \
         main.cpp
 
-win32-msvc*:LIBS += ole32.lib advapi32.lib rapi.lib
+LIBS += ole32.lib advapi32.lib
+
+isEmpty(QT_CE_RAPI_INC) {
+    DEFINES += QT_CETEST_NO_ACTIVESYNC
+    HEADERS += cetcpsyncconnection.h
+    SOURCES += cetcpsyncconnection.cpp
+} else {
+    HEADERS += activesyncconnection.h
+    SOURCES += activesyncconnection.cpp
+    LIBS += rapi.lib
+    INCLUDEPATH += $$QT_CE_RAPI_INC
+    LIBS += -L$$QT_CE_RAPI_LIB
+}
 
 include(qmake_include.pri)
 include(bootstrapped.pri)
 include($$QT_SOURCE_TREE/src/script/script.pri)
-
-INCLUDEPATH += $$QT_CE_RAPI_INC
-LIBS += -L$$QT_CE_RAPI_LIB
diff --git a/tools/qtestlib/wince/cetest/deployment.cpp b/tools/qtestlib/wince/cetest/deployment.cpp
index 68f0197..c64ae26 100644
--- a/tools/qtestlib/wince/cetest/deployment.cpp
+++ b/tools/qtestlib/wince/cetest/deployment.cpp
@@ -168,6 +168,7 @@ void DeploymentHandler::initQtDeploy(QMakeProject *project, DeploymentList &depl
         }
     }
 
+#ifndef QT_CETEST_NO_ACTIVESYNC
     // QtRemote deployment. We always deploy to \Windows
     if (!project->values("QMAKE_LIBDIR").isEmpty()) {
         QString remoteLibName = QLatin1String("QtRemote.dll");
@@ -177,6 +178,7 @@ void DeploymentHandler::initQtDeploy(QMakeProject *project, DeploymentList &depl
         else
             debugOutput(QString::fromLatin1("Could not find QtRemote. Might not be able to launch target executable"),0);
     }
+#endif
 
     // C-runtime deployment
     QString runtime = project->values("QT_CE_C_RUNTIME").join(QLatin1String(" "));
diff --git a/tools/qtestlib/wince/cetest/main.cpp b/tools/qtestlib/wince/cetest/main.cpp
index 782f6d9..e0e475c 100644
--- a/tools/qtestlib/wince/cetest/main.cpp
+++ b/tools/qtestlib/wince/cetest/main.cpp
@@ -39,7 +39,12 @@
 **
 ****************************************************************************/
 
-#include "activesyncconnection.h"
+#ifdef QT_CETEST_NO_ACTIVESYNC
+#   include "cetcpsyncconnection.h"
+#else
+#   include "activesyncconnection.h"
+#endif
+
 #include "deployment.h"
 #include <option.h>
 #include <project.h>
@@ -290,7 +295,11 @@ int main(int argc, char **argv)
     projectDeploymentList.append(CopyItem(TestConfiguration::localExecutable , TestConfiguration::remoteExecutable));
 
     // deploy
+#ifdef QT_CETEST_NO_ACTIVESYNC
+    CeTcpSyncConnection connection;
+#else
     ActiveSyncConnection connection;
+#endif
     if (!connection.connect()) {
         cout << "Error: Could not connect to device!" << endl;
         return -1;