Changeset 561 for trunk/src/testlib/qtestcase.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/testlib/qtestcase.cpp (modified) (40 diffs)

trunk/src/testlib/qtestcase.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtTest module of the Qt Toolkit.
@@ -21 +22 @@
 ** 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.
+** 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.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -55 +55 @@
 #include <QtCore/qprocess.h>
 #include <QtCore/qdebug.h>
+
 
 #include "QtTest/private/qtestlog_p.h"
@@ -72 +73 @@
 #endif
 #ifdef Q_OS_UNIX
+
+
 #include <time.h>
 #endif
@@ -301 +304 @@
     Use this macro to build stand-alone executables.
 
+
+
+
+
+
     Example:
     \snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 11
 
-    \sa QTEST_APPLESS_MAIN(), QTest::qExec()
+    \sa QTEST_APPLESS_MAIN(), QTest::qExec()
 */
 
@@ -348 +356 @@
         {Chapter 5: Writing a Benchmark}{Writing a Benchmark}
 */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /*! \enum QTest::SkipMode
@@ -401 +432 @@
     \overload
 
-    Simulates clicking of \a key with an optional \a modifier on a \a widget. If \a delay is larger than 0, the test will wait for \a delay milliseconds.
+    Simulates clicking of \a key with an optional \a modifier on a \a widget.
+    If \a delay is larger than 0, the test will wait for \a delay milliseconds.
 
     Example:
@@ -414 +446 @@
 /*! \fn void QTest::keyClick(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
 
-    Simulates clicking of \a key with an optional \a modifier on a \a widget. If \a delay is larger than 0, the test will wait for \a delay milliseconds.
+    Simulates clicking of \a key with an optional \a modifier on a \a widget.
+    If \a delay is larger than 0, the test will wait for \a delay milliseconds.
 
     Examples:
@@ -429 +462 @@
 /*! \fn void QTest::keyEvent(KeyAction action, QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
 
-    Sends a Qt key event to \a widget with the given \a key and an associated \a action. Optionally, a keyboard \a modifier can be specified, as well as a \a delay (in milliseconds) of the test before sending the event.
+    Sends a Qt key event to \a widget with the given \a key and an associated \a action.
+    Optionally, a keyboard \a modifier can be specified, as well as a \a delay
+    (in milliseconds) of the test before sending the event.
 */
 
@@ -436 +471 @@
     \overload
 
-    Sends a Qt key event to \a widget with the given key \a ascii and an associated \a action. Optionally, a keyboard \a modifier can be specified, as well as a \a delay (in milliseconds) of the test before sending the event.
+    Sends a Qt key event to \a widget with the given key \a ascii and an associated \a action.
+    Optionally, a keyboard \a modifier can be specified, as well as a \a delay
+    (in milliseconds) of the test before sending the event.
 
 */
@@ -442 +479 @@
 /*! \fn void QTest::keyPress(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
 
-    Simulates pressing a \a key with an optional \a modifier on a \a widget. If \a delay is larger than 0, the test will wait for \a delay milliseconds.
+    Simulates pressing a \a key with an optional \a modifier on a \a widget. If \a delay
+    is larger than 0, the test will wait for \a delay milliseconds.
 
     \bold {Note:} At some point you should release the key using \l keyRelease().
@@ -453 +491 @@
     \overload
 
-    Simulates pressing a \a key with an optional \a modifier on a \a widget. If \a delay is larger than 0, the test will wait for \a delay milliseconds.
+    Simulates pressing a \a key with an optional \a modifier on a \a widget.
+    If \a delay is larger than 0, the test will wait for \a delay milliseconds.
 
     \bold {Note:} At some point you should release the key using \l keyRelease().
@@ -462 +501 @@
 /*! \fn void QTest::keyRelease(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
 
-    Simulates releasing a \a key with an optional \a modifier on a \a widget. If \a delay is larger than 0, the test will wait for \a delay milliseconds.
+    Simulates releasing a \a key with an optional \a modifier on a \a widget.
+    If \a delay is larger than 0, the test will wait for \a delay milliseconds.
 
     \sa QTest::keyPress(), QTest::keyClick()
@@ -471 +511 @@
     \overload
 
-    Simulates releasing a \a key with an optional \a modifier on a \a widget. If \a delay is larger than 0, the test will wait for \a delay milliseconds.
+    Simulates releasing a \a key with an optional \a modifier on a \a widget.
+    If \a delay is larger than 0, the test will wait for \a delay milliseconds.
 
     \sa QTest::keyClick()
@@ -673 +714 @@
 */
 
