Squashed commit of the topic/exceptions branch.

Contains some smaller fixes and renaming of macros. Looks big,
but isn't scary at all ;)

2 files changed, 338 insertions, 77 deletions

diff --git a/tests/auto/exceptionsafety_objects/oomsimulator.h b/tests/auto/exceptionsafety_objects/oomsimulator.h
index 3c8b389f3b..11dd769fdb 100644
--- a/tests/auto/exceptionsafety_objects/oomsimulator.h
+++ b/tests/auto/exceptionsafety_objects/oomsimulator.h
@@ -39,10 +39,29 @@
 **
 ****************************************************************************/
 
+#ifndef Q_OS_SYMBIAN
 #include <malloc.h>
+#endif
 #include <limits.h>
-#include "3rdparty/memcheck.h"
+#include <stdio.h>
+#include <exception>
 
+#if !defined(Q_OS_WIN) && !defined(Q_OS_SYMBIAN)
+#  include "3rdparty/memcheck.h"
+#endif
+
+static bool mallocFailActive = false;
+static int mallocFailIndex = 0;
+static int mallocCount = 0;
+
+static void my_terminate_handler()
+{
+    // set a breakpoint here to get a backtrace for your uncaught exceptions
+    fprintf(stderr, "Uncaught Exception Detected. Set a breakpoint in my_terminate_handler()\n");
+    exit(1);
+}
+
+#ifdef __GLIBC__
 /* Use glibc's memory allocation hooks */
 
 /* our hooks */
@@ -88,40 +107,6 @@ void my_init_hook()
     enableHooks();
 }
 
-static bool mallocFailActive = false;
-static int mallocFailIndex = 0;
-static int mallocCount = 0;
-
-struct AllocFailer
-{
-    inline AllocFailer() { mallocFailActive = true; setAllocFailIndex(0); }
-    inline ~AllocFailer() { deactivate(); }
-
-    inline void setAllocFailIndex(int index)
-    {
-        if (RUNNING_ON_VALGRIND) {
-            VALGRIND_ENABLE_OOM_AT_ALLOC_INDEX(VALGRIND_GET_ALLOC_INDEX + index + 1);
-        } else {
-            mallocFailIndex = index;
-        }
-    }
-
-    inline void deactivate()
-    {
-        mallocFailActive = false;
-        VALGRIND_ENABLE_OOM_AT_ALLOC_INDEX(INT_MAX);
-    }
-
-    inline int currentAllocIndex() const
-    {
-        if (RUNNING_ON_VALGRIND) {
-            return VALGRIND_GET_ALLOC_INDEX;
-        } else {
-            return mallocCount;
-        }
-    }
-};
-
 void *my_malloc_hook(size_t size, const void *)
 {
     ++mallocCount;
@@ -173,6 +158,98 @@ void my_free_hook(void *ptr, const void *)
     __free_hook = my_free_hook;
 }
 
