From 41a83e1ff19ad1396e6001e6b0ac003c701ba55a Mon Sep 17 00:00:00 2001 From: Harald Fernengel Date: Mon, 3 Aug 2009 15:12:46 +0200 Subject: Squashed commit of the topic/exceptions branch. Contains some smaller fixes and renaming of macros. Looks big, but isn't scary at all ;) --- tests/auto/exceptionsafety_objects/oomsimulator.h | 158 ++++++++++--- .../tst_exceptionsafety_objects.cpp | 257 +++++++++++++++++---- 2 files changed, 338 insertions(+), 77 deletions(-) (limited to 'tests/auto/exceptionsafety_objects') 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 +#endif #include -#include "3rdparty/memcheck.h" +#include +#include +#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 #include +#include + 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 struct ObjectCreator : public AbstractObjectCreator { - QObject *create(QObject *parent) + void test(QObject *) + { + QScopedPointer ptr(new T); + } +}; + +struct BitArrayCreator : public AbstractObjectCreator +{ + void test(QObject *) + { QScopedPointer bitArray(new QBitArray(100, true)); } +}; + +struct ByteArrayMatcherCreator : public AbstractObjectCreator +{ + void test(QObject *) + { QScopedPointer ptr(new QByteArrayMatcher("ralf test",8)); } +}; + +struct CryptographicHashCreator : public AbstractObjectCreator +{ + void test(QObject *) + { + QScopedPointer 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 arr(new QByteArray("hallo, test")); + QScopedPointer ptr(new QDataStream(arr.data(), QIODevice::ReadWrite)); + ptr->writeBytes("ralf test",8); + } +}; + +struct DirCreator : public AbstractObjectCreator +{ + void test(QObject *) + { + QDir::cleanPath("../////././"); + QScopedPointer 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(new ObjectCreator) 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(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 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, 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 struct WidgetCreator : public AbstractObjectCreator { - QObject *create(QObject *parent) + void test(QObject *parent) + { + Q_ASSERT(!parent || parent->isWidgetType()); + QScopedPointer ptr(parent ? new T(static_cast(parent)) : new T); + } +}; + +// QSizeGrip doesn't have a default constructor - always pass parent (even though it might be 0) +template <> struct WidgetCreator : public AbstractObjectCreator +{ + void test(QObject *parent) { - return parent ? new T(static_cast(parent)) : new T; + Q_ASSERT(!parent || parent->isWidgetType()); + QScopedPointer ptr(new QSizeGrip(static_cast(parent))); } }; +// QDesktopWidget doesn't need a parent. +template <> struct WidgetCreator : public AbstractObjectCreator +{ + void test(QObject *parent) + { + Q_ASSERT(!parent || parent->isWidgetType()); + QScopedPointer ptr(new QDesktopWidget()); + } +}; void tst_ExceptionSafetyObjects::widgets_data() { QTest::addColumn("widgetCreator"); #undef NEWROW #define NEWROW(T) QTest::newRow(#T) << static_cast(new WidgetCreator) + 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) -- cgit v1.2.3