+
+
+
+
+
+
+
 /*! \fn void QTest::qWait(int ms)
 
@@ -687 +735 @@
 */
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 namespace QTest
 {
     static QObject *currentTestObject = 0;
 
-    struct TestFunction {
+    struct TestFunction {
         TestFunction():function(0), data(0) {}
         ~TestFunction() { delete [] data; }
         int function;
         char *data;
-    } testFuncs[512];
+    } ;
 
     /**
@@ -711 +848 @@
     static int keyVerbose = -1;
 
-/*! \internal
- */
-int qt_snprintf(char *str, int size, const char *format, ...)
-{
-    va_list ap;
-    int res = 0;
-
-    va_start(ap, format);
-    qvsnprintf(str, size, format, ap);
-    va_end(ap);
-    str[size - 1] = '\0';
-
+void filter_unprintable(char *str)
+{
     char *idx = str;
     while (*idx) {
@@ -729 +856 @@
         ++idx;
     }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     return res;
 }
@@ -819 +962 @@
          " options:\n"
          " -functions : Returns a list of current testfunctions\n"
+
          " -xml       : Outputs results as XML document\n"
          " -lightxml  : Outputs results as stream of XML tags\n"
+
          " -o filename: Writes all output into a file\n"
          " -silent    : Only outputs warnings and failures\n"
@@ -845 +990 @@
         " -median  n      : Sets the number of median iterations.\n"
         " -vb             : Print out verbose benchmarking information.\n"
-#ifndef QT_NO_PROCESS
-// Will be enabled when tools are integrated.    
-//        " -chart          : Runs the chart generator after the test. No output is printed to the console\n"
+#if !defined(QT_NO_PROCESS) && !defined(QT_NO_SETTINGS)
+        " -chart          : Create chart based on the benchmark result.\n"
 #endif
          "\n"
@@ -862 +1006 @@
             qPrintTestSlots();
             exit(0);
+
+
         } else if (strcmp(argv[i], "-xml") == 0) {
             QTestLog::setLogMode(QTestLog::XML);
         } else if (strcmp(argv[i], "-lightxml") == 0) {
             QTestLog::setLogMode(QTestLog::LightXML);
+
+
         } else if (strcmp(argv[i], "-silent") == 0) {
             QTestLog::setVerboseLevel(-1);
@@ -958 +1106 @@
         } else if (strcmp(argv[i], "-vb") == 0) {
             QBenchmarkGlobalData::current->verboseOutput = true;
-#ifndef QT_NO_PROCESS
+#if
         } else if (strcmp(argv[i], "-chart") == 0) {
             QBenchmarkGlobalData::current->createChart = true;
@@ -992 +1140 @@
             }
             ++QTest::lastTestFuncIdx;
+
+
+
+
+
             QTest::testFuncs[QTest::lastTestFuncIdx].function = idx;
             QTest::testFuncs[QTest::lastTestFuncIdx].data = data;
@@ -1007 +1160 @@
     if (count == 1)
         return container.at(0);
-    
+
     QList<QBenchmarkResult> containerCopy = container;
     qSort(containerCopy);
@@ -1057 +1210 @@
                     ? QTestResult::currentDataTag() : "");
 