+#elif defined(Q_CC_MSVC)
+
+#include "crtdbg.h"
+
+static int qCrtAllocHook(int allocType, void * /*userData*/, size_t /*size*/,
+                         int blockType, long /*requestNumber*/,
+                         const unsigned char * /*filename*/, int /*lineNumber*/)
+{
+    if (blockType == _CRT_BLOCK)
+        return TRUE; // ignore allocations from the C library
+
+    switch (allocType) {
+        case _HOOK_ALLOC:
+        case _HOOK_REALLOC:
+            ++mallocCount;
+            if (mallocFailActive && --mallocFailIndex < 0)
+                return FALSE; // simulate OOM
+    }
+
+    return TRUE;
+}
+
+static struct QCrtDebugRegistrator
+{
+    QCrtDebugRegistrator()
+    {
+        _CrtSetAllocHook(qCrtAllocHook);
+    }
+
+} crtDebugRegistrator;
+
+#endif
+
+struct AllocFailer
+{
+    inline AllocFailer(int index) { reactivateAt(index); }
+    inline ~AllocFailer() { deactivate(); }
+
+    inline void reactivateAt(int index)
+    {
+#ifdef RUNNING_ON_VALGRIND
+        if (RUNNING_ON_VALGRIND)
+            VALGRIND_ENABLE_OOM_AT_ALLOC_INDEX(VALGRIND_GET_ALLOC_INDEX + index + 1);
+#elif defined(Q_OS_SYMBIAN)
+        // symbian alloc fail index is 1 based
+        __UHEAP_BURSTFAILNEXT(index+1, KMaxTUint16);
+#endif
+        mallocFailIndex = index;
+        mallocFailActive = true;
+    }
+
+    inline void deactivate()
+    {
+        mallocFailActive = false;
+#ifdef RUNNING_ON_VALGRIND
+        VALGRIND_ENABLE_OOM_AT_ALLOC_INDEX(0);
+#elif defined(Q_OS_SYMBIAN)
+        __UHEAP_RESET;
+#endif
+    }
+
+    inline int currentAllocIndex() const
+    {
+#ifdef RUNNING_ON_VALGRIND
+        if (RUNNING_ON_VALGRIND)
+            return VALGRIND_GET_ALLOC_INDEX;
+#endif
+        return mallocCount;
+    }
+
+    static bool initialize()
+    {
+        std::set_terminate(my_terminate_handler);
+#ifdef RUNNING_ON_VALGRIND
+        if (RUNNING_ON_VALGRIND) {
+            if (VALGRIND_GET_ALLOC_INDEX == -1u) {
+                qWarning("You must use a valgrind with oom simulation support");
+                return false;
+            }
+            // running in valgrind - don't use glibc hooks
+            disableHooks();
+
+            // never stop simulating OOM
+            VALGRIND_DISABLE_OOM_AT_ALLOC_INDEX(-1u);
+        }
+#endif
+         return true;
+    }
+};
+
+#ifndef Q_OS_SYMBIAN
+
 static void *new_helper(std::size_t size)
 {
     void *ptr = malloc(size);
@@ -181,6 +258,11 @@ static void *new_helper(std::size_t size)
     return ptr;
 }
 
+#ifdef Q_CC_MSVC
+#  pragma warning(push)
+#  pragma warning(disable: 4290)
+#endif
+
 // overload operator new
 void* operator new(size_t size) throw (std::bad_alloc) { return new_helper(size); }
 void* operator new[](size_t size) throw (std::bad_alloc) { return new_helper(size); }
@@ -193,6 +275,12 @@ void operator delete[](void *ptr) throw() { if (ptr) free(ptr); }
 void operator delete(void *ptr, const std::nothrow_t&) throw() { if (ptr) free(ptr); }
 void operator delete[](void *ptr, const std::nothrow_t&) throw() { if (ptr) free (ptr); }
 
+#ifdef Q_CC_MSVC
+#  pragma warning(pop)
+#endif
+
+#endif
+
 // ignore placement new and placement delete - those don't allocate.
 
 
diff --git a/tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp b/tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp
index dd5f8da90d..c867899640 100644
--- a/tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp
+++ b/tests/auto/exceptionsafety_objects/tst_exceptionsafety_objects.cpp
@@ -42,15 +42,21 @@
 #include <QtGui/QtGui>
 #include <QtTest/QtTest>
 
+#include <stddef.h>
+
 QT_USE_NAMESPACE
 
-// this test only works with GLIBC (let moc run regardless, because it doesn't know about __GLIBC__)
-#if defined(QT_NO_EXCEPTIONS) || (!defined(__GLIBC__) && !defined(Q_MOC_RUN))
+// this test only works with
+//   * GLIBC
+//   * MSVC - only debug builds (we need the crtdbg.h helpers)
+#if (defined(QT_NO_EXCEPTIONS) || (!defined(__GLIBC__) && !defined(Q_CC_MSVC) && !defined(Q_OS_SYMBIAN))) && !defined(Q_MOC_RUN)
     QTEST_NOOP_MAIN
 #else
 
 #include "oomsimulator.h"
+#if !defined(Q_OS_SYMBIAN)
 #include "3rdparty/memcheck.h"
