Merge branch '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-1 into 4.7-integration

* '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-1: (54 commits)
  Apply f176759fc41abc4cb901c2cbaa15264f2a9ac85b to stdout too.
  Autotest: add some debugging, just in case there's something wrong
  Autotest: fix the fix for the rounding error.
  Fix compile error with QT_NO_LIBRARY in QtMultimedia
  the _setmode() prototype is different on win ce
  qdoc: Changed qdoc to output the new doc format.
  Doc: update 'developing on mac'
  fcntl.h doesn't seem to exist, either - contrary to an example on msdn
  Autotest: fix paths on the test server after update.
  Force the repaint during a window resize.
  fix compile on wince
  remove CONFIG += ordered again
  Assistant: Check namespace and virtual folder syntax of help projects.
  QtHelp: Fix auto tests.
  Fix a crash when unloading libQtCore
  Introduce a qconfig feature for QtDBus
  Fix build after MR 543 merged.
  Compile on 10.4.
  revert "Fix the Qt build on Mac OS X/Cocoa 64-bit"
  Remove expected failures after JavaScriptCore bug fix
  ...

17 files changed, 620 insertions, 96 deletions

diff --git a/tests/auto/macnativeevents/expectedeventlist.cpp b/tests/auto/macnativeevents/expectedeventlist.cpp
new file mode 100644
index 0000000..b1fb9a6
--- /dev/null
+++ b/tests/auto/macnativeevents/expectedeventlist.cpp
@@ -0,0 +1,176 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "expectedeventlist.h"
+#include <QDebug>
+#include <QCoreApplication>
+#include <QAbstractEventDispatcher>
+#include <QtTest/QtTest>
+
+ExpectedEventList::ExpectedEventList(QObject *target)
+    : QObject(target), eventCount(0)
+{
+    target->installEventFilter(this);
+    debug = !qgetenv("NATIVEDEBUG").isEmpty();
+}
+
+ExpectedEventList::~ExpectedEventList()
+{
+    qDeleteAll(eventList);
+}
+
+void ExpectedEventList::append(QEvent *e)
+{
+    eventList.append(e);
+    ++eventCount;
+}
+
+void ExpectedEventList::timerEvent(QTimerEvent *)
+{
+    timer.stop();
+    QAbstractEventDispatcher::instance()->interrupt();
+}
+
+bool ExpectedEventList::waitForAllEvents(int maxEventWaitTime)
+{
+    if (eventList.isEmpty())
+        return true;
+
+    int eventCount = eventList.size();
+    timer.start(maxEventWaitTime, this);
+
+    while (timer.isActive()) {
+        QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
+        if (eventList.isEmpty())
+            return true;
+
+        if (eventCount < eventList.size()){
+            eventCount = eventList.size();
+            timer.start(maxEventWaitTime, this);
+        }
+    }
+
+    int eventListNr = eventCount - eventList.size() + 1;
+    qWarning() << "Stopped waiting for expected event nr" << eventListNr;
+    return false;
+}
+
+void ExpectedEventList::compareMouseEvents(QEvent *received, QEvent *expected)
+{
+    QMouseEvent *e1 = static_cast<QMouseEvent *>(received);
+    QMouseEvent *e2 = static_cast<QMouseEvent *>(expected);
+    if (e1->pos() == e2->pos()
+            && (e1->globalPos() == e2->globalPos())
+            && (e1->button() == e2->button())
+            && (e1->buttons() == e2->buttons())
+            && (e1->modifiers() == e2->modifiers()))
+        return; // equal
+
+    int eventListNr = eventCount - eventList.size();
+    if (!debug) {
+        qWarning() << "Expected event" << eventListNr << "differs from received event:";
+        QCOMPARE(e1->pos(), e2->pos());
+        QCOMPARE(e1->globalPos(), e2->globalPos());
+        QCOMPARE(e1->button(), e2->button());
+        QCOMPARE(e1->buttons(), e2->buttons());
+        QCOMPARE(e1->modifiers(), e2->modifiers());
+    } else {
+        qWarning() << "*** FAIL *** : Expected event" << eventListNr << "differs from received event:";
+        qWarning() << "Received:" << e1 << e1->globalPos();
+        qWarning() << "Expected:" << e2 << e2->globalPos();
+    }
+}
+
+void ExpectedEventList::compareKeyEvents(QEvent *event1, QEvent *event2)
+{
+    QKeyEvent *e1 = static_cast<QKeyEvent *>(event1);
+    QKeyEvent *e2 = static_cast<QKeyEvent *>(event2);
+    Q_UNUSED(e1);
+    Q_UNUSED(e2);
+}
+
+bool ExpectedEventList::eventFilter(QObject *, QEvent *received)
+{
+    if (debug)
+        qDebug() << received;
+    if (eventList.isEmpty())
+        return false;
+
+    QEvent *expected = eventList.first();
+    if (expected->type() == received->type()) {
+        eventList.removeFirst();
+        switch (received->type()) {
+            case QEvent::MouseButtonPress:
+            case QEvent::MouseButtonRelease:
+            case QEvent::MouseMove:
+            case QEvent::MouseButtonDblClick:
+            case QEvent::NonClientAreaMouseButtonPress:
+            case QEvent::NonClientAreaMouseButtonRelease:
+            case QEvent::NonClientAreaMouseButtonDblClick:
+            case QEvent::NonClientAreaMouseMove: {
+                compareMouseEvents(received, expected);
+                break;
+            }
+            case QEvent::KeyPress: {
+                break;
+            }
+            case QEvent::KeyRelease: {
+                break;
+            }
+            case QEvent::Resize: {
+                break;
+            }
+            case QEvent::WindowActivate: {
+                break;
+            }
+            case QEvent::WindowDeactivate: {
+                break;
+            }
+            default:
+                break;
+        }
+        if (eventList.isEmpty())
+            QAbstractEventDispatcher::instance()->interrupt();
+    }
+
+    return false;
+}
+
diff --git a/tests/auto/macnativeevents/expectedeventlist.h b/tests/auto/macnativeevents/expectedeventlist.h
new file mode 100644
index 0000000..bd9f358
--- /dev/null
+++ b/tests/auto/macnativeevents/expectedeventlist.h
@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef EVENTFILTER
+#define EVENTFILTER
+
+#include <QWidget>
+#include <QList>
+#include <QEvent>
+#include <QBasicTimer>
+
+class ExpectedEventList : public QObject
+{
+    QList<QEvent *> eventList;
+    QBasicTimer timer;
+    bool debug;
+    int eventCount;
+    void timerEvent(QTimerEvent *);
+
+public:
+    ExpectedEventList(QObject *target);
+    ~ExpectedEventList();
+    void append(QEvent *e);
+    bool waitForAllEvents(int timeoutPerEvent = 2000);
+    bool eventFilter(QObject *obj, QEvent *event);
+
+private:
+    void compareMouseEvents(QEvent *event1, QEvent *event2);
+    void compareKeyEvents(QEvent *event1, QEvent *event2);
+};
+
+#endif
+
diff --git a/tests/auto/macnativeevents/macnativeevents.pro b/tests/auto/macnativeevents/macnativeevents.pro
index a0293d4..af34942 100644
--- a/tests/auto/macnativeevents/macnativeevents.pro
+++ b/tests/auto/macnativeevents/macnativeevents.pro
@@ -8,9 +8,9 @@ DEPENDPATH += .
 INCLUDEPATH += .
 LIBS += -framework Carbon
 