-            invokeOk = QMetaObject::invokeMethod(QTest::currentTestObject, slot, 
+            invokeOk = QMetaObject::invokeMethod(QTest::currentTestObject, slot,
                                                  Qt::DirectConnection);
             if (!invokeOk)
@@ -1078 +1231 @@
             results.append(QBenchmarkTestMethodData::current->result);
 
-        if (QBenchmarkTestMethodData::current->isBenchmark() && 
+        if (QBenchmarkTestMethodData::current->isBenchmark() &&
             QBenchmarkGlobalData::current->verboseOutput) {
                 if (i == -1) {
@@ -1209 +1362 @@
 /*!
   \fn char* QTest::toHexRepresentation(const char *ba, int length)
-  
+
   Returns a pointer to a string that is the string \a ba represented
   as a space-separated sequence of hex characters. If the input is
@@ -1215 +1368 @@
   the returned string as an ellipsis at the end.
 
-  \a length is the length of the string \a ba. 
+  \a length is the length of the string \a ba.
  */
 char *toHexRepresentation(const char *ba, int length)
@@ -1274 +1427 @@
 }
 
-static void qInvokeTestMethods(QObject *testObject) 
-{ 
-    const QMetaObject *metaObject = testObject->metaObject(); 
-    QTEST_ASSERT(metaObject); 
- 
-    QTestLog::startLogging(); 
- 
-    QTestResult::setCurrentTestFunction("initTestCase"); 
-    QTestResult::setCurrentTestLocation(QTestResult::DataFunc); 
-    QTestTable::globalTestTable(); 
-    QMetaObject::invokeMethod(testObject, "initTestCase_data", Qt::DirectConnection); 
- 
-    if (!QTestResult::skipCurrentTest() && !QTest::currentTestFailed()) { 
-        QTestResult::setCurrentTestLocation(QTestResult::InitFunc); 
-        QMetaObject::invokeMethod(testObject, "initTestCase"); 
- 
-        // finishedCurrentTestFunction() resets QTestResult::testFailed(), so use a local copy. 
-        const bool previousFailed = QTestResult::testFailed(); 
-        QTestResult::finishedCurrentTestFunction(); 
- 
-        if(!QTestResult::skipCurrentTest() && !previousFailed) { 
- 
-            if (lastTestFuncIdx >= 0) { 
-                for (int i = 0; i <= lastTestFuncIdx; ++i) { 
-                    if (!qInvokeTestMethod(metaObject->method(testFuncs[i].function).signature(), 
-                                           testFuncs[i].data)) 
-                        break; 
-                } 
-            } else { 
-                int methodCount = metaObject->methodCount(); 
-                for (int i = 0; i < methodCount; ++i) { 
-                    QMetaMethod slotMethod = metaObject->method(i); 
-                    if (!isValidSlot(slotMethod)) 
-                        continue; 
-                    if (!qInvokeTestMethod(slotMethod.signature())) 
-                        break; 
-                } 
-            } 
-        } 
- 
-        QTestResult::setSkipCurrentTest(false); 
-        QTestResult::setCurrentTestFunction("cleanupTestCase"); 
-        QMetaObject::invokeMethod(testObject, "cleanupTestCase"); 
-    } 
-    QTestResult::finishedCurrentTestFunction(); 
-    QTestResult::setCurrentTestFunction(0); 
-    QTestTable::clearGlobalTestTable(); 
- 
-    QTestLog::stopLogging(); 
-} 
+static void qInvokeTestMethods(QObject *testObject)
+{
+    const QMetaObject *metaObject = testObject->metaObject();
+    QTEST_ASSERT(metaObject);
+
+    QTestLog::startLogging();
+
+    QTestResult::setCurrentTestFunction("initTestCase");
+    QTestResult::setCurrentTestLocation(QTestResult::DataFunc);
+    QTestTable::globalTestTable();
+    QMetaObject::invokeMethod(testObject, "initTestCase_data", Qt::DirectConnection);
+
+    if (!QTestResult::skipCurrentTest() && !QTest::currentTestFailed()) {
+        QTestResult::setCurrentTestLocation(QTestResult::InitFunc);
+        QMetaObject::invokeMethod(testObject, "initTestCase");
+
+        // finishedCurrentTestFunction() resets QTestResult::testFailed(), so use a local copy.
+        const bool previousFailed = QTestResult::testFailed();
+        QTestResult::finishedCurrentTestFunction();
+
+        if(!QTestResult::skipCurrentTest() && !previousFailed) {
+
+            if (lastTestFuncIdx >= 0) {
+                for (int i = 0; i <= lastTestFuncIdx; ++i) {
+                    if (!qInvokeTestMethod(metaObject->method(testFuncs[i].function).signature(),
+                                           testFuncs[i].data))
+                        break;
+                }
+            } else {
+                int methodCount = metaObject->methodCount();
+                for (int i = 0; i < methodCount; ++i) {
+                    QMetaMethod slotMethod = metaObject->method(i);
+                    if (!isValidSlot(slotMethod))
+                        continue;
+                    if (!qInvokeTestMethod(slotMethod.signature()))
+                        break;
+                }
+            }
+        }
+
+        QTestResult::setSkipCurrentTest(false);
+        QTestResult::setCurrentTestFunction("cleanupTestCase");
+        QMetaObject::invokeMethod(testObject, "cleanupTestCase");
+    }
+    QTestResult::finishedCurrentTestFunction();
+    QTestResult::setCurrentTestFunction(0);
+    QTestTable::clearGlobalTestTable();
+
+    QTestLog::stopLogging();
+}
+
+#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
+class FatalSignalHandler
+{
+public:
+    FatalSignalHandler();
+    ~FatalSignalHandler();
+
+private:
+    static void signal(int);
+    sigset_t handledSignals;
+};
+
+void FatalSignalHandler::signal(int signum)
+{
+    qFatal("Received signal %d", signum);
+}
+
+FatalSignalHandler::FatalSignalHandler()
+{
+    sigemptyset(&handledSignals);
+
+    const int fatalSignals[] = {
+         SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGFPE, SIGSEGV, SIGPIPE, SIGTERM, 0 };
+
+    struct sigaction act;
+    memset(&act, 0, sizeof(act));
+    act.sa_handler = FatalSignalHandler::signal;
+
+    // Remove the handler after it is invoked.
+    act.sa_flags = SA_RESETHAND;
+
+    // Block all fatal signals in our signal handler so we don't try to close
+    // the testlog twice.
+    sigemptyset(&act.sa_mask);
+    for (int i = 0; fatalSignals[i]; ++i)
+        sigaddset(&act.sa_mask, fatalSignals[i]);
+
+    struct sigaction oldact;
+
+    for (int i = 0; fatalSignals[i]; ++i) {
+        sigaction(fatalSignals[i], &act, &oldact);
+#ifndef Q_WS_QWS
+        // Don't overwrite any non-default handlers
+        // however, we need to replace the default QWS handlers
+        if (oldact.sa_flags & SA_SIGINFO || oldact.sa_handler != SIG_DFL) {
+            sigaction(fatalSignals[i], &oldact, 0);
+        } else
+#endif
+        {
+            sigaddset(&handledSignals, fatalSignals[i]);
+        }
+    }
+}
+
+
+FatalSignalHandler::~FatalSignalHandler()
+{
+    // Unregister any of our remaining signal handlers
+    struct sigaction act;
+    memset(&act, 0, sizeof(act));
+    act.sa_handler = SIG_DFL;
+
+    struct sigaction oldact;
+
+    for (int i = 1; i < 32; ++i) {
+        if (!sigismember(&handledSignals, i))
+            continue;
+        sigaction(i, &act, &oldact);
+
+        // If someone overwrote it in the mean time, put it back
+        if (oldact.sa_handler != FatalSignalHandler::signal)
+            sigaction(i, &oldact, 0);
+    }
+}
+
+#endif
+
 
 } // namespace
@@ -1400 +1631 @@
 #endif
 
+
+
+
+
+
+
+
+
     QTestResult::reset();
 
@@ -1419 +1658 @@
         QBenchmarkValgrindUtils::cleanup();
 
-    } else {
-#endif
-
+    } else
+#endif
+    {
+#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
+        FatalSignalHandler handler;
+#endif
         qInvokeTestMethods(testObject);
-
-#ifdef QTESTLIB_USE_VALGRIND
     }
-#endif
-
- #ifndef QT_NO_EXCEPTIONS
+
+#ifndef QT_NO_EXCEPTIONS
      } catch (...) {
          QTestResult::addFailure("Caught unhandled exception", __FILE__, __LINE__);
@@ -1442 +1681 @@
          }
 #endif