+#endif
 
 class tst_ExceptionSafetyObjects: public QObject
 {
@@ -70,7 +76,7 @@ private slots:
 // helper structs to create an arbitrary widget
 struct AbstractObjectCreator
 {
-    virtual QObject *create(QObject *parent) = 0;
+    virtual void test(QObject *parent) = 0;
 };
 
 Q_DECLARE_METATYPE(AbstractObjectCreator *)
@@ -78,9 +84,57 @@ Q_DECLARE_METATYPE(AbstractObjectCreator *)
 template <typename T>
 struct ObjectCreator : public AbstractObjectCreator
 {
-    QObject *create(QObject *parent)
+    void test(QObject *)
+    {
+        QScopedPointer<T> ptr(new T);
+    }
+};
+
+struct BitArrayCreator : public AbstractObjectCreator
+{
+    void test(QObject *)
+    { QScopedPointer<QBitArray> bitArray(new QBitArray(100, true)); }
+};
+
+struct ByteArrayMatcherCreator : public AbstractObjectCreator
+{
+    void test(QObject *)
+    { QScopedPointer<QByteArrayMatcher> ptr(new QByteArrayMatcher("ralf test",8)); }
+};
+
+struct CryptographicHashCreator : public AbstractObjectCreator
+{
+    void test(QObject *)
+    {
+        QScopedPointer<QCryptographicHash> ptr(new QCryptographicHash(QCryptographicHash::Sha1));
+        ptr->addData("ralf test",8);
+    }
+};
+
+struct DataStreamCreator : public AbstractObjectCreator
+{
+    void test(QObject *)
     {
-        return parent ? new T(parent) : new T;
+        QScopedPointer<QByteArray> arr(new QByteArray("hallo, test"));
+        QScopedPointer<QDataStream> ptr(new QDataStream(arr.data(), QIODevice::ReadWrite));
+        ptr->writeBytes("ralf test",8);
+    }
+};
+
+struct DirCreator : public AbstractObjectCreator
+{
+    void test(QObject *)
+    {
+        QDir::cleanPath("../////././");
+        QScopedPointer<QDir> ptr(new QDir("."));
+        while( ptr->cdUp() )
+            ; // just going up
+        ptr->count();
+        ptr->exists(ptr->path());
+
+        QStringList filters;
+        filters << "*.cpp" << "*.cxx" << "*.cc";
+        ptr->setNameFilters(filters);
     }
 };
 
@@ -90,46 +144,83 @@ void tst_ExceptionSafetyObjects::objects_data()
 
 #define NEWROW(T) QTest::newRow(#T) << static_cast<AbstractObjectCreator *>(new ObjectCreator<T >)
     NEWROW(QObject);
+    NEWROW(QBuffer);
+    NEWROW(QFile);
+    NEWROW(QProcess);
+    NEWROW(QSettings);
+    // NEWROW(QSocketNotifier);
+    NEWROW(QThread);
+    NEWROW(QThreadPool);
+    NEWROW(QTranslator);
+    NEWROW(QFSFileEngine);
+
+#define NEWROW2(T, CREATOR) QTest::newRow(#T) << static_cast<AbstractObjectCreator *>(new CREATOR)
+    NEWROW2(QBitArray, BitArrayCreator);
+    NEWROW2(QByteArrayMatcher, ByteArrayMatcherCreator);
+    NEWROW2(QCryptographicHash, CryptographicHashCreator);
+    NEWROW2(QDataStream, DataStreamCreator);
+    NEWROW2(QDir, DirCreator);
+
 }
 
 // create and destructs an object, and lets each and every allocation
 // during construction and destruction fail.
 static void doOOMTest(AbstractObjectCreator *creator, QObject *parent)
 {
-    AllocFailer allocFailer;
     int currentOOMIndex = 0;
     bool caught = false;
+    bool done = false;
 
-    int allocStartIndex = 0;
-    int allocEndIndex = 0;
-    int lastAllocCount = 0;
+    AllocFailer allocFailer(0);
+    int allocCountBefore = allocFailer.currentAllocIndex();
 
     do {
-        allocFailer.setAllocFailIndex(++currentOOMIndex);
+        allocFailer.reactivateAt(++currentOOMIndex);
 
         caught = false;
-        lastAllocCount = allocEndIndex - allocStartIndex;
-        allocStartIndex = allocFailer.currentAllocIndex();
 
         try {
-            QScopedPointer<QObject> ptr(creator->create(parent));
+            creator->test(parent);
         } catch (const std::bad_alloc &) {
             caught = true;
+        } catch (const std::exception &ex) {
+            if (strcmp(ex.what(), "autotest swallow") != 0)
+                throw;
+            caught = true;
+        }
+
+        if (!caught) {
+            void *buf = malloc(42);
+            if (buf) {
+                // we got memory here - oom test is over.
+                free(buf);
+                done = true;
+            }
         }
 
-        allocEndIndex = allocFailer.currentAllocIndex();
+//#define REALLY_VERBOSE
+#ifdef REALLY_VERBOSE
+    fprintf(stderr, " OOM Index: %d\n", currentOOMIndex);
+#endif
 
-    } while (caught || allocEndIndex - allocStartIndex != lastAllocCount);
+
+    } while (caught || !done);
 
     allocFailer.deactivate();