-HEADERS += qnativeinput.h qnativeplayer.h
-SOURCES += qnativeinput.cpp qnativeplayer.cpp qnativeinput_mac.cpp
-
+HEADERS += qnativeevents.h nativeeventlist.h expectedeventlist.h
+SOURCES += qnativeevents.cpp qnativeevents_mac.cpp 
+SOURCES += expectedeventlist.cpp nativeeventlist.cpp
 SOURCES += tst_macnativeevents.cpp
 
 requires(mac)
diff --git a/tests/auto/macnativeevents/qnativeplayer.cpp b/tests/auto/macnativeevents/nativeeventlist.cpp
index 92298ef..d5d7b95 100644
--- a/tests/auto/macnativeevents/qnativeplayer.cpp
+++ b/tests/auto/macnativeevents/nativeeventlist.cpp
@@ -39,22 +39,26 @@
 **
 ****************************************************************************/
 
-#include "qnativeplayer.h"
+#include "nativeeventlist.h"
 
-QNativePlayer::QNativePlayer()
+NativeEventList::NativeEventList(int defaultWaitMs)
+    : playbackMultiplier(1.0)
+    , currIndex(-1)
+    , wait(false)
+    , defaultWaitMs(defaultWaitMs)
 {
-    currIndex = -1;
-    playbackMultiplier = 1.0;
-    wait = false;
+    QString multiplier = qgetenv("NATIVEDEBUG");
+    if (!multiplier.isEmpty())
+        setTimeMultiplier(multiplier.toFloat());
 }
 