- #ifdef Q_OS_WIN
-         // rethrow exception to make debugging easier
+         // Rethrow exception to make debugging easier.
          throw;
- #endif
-         return -1;
+         return 1;
      }
- #endif
+endif
 
     currentTestObject = 0;
@@ -1458 +1695 @@
 
 
-#ifndef QT_NO_PROCESS
+#if
     if (QBenchmarkGlobalData::current->createChart) {
-
-#define XSTR(s) STR(s)
-#define STR(s) #s
+        QString chartLocation = QLibraryInfo::location(QLibraryInfo::BinariesPath);
 #ifdef Q_OS_WIN
-    const char * path = XSTR(QBENCHLIB_BASE) "/tools/generatereport/generatereport.exe";
+    ;
 #else
-    const char * path = XSTR(QBENCHLIB_BASE) "/tools/generatereport/generatereport";
-#endif
-#undef XSTR
-#undef STR
-
-        if (QFile::exists(QLatin1String(path))) {
+        chartLocation += QLatin1String("/../tools/qtestlib/chart/chart");
+#endif
+        if (QFile::exists(chartLocation)) {
             QProcess p;
             p.setProcessChannelMode(QProcess::ForwardedChannels);
-            p.start(QLatin1String(path), QStringList() << QLatin1String("results.xml"));
+            p.start(, QStringList() << QLatin1String("results.xml"));
             p.waitForFinished(-1);
         } else {
-            qWarning("Could not find %s, please make sure it is compiled.", path);
+            q);
         }
     }
 #endif
 