+
+//#define VERBOSE
+#ifdef VERBOSE
+    fprintf(stderr, "OOM Test done, checked allocs: %d (range %d - %d)\n", currentOOMIndex,
+                allocCountBefore, allocFailer.currentAllocIndex());
+#endif
 }
 
-static bool alloc1Failed = false;
-static bool alloc2Failed = false;
-static bool alloc3Failed = false;
-static bool alloc4Failed = false;
-static bool malloc1Failed = false;
-static bool malloc2Failed = false;
+static int alloc1Failed = 0;
+static int alloc2Failed = 0;
+static int alloc3Failed = 0;
+static int alloc4Failed = 0;
+static int malloc1Failed = 0;
+static int malloc2Failed = 0;
 
 // Tests that new, new[] and malloc() fail at least once during OOM testing.
 class SelfTestObject : public QObject
@@ -138,54 +229,62 @@ public:
     SelfTestObject(QObject *parent = 0)
         : QObject(parent)
     {
-        try { delete new int; } catch (const std::bad_alloc &) { alloc1Failed = true; }
-        try { delete [] new double[5]; } catch (const std::bad_alloc &) { alloc2Failed = true; }
+        try { delete new int; } catch (const std::bad_alloc &) { ++alloc1Failed; throw; }
+        try { delete [] new double[5]; } catch (const std::bad_alloc &) { ++alloc2Failed; throw ;}
         void *buf = malloc(42);
         if (buf)
             free(buf);
         else
-            malloc1Failed = true;
+            ++malloc1Failed;
     }
 
     ~SelfTestObject()
     {
-        try { delete new int; } catch (const std::bad_alloc &) { alloc3Failed = true; }
-        try { delete [] new double[5]; } catch (const std::bad_alloc &) { alloc4Failed = true; }
+        try { delete new int; } catch (const std::bad_alloc &) { ++alloc3Failed; }
+        try { delete [] new double[5]; } catch (const std::bad_alloc &) { ++alloc4Failed; }
         void *buf = malloc(42);
         if (buf)
             free(buf);
         else
-            malloc2Failed = true;
+            ++malloc2Failed = true;
     }
 };
 
 void tst_ExceptionSafetyObjects::initTestCase()
 {
-    if (RUNNING_ON_VALGRIND) {
-        QVERIFY2(VALGRIND_GET_ALLOC_INDEX != -1u,
-                 "You must use a valgrind with oom simulation support");
-        // running in valgrind - don't use glibc hooks
-        disableHooks();
-    }
+    QVERIFY(AllocFailer::initialize());
 
     // sanity check whether OOM simulation works
-    AllocFailer allocFailer;
+    AllocFailer allocFailer(0);
 
     // malloc fail index is 0 -> this malloc should fail.
     void *buf = malloc(42);
+    allocFailer.deactivate();
     QVERIFY(!buf);
 
     // malloc fail index is 1 - second malloc should fail.
-    allocFailer.setAllocFailIndex(1);
+    allocFailer.reactivateAt(1);
     buf = malloc(42);
+    void *buf2 = malloc(42);
+    allocFailer.deactivate();
+
     QVERIFY(buf);
     free(buf);
-    buf = malloc(42);
-    QVERIFY(!buf);
+    QVERIFY(!buf2);
 
-    allocFailer.deactivate();
+#ifdef Q_OS_SYMBIAN
+    // temporary workaround for INC138398
+    std::new_handler nh_func = std::set_new_handler(0);
+    (void) std::set_new_handler(nh_func);
+#endif
 
     doOOMTest(new ObjectCreator<SelfTestObject>, 0);
+    QCOMPARE(alloc1Failed, 1);
+    QCOMPARE(alloc2Failed, 1);
+    QCOMPARE(alloc3Failed, 2);
+    QCOMPARE(alloc4Failed, 3);
+    QCOMPARE(malloc1Failed, 1);
+    QCOMPARE(malloc2Failed, 1);
 }
 
 void tst_ExceptionSafetyObjects::objects()