-QNativePlayer::~QNativePlayer()
+NativeEventList::~NativeEventList()
 {
     for (int i=0; i<eventList.size(); i++)
         delete eventList.takeAt(i).second;
 }
 
-void QNativePlayer::sendNextEvent()
+void NativeEventList::sendNextEvent()
 {
     QNativeEvent *e = eventList.at(currIndex).second;
     if (e)
@@ -62,7 +66,7 @@ void QNativePlayer::sendNextEvent()
     waitNextEvent();
 }
 
-void QNativePlayer::waitNextEvent()
+void NativeEventList::waitNextEvent()
 {
     if (++currIndex >= eventList.size()){
         emit done();
@@ -74,12 +78,22 @@ void QNativePlayer::waitNextEvent()
     QTimer::singleShot(interval * playbackMultiplier, this, SLOT(sendNextEvent()));
 }
 
-void QNativePlayer::append(int waitMs, QNativeEvent *event)
+void NativeEventList::append(QNativeEvent *event)
+{
+    eventList.append(QPair<int, QNativeEvent *>(defaultWaitMs, event));
+}
+
+void NativeEventList::append(int waitMs, QNativeEvent *event)
 {
     eventList.append(QPair<int, QNativeEvent *>(waitMs, event));
 }
 
-void QNativePlayer::play(Playback playback)
+void NativeEventList::append(int waitMs)
+{
+    eventList.append(QPair<int, QNativeEvent *>(waitMs, 0));
+}
+
+void NativeEventList::play(Playback playback)
 {
     waitNextEvent();
 
@@ -88,52 +102,14 @@ void QNativePlayer::play(Playback playback)
         QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
 }
 
-void QNativePlayer::stop()
+void NativeEventList::stop()
 {
     wait = false;
     QAbstractEventDispatcher::instance()->interrupt();
 }
 
-// ************************************************************************
-
-QEventOutputList::QEventOutputList()
-{
-    wait = true;
-}
-
-QEventOutputList::~QEventOutputList()
+void NativeEventList::setTimeMultiplier(float multiplier)
 {
-    qDeleteAll(*this);
+    playbackMultiplier = multiplier;
 }
 
-bool QEventOutputList::waitUntilEmpty(int maxEventWaitTime)
-{
-    int currSize = size();
-    QTime time;
-    time.restart();
-    while (wait){
-        QCoreApplication::processEvents(QEventLoop::AllEvents, 50);
-
-        if (isEmpty()){
-            return true;
-        }
-        else if (currSize == size()){
-            if (time.elapsed() > maxEventWaitTime){
-                return false;
-            }
-        }
-        else{
-            currSize = size();
-            time.restart();
-        }
-    }
-    return false;
-}
-
-void QEventOutputList::sleep(int sleepTime)
-{
-    QTime time;
-    time.restart();
-    while (time.elapsed() < sleepTime)
-        QCoreApplication::processEvents(QEventLoop::AllEvents, 50);
-}
diff --git a/tests/auto/macnativeevents/qnativeplayer.h b/tests/auto/macnativeevents/nativeeventlist.h
index 61ee162..688665d 100644
--- a/tests/auto/macnativeevents/qnativeplayer.h
+++ b/tests/auto/macnativeevents/nativeeventlist.h
@@ -43,22 +43,25 @@
 #define Q_NATIVE_PLAYBACK
 
 #include <QtCore>
-#include "qnativeinput.h"
+#include "qnativeevents.h"
 
-class QNativePlayer : public QObject
+class NativeEventList : public QObject
 {
     Q_OBJECT;
 
     public:
     enum Playback {ReturnImmediately, WaitUntilFinished};
 
-    QNativePlayer();
-    ~QNativePlayer();
+    NativeEventList(int defaultWaitMs = 20);
+    ~NativeEventList();
 
+    void append(QNativeEvent *event);
     void append(int waitMs, QNativeEvent *event = 0);
+    void append(int waitMs);
+
     void play(Playback playback = WaitUntilFinished);
     void stop();
-    float playbackMultiplier;
+    void setTimeMultiplier(float multiplier);
 
 signals:
     void done();
@@ -66,27 +69,14 @@ signals:
 private slots:
     void sendNextEvent();
 
-    private:
+private:
     void waitNextEvent();
 
     QList<QPair<int, QNativeEvent *> > eventList;
+    float playbackMultiplier;
     int currIndex;
     bool wait;
+    int defaultWaitMs;
 };
 
-// ******************************************************************
-
-class QEventOutputList : public QList<QEvent *>
-{
-public:
-    QEventOutputList();
-    ~QEventOutputList();
-    bool waitUntilEmpty(int maxEventWaitTime = 1000);
-    bool wait;
-
-    // Useful method. Just sleep and process events:
-    static void sleep(int sleepTime);
-};
-
-
 #endif
diff --git a/tests/auto/macnativeevents/qnativeinput.cpp b/tests/auto/macnativeevents/qnativeevents.cpp
index c9462a6..cb4b82e 100644
--- a/tests/auto/macnativeevents/qnativeinput.cpp
+++ b/tests/auto/macnativeevents/qnativeevents.cpp
@@ -39,7 +39,7 @@
 **
 ****************************************************************************/
 
-#include "qnativeinput.h"
+#include "qnativeevents.h"
 
 QNativeInput::QNativeInput(bool subscribe)
 {
diff --git a/tests/auto/macnativeevents/qnativeinput.h b/tests/auto/macnativeevents/qnativeevents.h
index a98e4e4..a98e4e4 100644
--- a/tests/auto/macnativeevents/qnativeinput.h
+++ b/tests/auto/macnativeevents/qnativeevents.h
diff --git a/tests/auto/macnativeevents/qnativeinput_mac.cpp b/tests/auto/macnativeevents/qnativeevents_mac.cpp
index 143a633..6c04bf3 100644
--- a/tests/auto/macnativeevents/qnativeinput_mac.cpp
+++ b/tests/auto/macnativeevents/qnativeevents_mac.cpp
@@ -39,7 +39,7 @@
 **
 ****************************************************************************/
 
-#include "qnativeinput.h"
+#include "qnativeevents.h"
 #include <Carbon/Carbon.h>
 #include <QtCore>
 
diff --git a/tests/auto/macnativeevents/tst_macnativeevents.cpp b/tests/auto/macnativeevents/tst_macnativeevents.cpp
index ccadd54..08ab9e6 100644
--- a/tests/auto/macnativeevents/tst_macnativeevents.cpp
+++ b/tests/auto/macnativeevents/tst_macnativeevents.cpp
@@ -44,8 +44,9 @@
 #include <QPushButton>
 #include <QtTest/QtTest>
 
-#include "qnativeinput.h"
-#include "qnativeplayer.h"
+#include "qnativeevents.h"
+#include "nativeeventlist.h"
+#include "expectedeventlist.h"
 
 #ifdef Q_OS_MAC
 
@@ -55,21 +56,233 @@ class tst_MacNativeEvents : public QObject
 {
 Q_OBJECT
 private slots:
-    void testLeftMousePressRelease();
+    void testMouseMoveLocation();
+    void testPushButtonPressRelease();
+    void testMouseLeftDoubleClick();
+    void stressTestMouseLeftDoubleClick();
+    void testMouseDragInside();
+    void testMouseDragOutside();
+    void testMouseDragToNonClientArea();
+    void testDragWindow();
+    void testMouseEnter();
 };
 
-void tst_MacNativeEvents::testLeftMousePressRelease()
+void tst_MacNativeEvents::testMouseMoveLocation()
 {
+    QWidget w;
+    w.setMouseTracking(true);
+    w.show();
+    QPoint p = w.geometry().center();
+
+    NativeEventList native;
+    native.append(new QNativeMouseMoveEvent(p, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(p), p, Qt::NoButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+void tst_MacNativeEvents::testPushButtonPressRelease()
+{
+    // Check that a native mouse press and release generates the
+    // same qevents on a pushbutton:
     QPushButton w("click me");
     w.show();
     QPoint p = w.geometry().center();
 
-    QNativePlayer player;
-    player.append(50, new QNativeMouseButtonEvent(p, Qt::LeftButton, 1, Qt::NoModifier));
-    player.append(50, new QNativeMouseButtonEvent(p, Qt::LeftButton, 0, Qt::NoModifier));
-    player.play();
+    NativeEventList native;
+    native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 1, Qt::NoModifier));
+    native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 0, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QMouseEvent(QEvent::MouseButtonPress, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+void tst_MacNativeEvents::testMouseLeftDoubleClick()
+{
+    // Check that a native double click makes
+    // the test widget receive a press-release-click-release:
+    QWidget w;
+    w.show();
+    QPoint p = w.geometry().center();
+
+    NativeEventList native;
+    native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 1, Qt::NoModifier));
+    native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 0, Qt::NoModifier));
+    native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 2, Qt::NoModifier));
+    native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 0, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QMouseEvent(QEvent::MouseButtonPress, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseButtonDblClick, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+void tst_MacNativeEvents::stressTestMouseLeftDoubleClick()
+{
+    // Check that multiple, fast, double clicks makes
+    // the test widget receive correct click events
+    QWidget w;
+    w.show();
+    QPoint p = w.geometry().center();
+
+    NativeEventList native;
+    ExpectedEventList expected(&w);
+
+    for (int i=0; i<10; ++i){
+        native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 1, Qt::NoModifier));
+        native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 0, Qt::NoModifier));
+        native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 2, Qt::NoModifier));
+        native.append(new QNativeMouseButtonEvent(p, Qt::LeftButton, 0, Qt::NoModifier));
+
+        expected.append(new QMouseEvent(QEvent::MouseButtonPress, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+        expected.append(new QMouseEvent(QEvent::MouseButtonDblClick, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(p), p, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+    }
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
 }
 
+void tst_MacNativeEvents::testMouseDragInside()
+{
+    // Check that a mouse drag inside a widget
+    // will cause press-move-release events to be delivered
+    QWidget w;
+    w.show();
+    QPoint p1 = w.geometry().center();
+    QPoint p2 = p1 - QPoint(10, 0);
+    QPoint p3 = p1 - QPoint(20, 0);
+    QPoint p4 = p1 - QPoint(30, 0);
+
+    NativeEventList native;
+    native.append(new QNativeMouseButtonEvent(p1, Qt::LeftButton, 1, Qt::NoModifier));
+    native.append(new QNativeMouseDragEvent(p2, Qt::LeftButton, Qt::NoModifier));
+    native.append(new QNativeMouseDragEvent(p3, Qt::LeftButton, Qt::NoModifier));
+    native.append(new QNativeMouseButtonEvent(p4, Qt::LeftButton, 0, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QMouseEvent(QEvent::MouseButtonPress, w.mapFromGlobal(p1), p1, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(p2), p2, Qt::NoButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(p3), p3, Qt::NoButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(p4), p4, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+void tst_MacNativeEvents::testMouseDragOutside()
+{
+    // Check that if we drag the mouse from inside the
+    // widget, and release it outside, we still get mouse move
+    // and release events when the mouse is outside the widget.
+    QWidget w;
+    w.show();
+    QPoint inside1 = w.geometry().center();
+    QPoint inside2 = inside1 - QPoint(10, 0);
+    QPoint outside1 = w.geometry().topLeft() - QPoint(50, 0);
+    QPoint outside2 = outside1 - QPoint(10, 0);
+
+    NativeEventList native;
+    native.append(new QNativeMouseButtonEvent(inside1, Qt::LeftButton, 1, Qt::NoModifier));
+    native.append(new QNativeMouseDragEvent(inside2, Qt::LeftButton, Qt::NoModifier));
+    native.append(new QNativeMouseDragEvent(outside1, Qt::LeftButton, Qt::NoModifier));
+    native.append(new QNativeMouseButtonEvent(outside2, Qt::LeftButton, 0, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QMouseEvent(QEvent::MouseButtonPress, w.mapFromGlobal(inside1), inside1, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(inside2), inside2, Qt::NoButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(outside1), outside1, Qt::NoButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(outside2), outside2, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+void tst_MacNativeEvents::testMouseDragToNonClientArea()
+{
+    // Check that if we drag the mouse from inside the
+    // widget, and release it on the title bar, we still get mouse move
+    // and release events when the mouse is on the title bar
+    QWidget w;
+    w.show();
+    QPoint inside1 = w.geometry().center();
+    QPoint inside2 = inside1 - QPoint(10, 0);
+    QPoint titlebar1 = w.geometry().topLeft() - QPoint(-100, 10);
+    QPoint titlebar2 = titlebar1 - QPoint(10, 0);
+
+    NativeEventList native;
+    native.append(new QNativeMouseButtonEvent(inside1, Qt::LeftButton, 1, Qt::NoModifier));
+    native.append(new QNativeMouseDragEvent(inside2, Qt::LeftButton, Qt::NoModifier));
+    native.append(new QNativeMouseDragEvent(titlebar1, Qt::LeftButton, Qt::NoModifier));
+    native.append(new QNativeMouseButtonEvent(titlebar2, Qt::LeftButton, 0, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QMouseEvent(QEvent::MouseButtonPress, w.mapFromGlobal(inside1), inside1, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(inside2), inside2, Qt::NoButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(titlebar1), titlebar1, Qt::NoButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::MouseButtonRelease, w.mapFromGlobal(titlebar2), titlebar2, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+void tst_MacNativeEvents::testDragWindow()
+{
+    // Check that if we drag the mouse from inside the
+    // widgets title bar, we get a move event on the window
+    QWidget w;
+    w.show();
+    QPoint titlebar = w.geometry().topLeft() - QPoint(-100, 10);
+    QPoint moveTo = titlebar + QPoint(100, 0);
+
+    NativeEventList native;
+    native.append(new QNativeMouseButtonEvent(titlebar, Qt::LeftButton, 1, Qt::NoModifier));
+    native.append(new QNativeMouseDragEvent(moveTo, Qt::LeftButton, Qt::NoModifier));
+    native.append(500, new QNativeMouseButtonEvent(moveTo, Qt::LeftButton, 0, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QMouseEvent(QEvent::NonClientAreaMouseButtonPress, w.mapFromGlobal(titlebar), titlebar, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+    expected.append(new QMouseEvent(QEvent::NonClientAreaMouseButtonRelease, w.mapFromGlobal(titlebar), moveTo, Qt::LeftButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+void tst_MacNativeEvents::testMouseEnter()
+{
+    // When a mouse enters a widget, both a mouse enter events and a
+    // mouse move event should be sendt. Lets test this:
+    QWidget w;
+    w.setMouseTracking(true);
+    w.show();
+    QPoint outside = w.geometry().topLeft() - QPoint(50, 0);
+    QPoint inside = w.geometry().center();
+
+    NativeEventList native;
+    native.append(new QNativeMouseMoveEvent(outside, Qt::NoModifier));
+    native.append(new QNativeMouseMoveEvent(inside, Qt::NoModifier));
+
+    ExpectedEventList expected(&w);
+    expected.append(new QEvent(QEvent::Enter));
+    expected.append(new QMouseEvent(QEvent::MouseMove, w.mapFromGlobal(inside), inside, Qt::NoButton, Qt::NoButton, Qt::NoModifier));
+
+    native.play();
+    QVERIFY2(expected.waitForAllEvents(), "the test did not receive all expected events!");
+}
+
+
 #include "tst_macnativeevents.moc"
 
 QTEST_MAIN(tst_MacNativeEvents)
diff --git a/tests/auto/qelapsedtimer/tst_qelapsedtimer.cpp b/tests/auto/qelapsedtimer/tst_qelapsedtimer.cpp
index 9ea422c..87df57d 100644
--- a/tests/auto/qelapsedtimer/tst_qelapsedtimer.cpp
+++ b/tests/auto/qelapsedtimer/tst_qelapsedtimer.cpp
@@ -46,6 +46,17 @@
 
 static const int minResolution = 50; // the minimum resolution for the tests
 
+QDebug operator<<(QDebug s, const QElapsedTimer &t)
+{
+    union {
+        QElapsedTimer t;
+        struct { qint64 t1, t2; } i;
+    } copy;
+    copy.t = t;
+    s.nospace() << "(" <<  copy.i.t1 << ", " << copy.i.t2 << ")";
+    return s.space();
+}
+
 class tst_QElapsedTimer : public QObject
 {
     Q_OBJECT
@@ -110,15 +121,17 @@ void tst_QElapsedTimer::basics()
 #endif
 
     quint64 value1 = t1.msecsSinceReference();
+    qDebug() << value1 << t1;
     qint64 elapsed = t1.restart();
     QVERIFY(elapsed < minResolution);
 
     quint64 value2 = t1.msecsSinceReference();
+    qDebug() << value2 << t1 << elapsed;
     // in theory, elapsed == value2 - value1
 
     // However, since QElapsedTimer keeps internally the full resolution,
     // we have here a rounding error due to integer division
-    QVERIFY(qAbs(elapsed - qint64(value2 - value1)) < 1);
+    QVERIFY(qAbs(elapsed - qint64(value2 - value1)) <= 1);
 }
 
 void tst_QElapsedTimer::elapsed()
diff --git a/tests/auto/qhelpgenerator/data/test.qhp b/tests/auto/qhelpgenerator/data/test.qhp
index a97c00d..2c3f128 100644
--- a/tests/auto/qhelpgenerator/data/test.qhp
+++ b/tests/auto/qhelpgenerator/data/test.qhp
@@ -3,7 +3,7 @@
     <metaData name="author" value="Nokia Corporation and/or its subsidiary(-ies)" />
     <metaData name="language" value="en" />
 	<virtualFolder>testFolder</virtualFolder>
-	<namespace>trolltech.com.1_0_0.test</namespace>
+	<namespace>trolltech.com.1.0.0.test</namespace>
 	<customFilter name="Custom Filter 1">
 		<filterAttribute>test</filterAttribute>
 		<filterAttribute>filter1</filterAttribute>		
diff --git a/tests/auto/qhelpgenerator/tst_qhelpgenerator.cpp b/tests/auto/qhelpgenerator/tst_qhelpgenerator.cpp
index 34ee7c6..a190081 100644
--- a/tests/auto/qhelpgenerator/tst_qhelpgenerator.cpp
+++ b/tests/auto/qhelpgenerator/tst_qhelpgenerator.cpp
@@ -119,7 +119,7 @@ void tst_QHelpGenerator::checkNamespace()
 {
     m_query->exec("SELECT Id, Name FROM NamespaceTable");
     if (m_query->next()
-        && m_query->value(1).toString() == QLatin1String("trolltech.com.1_0_0.test"))
+        && m_query->value(1).toString() == QLatin1String("trolltech.com.1.0.0.test"))
         return;
     QFAIL("Namespace Error!");
 }
diff --git a/tests/auto/qhelpprojectdata/data/test.qhp b/tests/auto/qhelpprojectdata/data/test.qhp
index e9ac7f2..1e9074a 100644
--- a/tests/auto/qhelpprojectdata/data/test.qhp
+++ b/tests/auto/qhelpprojectdata/data/test.qhp
@@ -3,7 +3,7 @@
     <metaData name="author" value="Nokia Corporation and/or its subsidiary(-ies)" />
     <metaData name="language" value="en" />
 	<virtualFolder>testFolder</virtualFolder>
-	<namespace>trolltech.com.1_0_0.test</namespace>
+	<namespace>trolltech.com.1.0.0.test</namespace>
 	<customFilter name="Custom Filter 1">
 		<filterAttribute>test</filterAttribute>
 		<filterAttribute>filter1</filterAttribute>		
@@ -69,4 +69,4 @@
 			<file>cars.html</file>			
 		</files>
 	</filterSection>
-</QtHelpProject>
\ No newline at end of file
+</QtHelpProject>
diff --git a/tests/auto/qhelpprojectdata/tst_qhelpprojectdata.cpp b/tests/auto/qhelpprojectdata/tst_qhelpprojectdata.cpp
index 929cab5..9c458f7 100644
--- a/tests/auto/qhelpprojectdata/tst_qhelpprojectdata.cpp
+++ b/tests/auto/qhelpprojectdata/tst_qhelpprojectdata.cpp
@@ -83,7 +83,7 @@ void tst_QHelpProjectData::namespaceName()
     QHelpProjectData data;
     if (!data.readData(m_inputFile))
         QFAIL("Cannot read qhp file!");
-    QCOMPARE(data.namespaceName(), QString("trolltech.com.1_0_0.test"));
+    QCOMPARE(data.namespaceName(), QString("trolltech.com.1.0.0.test"));
 }
 
 void tst_QHelpProjectData::virtualFolder()
diff --git a/tests/auto/qmenu/tst_qmenu.cpp b/tests/auto/qmenu/tst_qmenu.cpp
index e10d7ee..4be6fdd 100644
--- a/tests/auto/qmenu/tst_qmenu.cpp
+++ b/tests/auto/qmenu/tst_qmenu.cpp
@@ -106,6 +106,8 @@ private slots:
     void pushButtonPopulateOnAboutToShow();
     void QTBUG7907_submenus_autoselect();
     void QTBUG7411_submenus_activate();
+    void menuGeometry_data();
+    void menuGeometry();
 protected slots:
     void onActivated(QAction*);
     void onHighlighted(QAction*);
@@ -967,6 +969,60 @@ void tst_QMenu::QTBUG7411_submenus_activate()
     QTRY_VERIFY(sub1.isVisible());
 }
 
+void tst_QMenu::menuGeometry_data()
+{
+    QTest::addColumn<QRect>("screen");
+    QTest::addColumn<QPoint>("pos");
+    QTest::addColumn<QPoint>("expectedPos");
+
+    QMenu menu("Test Menu");
+    for (int i = 0; i < 3; ++i)
+        menu.addAction("Hello World!");
+
+    menu.adjustSize();
+
+    const int screenCount = QApplication::desktop()->screenCount();
+    const int desktopFrame = menu.style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, &menu);
+
+    for (int i = 0; i < screenCount; ++i) {
+        const QRect screen = QApplication::desktop()->screenGeometry(i);
+
+        if (screen.width() < menu.width() || screen.height() < menu.height())
+            continue;
+
+        QTest::newRow("topLeft") << screen << screen.topLeft()
+            << QPoint(screen.left() + desktopFrame, screen.top() + desktopFrame);
+
+        QTest::newRow("topRight") << screen << screen.topRight()
+            << QPoint(screen.right() - desktopFrame - menu.width() + 1, screen.top() + desktopFrame);
+
+        QTest::newRow("bottomLeft") << screen << screen.bottomLeft()
+            << QPoint(screen.left() + desktopFrame, screen.bottom() - desktopFrame - menu.height() + 1);
+
+        QTest::newRow("bottomRight") << screen << screen.bottomRight()
+            << QPoint(screen.right() - desktopFrame - menu.width() + 1, screen.bottom() - desktopFrame - menu.height() + 1);
+
+        const QPoint pos = QPoint(screen.right() - qMax(desktopFrame, 20), screen.bottom() - qMax(desktopFrame, 20));
+        QTest::newRow("position") << screen << pos
+            << QPoint(screen.right() - menu.width() + 1, pos.y() - menu.height() + 1);
+    }
+}
+
+void tst_QMenu::menuGeometry()
+{
+    QFETCH(QRect, screen);
+    QFETCH(QPoint, pos);
+    QFETCH(QPoint, expectedPos);
+
+    QMenu menu("Test Menu");
+    for (int i = 0; i < 3; ++i)
+        menu.addAction("Hello World!");
+
+    menu.popup(pos);
+    QTest::qWaitForWindowShown(&menu);
+    QVERIFY(screen.contains(menu.geometry()));
+    QCOMPARE(menu.pos(), expectedPos);
+}
 
 
 QTEST_MAIN(tst_QMenu)
diff --git a/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp b/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp
index 10ff488..a280256 100644
--- a/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp
+++ b/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp
@@ -683,11 +683,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 7", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 26", willFixInNextReleaseMessage);
 
-#ifndef Q_CC_MINGW
-    addExpectedFailure("ecma/Expressions/11.4.7-02.js", "-(-2147483648) == 2147483648", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma/TypeConversion/9.3.1-3.js", "- -\"0x80000000\"", willFixInNextReleaseMessage);
-#endif
-
 #ifdef Q_CC_MSVC
     addExpectedFailure("ecma_3/Expressions/11.7.3-01.js", "11.7.3 - >>> should evaluate operands in order: order", "QTBUG-8056");
     addExpectedFailure("ecma_3/Operators/order-01.js", "operator evaluation order: 11.7.3 >>>", "QTBUG-8056");
diff --git a/tests/auto/qtextcursor/tst_qtextcursor.cpp b/tests/auto/qtextcursor/tst_qtextcursor.cpp
index f55b8db..d44ce72 100644
--- a/tests/auto/qtextcursor/tst_qtextcursor.cpp
+++ b/tests/auto/qtextcursor/tst_qtextcursor.cpp
@@ -150,6 +150,7 @@ private slots:
     void adjustCursorsOnInsert();
 
     void cursorPositionWithBlockUndoAndRedo();
+    void cursorPositionWithBlockUndoAndRedo2();
 
 private:
     int blockCount();
@@ -1778,5 +1779,38 @@ void tst_QTextCursor::cursorPositionWithBlockUndoAndRedo()
     QCOMPARE(cursor.position(), cursorPositionAfter);
 }
 
+void tst_QTextCursor::cursorPositionWithBlockUndoAndRedo2()
+{
+    cursor.insertText("AAAABBBB");
+    int cursorPositionBefore = cursor.position();
+    cursor.setPosition(0, QTextCursor::KeepAnchor);
+    cursor.beginEditBlock();
+    cursor.removeSelectedText();
+    cursor.insertText("AAAABBBBCCCCDDDD");
+    cursor.endEditBlock();
+    doc->undo(&cursor);
+    QVERIFY(doc->toPlainText() == "AAAABBBB");
+    QCOMPARE(cursor.position(), cursorPositionBefore);
+
+    cursor.insertText("CCCC");
+    QVERIFY(doc->toPlainText() == "AAAABBBBCCCC");
+
+    cursorPositionBefore = cursor.position();
+    cursor.setPosition(0, QTextCursor::KeepAnchor);
+    cursor.beginEditBlock();
+    cursor.removeSelectedText();
+    cursor.insertText("AAAABBBBCCCCDDDD");
+    cursor.endEditBlock();
+
+    /* this undo now implicitely reinserts two segments, first "CCCCC", then
+       "AAAABBBB". The test ensures that the two are combined in order to
+       reconstruct the correct cursor position */
+    doc->undo(&cursor);
+
+
+    QVERIFY(doc->toPlainText() == "AAAABBBBCCCC");
+    QCOMPARE(cursor.position(), cursorPositionBefore);
+}
+
 QTEST_MAIN(tst_QTextCursor)
 #include "tst_qtextcursor.moc"