-#if defined(QTEST_NOEXITCODE) || (defined(QT_BUILD_INTERNAL) && !defined(QTEST_FORCE_EXITCODE))
+#if defined(QTEST_NOEXITCODE)
     return 0;
 #else
@@ -1756 +1988 @@
  */
 template <>
-bool QTest::qCompare<float>(float const &t1, float const &t2, const char *actual, const char *expected,
+bool QTest::qCompare<float>(float const &t1, float const &t2, const char *actual, const char *expected,
                     const char *file, int line)
 {
@@ -1769 +2001 @@
  */
 template <>
-bool QTest::qCompare<double>(double const &t1, double const &t2, const char *actual, const char *expected,
+bool QTest::qCompare<double>(double const &t1, double const &t2, const char *actual, const char *expected,
                     const char *file, int line)
 {
@@ -1779 +2011 @@
 
 #define COMPARE_IMPL2(TYPE, FORMAT) \
-template <> char *QTest::toString<TYPE >(const TYPE &t) \
+template <> char *QTest::toString<TYPE >(const TYPE &t) \
 { \
     char *msg = new char[128]; \
@@ -1801 +2033 @@
 COMPARE_IMPL2(bool, %d)
 COMPARE_IMPL2(char, %c)
-COMPARE_IMPL2(float, %g);
-COMPARE_IMPL2(double, %lg);
+COMPARE_IMPL2(float, %g)
+COMPARE_IMPL2(double, %lg)
 
 /*! \internal
@@ -1911 +2143 @@
 */
 
+
+
+
+
 /*! \fn bool QTest::qTest(const T& actual, const char *elementName, const char *actualStr, const char *expected, const char *file, int line)
     \internal
@@ -1927 +2163 @@
 */
 
-/*! \fn int QTest::qt_snprintf(char *str, int size, const char *format, ...)
-    \internal
-*/
-
 QT_END_NAMESPACE