@@ -198,23 +297,94 @@ void tst_ExceptionSafetyObjects::objects()
 template <typename T>
 struct WidgetCreator : public AbstractObjectCreator
 {
-    QObject *create(QObject *parent)
+    void test(QObject *parent)
+    {
+        Q_ASSERT(!parent || parent->isWidgetType());
+        QScopedPointer<T> ptr(parent ? new T(static_cast<QWidget *>(parent)) : new T);
+    }
+};
+
+// QSizeGrip doesn't have a default constructor - always pass parent (even though it might be 0)
+template <> struct WidgetCreator<QSizeGrip> : public AbstractObjectCreator
+{
+    void test(QObject *parent)
     {
-        return parent ? new T(static_cast<QWidget *>(parent)) : new T;
+        Q_ASSERT(!parent || parent->isWidgetType());
+        QScopedPointer<QSizeGrip> ptr(new QSizeGrip(static_cast<QWidget *>(parent)));
     }
 };
 
+// QDesktopWidget doesn't need a parent.
+template <> struct WidgetCreator<QDesktopWidget> : public AbstractObjectCreator
+{
+    void test(QObject *parent)
+    {
+        Q_ASSERT(!parent || parent->isWidgetType());
+        QScopedPointer<QDesktopWidget> ptr(new QDesktopWidget());
+    }
+};
 void tst_ExceptionSafetyObjects::widgets_data()
 {
     QTest::addColumn<AbstractObjectCreator *>("widgetCreator");
 
 #undef NEWROW
 #define NEWROW(T) QTest::newRow(#T) << static_cast<AbstractObjectCreator *>(new WidgetCreator<T >)
+
     NEWROW(QWidget);
-    NEWROW(QPushButton);
-    NEWROW(QLabel);
+
+    NEWROW(QButtonGroup);
+    NEWROW(QDesktopWidget);
+    NEWROW(QCheckBox);
+    NEWROW(QComboBox);
+    NEWROW(QCommandLinkButton);
+    NEWROW(QDateEdit);
+    NEWROW(QDateTimeEdit);
+    NEWROW(QDial);
+    NEWROW(QDoubleSpinBox);
+    NEWROW(QFocusFrame);
+    NEWROW(QFontComboBox);
     NEWROW(QFrame);
+    NEWROW(QGroupBox);
+    NEWROW(QLCDNumber);
+    NEWROW(QLabel);
+    NEWROW(QLCDNumber);
+    NEWROW(QLineEdit);
+    NEWROW(QMenu);
+    NEWROW(QPlainTextEdit);
+    NEWROW(QProgressBar);
+    NEWROW(QPushButton);
+    NEWROW(QRadioButton);
+    NEWROW(QScrollArea);
+    NEWROW(QScrollBar);
+    NEWROW(QSizeGrip);
+    NEWROW(QSlider);
+    NEWROW(QSpinBox);
+    NEWROW(QSplitter);
     NEWROW(QStackedWidget);
+    NEWROW(QStatusBar);
+    NEWROW(QTabBar);
+    NEWROW(QTabWidget);
+    NEWROW(QTextBrowser);
+    NEWROW(QTextEdit);
+    NEWROW(QTimeEdit);
+    NEWROW(QToolBox);
+    NEWROW(QToolButton);
+    NEWROW(QStatusBar);
+    NEWROW(QSplitter);
+    NEWROW(QTextEdit);
+    NEWROW(QTextBrowser);
+    NEWROW(QToolBar);
+    NEWROW(QMenuBar);
+    NEWROW(QMainWindow);
+    NEWROW(QWorkspace);
+    NEWROW(QColumnView);
+    NEWROW(QListView);
+    NEWROW(QListWidget);
+    NEWROW(QTableView);
+    NEWROW(QTableWidget);
+    NEWROW(QTreeView);
+    NEWROW(QTreeWidget);
+
 }
 
 void tst_ExceptionSafetyObjects::widgets()
@@ -225,6 +395,9 @@ void tst_ExceptionSafetyObjects::widgets()
 
     QWidget parent;
     doOOMTest(widgetCreator, &parent);
+
+    // if the test reaches here without crashing, we passed :)
+    QVERIFY(true);
 }
 
 QTEST_MAIN(tst_ExceptionSafetyObjects)