FCL/sf/mw/qt: comparison src/testlib/qtestcase.cpp

equal deleted inserted replaced

--1:000000000000
+:1918ee327afb
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtTest module 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 "QtTest/qtestcase.h"
+#include "QtTest/qtestassert.h"
+#include <QtCore/qbytearray.h>
+#include <QtCore/qmetaobject.h>
+#include <QtCore/qobject.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qvarlengtharray.h>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qfileinfo.h>
+#include <QtCore/qdir.h>
+#include <QtCore/qprocess.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qlibraryinfo.h>
+#include "QtTest/private/qtestlog_p.h"
+#include "QtTest/private/qtesttable_p.h"
+#include "QtTest/qtestdata.h"
+#include "QtTest/private/qtestresult_p.h"
+#include "QtTest/private/qsignaldumper_p.h"
+#include "QtTest/private/qbenchmark_p.h"
+#include "3rdparty/cycle_p.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef Q_OS_WIN
+#include <windows.h> // for Sleep
+#endif
+#ifdef Q_OS_UNIX
+#include <errno.h>
+#include <signal.h>
+#include <time.h>
+#endif
+#ifdef Q_WS_MAC
+#include <Carbon/Carbon.h> // for SetFrontProcess
+#ifdef QT_MAC_USE_COCOA
+#include <IOKit/pwr_mgt/IOPMLib.h>
+#else
+#include <Security/AuthSession.h>
+#endif
+#undef verify
+#endif
+QT_BEGIN_NAMESPACE
+/*!
+\namespace QTest
+\inmodule QtTest
+\brief The QTest namespace contains all the functions and
+declarations that are related to the QTestLib tool.
+Please refer to the \l{QTestLib Manual} documentation for information on
+how to write unit tests.
+*/
+/*! \macro QVERIFY(condition)
+\relates QTest
+The QVERIFY() macro checks whether the \a condition is true or not. If it is
+true, execution continues. If not, a failure is recorded in the test log
+and the test won't be executed further.
+\bold {Note:} This macro can only be used in a test function that is invoked
+by the test framework.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 0
+\sa QCOMPARE()
+*/
+/*! \macro QVERIFY2(condition, message)
+\relates QTest
+The QVERIFY2() macro behaves exactly like QVERIFY(), except that it outputs
+a verbose \a message when \a condition is false. The \a message is a plain
+C string.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 1
+\sa QVERIFY(), QCOMPARE()
+*/
+/*! \macro QCOMPARE(actual, expected)
+\relates QTest
+The QCOMPARE macro compares an \a actual value to an \a expected value using
+the equals operator. If \a actual and \a expected are identical, execution
+continues. If not, a failure is recorded in the test log and the test
+won't be executed further.
+In the case of comparing floats and doubles, qFuzzyCompare() is used for
+comparing. This means that comparing to 0 will likely fail. One solution
+to this is to compare to 1, and add 1 to the produced output.
+QCOMPARE tries to output the contents of the values if the comparison fails,
+so it is visible from the test log why the comparison failed.
+QCOMPARE is very strict on the data types. Both \a actual and \a expected
+have to be of the same type, otherwise the test won't compile. This prohibits
+unspecified behavior from being introduced; that is behavior that usually
+occurs when the compiler implicitly casts the argument.
+If you use QCOMPARE() to compare two QStringList objects, it will start
+comparing the objects from the end of the lists.
+For your own classes, you can use \l QTest::toString() to format values for
+outputting into the test log.
+\note This macro can only be used in a test function that is invoked
+by the test framework.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 2
+\sa QVERIFY(), QTest::toString()
+*/
+/*! \macro QFETCH(type, name)
+\relates QTest
+The fetch macro creates a local variable named \a name with the type \a type
+on the stack. \a name has to match the element name from the test's data.
+If no such element exists, the test will assert.
+Assuming a test has the following data:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 3
+The test data has two elements, a QString called \c aString and an integer
+called \c expected. To fetch these values in the actual test:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 4
+\c aString and \c expected are variables on the stack that are initialized with
+the current test data.
+\bold {Note:} This macro can only be used in a test function that is invoked
+by the test framework. The test function must have a _data function.
+*/
+/*! \macro QWARN(message)
+\relates QTest
+\threadsafe
+Appends \a message as a warning to the test log. This macro can be used anywhere
+in your tests.
+*/
+/*! \macro QFAIL(message)
+\relates QTest
+This macro can be used to force a test failure. The test stops
+executing and the failure \a message is appended to the test log.
+\bold {Note:} This macro can only be used in a test function that is invoked
+by the test framework.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 5
+*/
+/*! \macro QTEST(actual, testElement)
+\relates QTest
+QTEST() is a convenience macro for \l QCOMPARE() that compares
+the value \a actual with the element \a testElement from the test's data.
+If there is no such element, the test asserts.
+Apart from that, QTEST() behaves exactly as \l QCOMPARE().
+Instead of writing:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 6
+you can write:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 7
+\sa QCOMPARE()
+*/
+/*! \macro QSKIP(description, mode)
+\relates QTest
+The QSKIP() macro stops execution of the test without adding a failure to the
+test log. You can use it to skip tests that wouldn't make sense in the current
+configuration. The text \a description is appended to the test log and should
+contain an explanation why the test couldn't be executed. \a mode is a QTest::SkipMode
+and describes whether to proceed with the rest of the test data or not.
+\bold {Note:} This macro can only be used in a test function that is invoked
+by the test framework.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 8
+\sa QTest::SkipMode
+*/
+/*! \macro QEXPECT_FAIL(dataIndex, comment, mode)
+\relates QTest
+The QEXPECT_FAIL() macro marks the next \l QCOMPARE() or \l QVERIFY() as an
+expected failure. Instead of adding a failure to the test log, an expected
+failure will be reported.
+If a \l QVERIFY() or \l QCOMPARE() is marked as an expected failure,
+but passes instead, an unexpected pass (XPASS) is written to the test log.
+The parameter \a dataIndex describes for which entry in the test data the
+failure is expected. Pass an empty string (\c{""}) if the failure
+is expected for all entries or if no test data exists.
+\a comment will be appended to the test log for the expected failure.
+\a mode is a \l QTest::TestFailMode and sets whether the test should
+continue to execute or not.
+\bold {Note:} This macro can only be used in a test function that is invoked
+by the test framework.
+Example 1:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 9
+In the example above, an expected fail will be written into the test output
+if the variable \c i is not 42. If the variable \c i is 42, an unexpected pass
+is written instead. The QEXPECT_FAIL() has no influence on the second QCOMPARE()
+statement in the example.
+Example 2:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 10
+The above testfunction will not continue executing for the test data
+entry \c{data27}.
+\sa QTest::TestFailMode, QVERIFY(), QCOMPARE()
+*/
+/*! \macro QTEST_MAIN(TestClass)
+\relates QTest
+Implements a main() function that instantiates a QApplication object and
+the \a TestClass, and executes all tests in the order they were defined.
+Use this macro to build stand-alone executables.
+\bold {Note:} On platforms that have keypad navigation enabled by default (eg: Symbian),
+this macro will forcfully disable it to simplify the usage of key events when writing
+autotests. If you wish to write a test case that uses keypad navigation, you should
+enable it either in the \c {initTestCase()} or \c {init()} functions of your test case.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 11
+\sa QTEST_APPLESS_MAIN(), QTest::qExec(), QApplication::setNavigationMode()
+*/
+/*! \macro QTEST_APPLESS_MAIN(TestClass)
+\relates QTest
+Implements a main() function that executes all tests in \a TestClass.
+Behaves like \l QTEST_MAIN(), but doesn't instantiate a QApplication
+object. Use this macro for really simple stand-alone non-GUI tests.
+\sa QTEST_MAIN()
+*/
+/*! \macro QTEST_NOOP_MAIN()
+\relates QTest
+Implements a main() function with a test class that does absolutely nothing.
+Use this macro to create a test that produces valid test output but just
+doesn't execute any test, for example in conditional compilations:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 12
+\sa QTEST_MAIN()
+*/
+/*!
+\macro QBENCHMARK
+\relates QTest
+This macro is used to measure the performance of code within a test.
+The code to be benchmarked is contained within a code block following
+this macro.
+For example:
+\snippet examples/qtestlib/tutorial5/benchmarking.cpp 0
+\sa {QTestLib Manual#Creating a Benchmark}{Creating a Benchmark},
+{Chapter 5: Writing a Benchmark}{Writing a Benchmark}
+*/
+/*!
+\macro QBENCHMARK_ONCE
+\since 4.6
+\relates QTest
+\brief The QBENCHMARK_ONCE macro is for measuring performance of a
+code block by running it once.
+This macro is used to measure the performance of code within a test.
+The code to be benchmarked is contained within a code block following
+this macro.
+Unlike QBENCHMARK, the contents of the contained code block is only run
+once. The elapsed time will be reported as "0" if it's to short to
+be measured by the selected backend. (Use)
+\sa {QTestLib Manual#Creating a Benchmark}{Creating a Benchmark},
+{Chapter 5: Writing a Benchmark}{Writing a Benchmark}
+*/
+/*! \enum QTest::SkipMode
+This enum describes the modes for skipping tests during execution
+of the test data.
+\value SkipSingle Skips the current entry in the test table; continues
+execution of all the other entries in the table.
+\value SkipAll Skips all the entries in the test table; the test won't
+be executed further.
+\sa QSKIP()
+*/
+/*! \enum QTest::TestFailMode
+This enum describes the modes for handling an expected failure of the
+\l QVERIFY() or \l QCOMPARE() macros.
+\value Abort Aborts the execution of the test. Use this mode when it
+doesn't make sense to execute the test any further after the
+expected failure.
+\value Continue Continues execution of the test after the expected failure.
+\sa QEXPECT_FAIL()
+*/
+/*! \enum QTest::KeyAction
+This enum describes possible actions for key handling.
+\value Press    The key is pressed.
+\value Release  The key is released.
+\value Click    The key is clicked (pressed and released).
+*/
+/*! \enum QTest::MouseAction
+This enum describes possible actions for mouse handling.
+\value MousePress    A mouse button is pressed.
+\value MouseRelease  A mouse button is released.
+\value MouseClick    A mouse button is clicked (pressed and released).
+\value MouseDClick   A mouse button is double clicked (pressed and released twice).
+\value MouseMove     The mouse pointer has moved.
+*/
+/*! \fn void QTest::keyClick(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
+\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.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 13
+The example above simulates clicking \c a on \c myWidget without
+any keyboard modifiers and without delay of the test.
+\sa QTest::keyClicks()
+*/
+/*! \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.
+Examples:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 14
+The first example above simulates clicking the \c escape key on \c
+myWidget without any keyboard modifiers and without delay. The
+second example simulates clicking \c shift-escape on \c myWidget
+with a following 200 ms delay of the test.
+\sa QTest::keyClicks()
+*/
+/*! \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.
+*/
+/*! \fn void QTest::keyEvent(KeyAction action, QWidget *widget, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
+\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.
+*/
+/*! \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.
+\bold {Note:} At some point you should release the key using \l keyRelease().
+\sa QTest::keyRelease(), QTest::keyClick()
+*/
+/*! \fn void QTest::keyPress(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
+\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.
+\bold {Note:} At some point you should release the key using \l keyRelease().
+\sa QTest::keyRelease(), QTest::keyClick()
+*/
+/*! \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.
+\sa QTest::keyPress(), QTest::keyClick()
+*/
+/*! \fn void QTest::keyRelease(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
+\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.
+\sa QTest::keyClick()
+*/
+/*! \fn void QTest::keyClicks(QWidget *widget, const QString &sequence, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay=-1)
+Simulates clicking a \a sequence of keys on a \a
+widget. Optionally, a keyboard \a modifier can be specified as
+well as a \a delay (in milliseconds) of the test before each key
+click.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 15
+The example above simulates clicking the sequence of keys
+representing "hello world" on \c myWidget without any keyboard
+modifiers and without delay of the test.
+\sa QTest::keyClick()
+*/
+/*! \fn void QTest::mousePress(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint(), int delay=-1)
+Simulates pressing a mouse \a button with an optional \a modifier
+on a \a widget.  The position is defined by \a pos; the default
+position is the center of the widget. If \a delay is specified,
+the test will wait for the specified amount of milliseconds before
+the press.
+\sa QTest::mouseRelease(), QTest::mouseClick()
+*/
+/*! \fn void QTest::mouseRelease(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint(), int delay=-1)
+Simulates releasing a mouse \a button with an optional \a modifier
+on a \a widget.  The position of the release is defined by \a pos;
+the default position is the center of the widget. If \a delay is
+specified, the test will wait for the specified amount of
+milliseconds before releasing the button.
+\sa QTest::mousePress(), QTest::mouseClick()
+*/
+/*! \fn void QTest::mouseClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint(), int delay=-1)
+Simulates clicking a mouse \a button with an optional \a modifier
+on a \a widget.  The position of the click is defined by \a pos;
+the default position is the center of the widget. If \a delay is
+specified, the test will wait for the specified amount of
+milliseconds before pressing and before releasing the button.
+\sa QTest::mousePress(), QTest::mouseRelease()
+*/
+/*! \fn void QTest::mouseDClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint(), int delay=-1)
+Simulates double clicking a mouse \a button with an optional \a
+modifier on a \a widget.  The position of the click is defined by
+\a pos; the default position is the center of the widget. If \a
+delay is specified, the test will wait for the specified amount of
+milliseconds before each press and release.
+\sa QTest::mouseClick()
+*/
+/*! \fn void QTest::mouseMove(QWidget *widget, QPoint pos = QPoint(), int delay=-1)
+Moves the mouse pointer to a \a widget. If \a pos is not
+specified, the mouse pointer moves to the center of the widget. If
+a \a delay (in milliseconds) is given, the test will wait before
+moving the mouse pointer.
+*/
+/*!
+\fn char *QTest::toString(const T &value)
+Returns a textual representation of \a value. This function is used by
+\l QCOMPARE() to output verbose information in case of a test failure.
+You can add specializations of this function to your test to enable
+verbose output.
+\bold {Note:} The caller of toString() must delete the returned data
+using \c{delete[]}.  Your implementation should return a string
+created with \c{new[]} or qstrdup().
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 16
+The example above defines a toString() specialization for a class
+called \c MyPoint. Whenever a comparison of two instances of \c
+MyPoint fails, \l QCOMPARE() will call this function to output the
+contents of \c MyPoint to the test log.
+\sa QCOMPARE()
+*/
+/*!
+\fn char *QTest::toString(const QLatin1String &string)
+\overload
+Returns a textual representation of the given \a string.
+*/
+/*!
+\fn char *QTest::toString(const QString &string)
+\overload
+Returns a textual representation of the given \a string.
+*/
+/*!
+\fn char *QTest::toString(const QByteArray &ba)
+\overload
+Returns a textual representation of the byte array \a ba.
+\sa QTest::toHexRepresentation()
+*/
+/*!
+\fn char *QTest::toString(const QTime &time)
+\overload
+Returns a textual representation of the given \a time.
+*/
+/*!
+\fn char *QTest::toString(const QDate &date)
+\overload
+Returns a textual representation of the given \a date.
+*/
+/*!
+\fn char *QTest::toString(const QDateTime &dateTime)
+\overload
+Returns a textual representation of the date and time specified by
+\a dateTime.
+*/
+/*!
+\fn char *QTest::toString(const QChar &character)
+\overload
+Returns a textual representation of the given \a character.
+*/
+/*!
+\fn char *QTest::toString(const QPoint &point)
+\overload
+Returns a textual representation of the given \a point.
+*/
+/*!
+\fn char *QTest::toString(const QSize &size)
+\overload
+Returns a textual representation of the given \a size.
+*/
+/*!
+\fn char *QTest::toString(const QRect &rectangle)
+\overload
+Returns a textual representation of the given \a rectangle.
+*/
+/*!
+\fn char *QTest::toString(const QUrl &url)
+\since 4.4
+\overload
+Returns a textual representation of the given \a url.
+*/
+/*!
+\fn char *QTest::toString(const QPointF &point)
+\overload
+Returns a textual representation of the given \a point.
+*/
+/*!
+\fn char *QTest::toString(const QSizeF &size)
+\overload
+Returns a textual representation of the given \a size.
+*/
+/*!
+\fn char *QTest::toString(const QRectF &rectangle)
+\overload
+Returns a textual representation of the given \a rectangle.
+*/
+/*!
+\fn char *QTest::toString(const QVariant &variant)
+\overload
+Returns a textual representation of the given \a variant.
+*/
+/*! \fn void QTest::qWait(int ms)
+Waits for \a ms milliseconds. While waiting, events will be processed and
+your test will stay responsive to user interface events or network communication.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 17
+The code above will wait until the network server is responding for a
+maximum of about 12.5 seconds.
+\sa QTest::qSleep()
+*/
+/*! \fn bool QTest::qWaitForWindowShown(QWidget *window)
+\since 4.6
+Waits until the \a window is shown in the screen. This is mainly useful for
+asynchronous systems like X11, where a window will be mapped to screen some
+time after being asked to show itself on the screen. Returns true.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 24
+*/
+/*!
+\class QTest::QTouchEventSequence
+\inmodule QtTest
+\since 4.6
+\brief The QTouchEventSequence class is used to simulate a sequence of touch events.
+To simulate a sequence of touch events on a specific device for a widget, call
+QTest::touchEvent to create a QTouchEventSequence instance. Add touch events to
+the sequence by calling press(), move(), release() and stationary(), and let the
+instance run out of scope to commit the sequence to the event system.
+*/
+/*!
+\fn QTest::QTouchEventSequence::~QTouchEventSequence()
+Commits this sequence of touch events and frees allocated resources.
+*/
+/*!
+\fn QTouchEventSequence &QTest::QTouchEventSequence::press(int touchId, const QPoint &pt, QWidget *widget)
+Adds a press event for touchpoint \a touchId at position \a pt to this sequence and returns
+a reference to this QTouchEventSequence.
+The position \a pt is interpreted as relative to \a widget. If \a widget is the null pointer, then
+\a pt is interpreted as relative to the widget provided when instantiating this QTouchEventSequence.
+Simulates that the user pressed the touch screen or pad with the finger identified by \a touchId.
+*/
+/*!
+\fn QTouchEventSequence &QTest::QTouchEventSequence::move(int touchId, const QPoint &pt, QWidget *widget)
+Adds a move event for touchpoint \a touchId at position \a pt to this sequence and returns
+a reference to this QTouchEventSequence.
+The position \a pt is interpreted as relative to \a widget. If \a widget is the null pointer, then
+\a pt is interpreted as relative to the widget provided when instantiating this QTouchEventSequence.
+Simulates that the user moved the finger identified by \a touchId.
+*/
+/*!
+\fn QTouchEventSequence &QTest::QTouchEventSequence::release(int touchId, const QPoint &pt, QWidget *widget)
+Adds a release event for touchpoint \a touchId at position \a pt to this sequence and returns
+a reference to this QTouchEventSequence.
+The position \a pt is interpreted as relative to \a widget. If \a widget is the null pointer, then
+\a pt is interpreted as relative to the widget provided when instantiating this QTouchEventSequence.
+Simulates that the user lifted the finger identified by \a touchId.
+*/
+/*!
+\fn QTouchEventSequence &QTest::QTouchEventSequence::stationary(int touchId)
+Adds a stationary event for touchpoint \a touchId to this sequence and returns
+a reference to this QTouchEventSequence.
+Simulates that the user did not move the finger identified by \a touchId.
+*/
+/*!
+\fn QTouchEventSequence QTest::touchEvent(QWidget *widget, QTouchEvent::DeviceType deviceType)
+Creates and returns a QTouchEventSequence for the device \a deviceType to
+simulate events for \a widget.
+When adding touch events to the sequence, \a widget will also be used to translate
+the position provided to screen coordinates, unless another widget is provided in the
+respective calls to press(), move() etc.
+The touch events are committed to the event system when the destructor of the
+QTouchEventSequence is called (ie when the object returned runs out of scope).
+*/
+namespace QTest
+{
+static QObject *currentTestObject = 0;
+static struct TestFunction {
+TestFunction():function(0), data(0) {}
+~TestFunction() { delete [] data; }
+int function;
+char *data;
+} *testFuncs;
+/**
+* Contains the count of test functions that was supplied
+* on the command line, if any. Hence, if lastTestFuncIdx is
+* more than zero, those functions should be run instead of
+* all appearing in the test case.
+*/
+static int lastTestFuncIdx = -1;
+static int keyDelay = -1;
+static int mouseDelay = -1;
+static int eventDelay = -1;
+static int keyVerbose = -1;
+void filter_unprintable(char *str)
+{
+char *idx = str;
+while (*idx) {
+if (((*idx < 0x20 && *idx != '\n' && *idx != '\t') || *idx > 0x7e))
+*idx = '?';
+++idx;
+}
+}
+/*! \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';
+filter_unprintable(str);
+return res;
+}
+bool Q_TESTLIB_EXPORT defaultKeyVerbose()
+{
+if (keyVerbose == -1) {
+keyVerbose = qgetenv("QTEST_KEYEVENT_VERBOSE").constData() ? 1 : 0;
+}
+return keyVerbose == 1;
+}
+int defaultEventDelay()
+{
+if (eventDelay == -1) {
+if (qgetenv("QTEST_EVENT_DELAY").constData())
+eventDelay = atoi(qgetenv("QTEST_EVENT_DELAY"));
+else
+eventDelay = 0;
+}
+return eventDelay;
+}
+int Q_TESTLIB_EXPORT defaultMouseDelay()
+{
+if (mouseDelay == -1) {
+if (qgetenv("QTEST_MOUSEEVENT_DELAY").constData())
+mouseDelay = atoi((qgetenv("QTEST_MOUSEEVENT_DELAY")));
+else
+mouseDelay = defaultEventDelay();
+}
+return mouseDelay;
+}
+int Q_TESTLIB_EXPORT defaultKeyDelay()
+{
+if (keyDelay == -1) {
+if (qgetenv("QTEST_KEYEVENT_DELAY").constData())
+keyDelay = atoi(qgetenv("QTEST_KEYEVENT_DELAY").constData());
+else
+keyDelay = defaultEventDelay();
+}
+return keyDelay;
+}
+static bool isValidSlot(const QMetaMethod &sl)
+{
+if (sl.access() != QMetaMethod::Private || !sl.parameterTypes().isEmpty()
+|| qstrlen(sl.typeName()) || sl.methodType() != QMetaMethod::Slot)
+return false;
+const char *sig = sl.signature();
+int len = qstrlen(sig);
+if (len < 2)
+return false;
+if (sig[len - 2] != '(' || sig[len - 1] != ')')
+return false;
+if (len > 7 && strcmp(sig + (len - 7), "_data()") == 0)
+return false;
+if (strcmp(sig, "initTestCase()") == 0 || strcmp(sig, "cleanupTestCase()") == 0
+|| strcmp(sig, "cleanup()") == 0 || strcmp(sig, "init()") == 0)
+return false;
+return true;
+}
+static void qPrintTestSlots()
+{
+for (int i = 0; i < QTest::currentTestObject->metaObject()->methodCount(); ++i) {
+QMetaMethod sl = QTest::currentTestObject->metaObject()->method(i);
+if (isValidSlot(sl))
+printf("%s\n", sl.signature());
+}
+}
+static int qToInt(char *str)
+{
+char *pEnd;
+int l = (int)strtol(str, &pEnd, 10);
+if (*pEnd != 0) {
+printf("Invalid numeric parameter: '%s'\n", str);
+exit(1);
+}
+return l;
+}
+static void qParseArgs(int argc, char *argv[])
+{
+lastTestFuncIdx = -1;
+const char *testOptions =
+" options:\n"
+" -functions : Returns a list of current testfunctions\n"
+" -xunitxml  : Outputs results as XML XUnit document\n"
+" -xml       : Outputs results as XML document\n"
+" -lightxml  : Outputs results as stream of XML tags\n"
+" -flush     : Flushes the resutls\n"
+" -o filename: Writes all output into a file\n"
+" -silent    : Only outputs warnings and failures\n"
+" -v1        : Print enter messages for each testfunction\n"
+" -v2        : Also print out each QVERIFY/QCOMPARE/QTEST\n"
+" -vs        : Print every signal emitted\n"
+" -eventdelay ms    : Set default delay for mouse and keyboard simulation to ms milliseconds\n"
+" -keydelay ms      : Set default delay for keyboard simulation to ms milliseconds\n"
+" -mousedelay ms    : Set default delay for mouse simulation to ms milliseconds\n"
+" -keyevent-verbose : Turn on verbose messages for keyboard simulation\n"
+" -maxwarnings n    : Sets the maximum amount of messages to output.\n"
+"                     0 means unlimited, default: 2000\n"
+"\n"
+" Benchmark related options:\n"
+#ifdef QTESTLIB_USE_VALGRIND
+" -callgrind      : Use callgrind to time benchmarks\n"
+#endif
+#ifdef HAVE_TICK_COUNTER
+" -tickcounter    : Use CPU tick counters to time benchmarks\n"
+#endif
+" -eventcounter   : Counts events received during benchmarks\n"
+" -minimumvalue n : Sets the minimum acceptable measurement value\n"
+" -iterations  n  : Sets the number of accumulation iterations.\n"
+" -median  n      : Sets the number of median iterations.\n"
+" -vb             : Print out verbose benchmarking information.\n"
+#if !defined(QT_NO_PROCESS) && !defined(QT_NO_SETTINGS)
+" -chart          : Create chart based on the benchmark result.\n"
+#endif
+"\n"
+" -help      : This help\n";
+for (int i = 1; i < argc; ++i) {
+if (strcmp(argv[i], "-help") == 0 || strcmp(argv[i], "--help") == 0
+|| strcmp(argv[i], "/?") == 0) {
+printf(" Usage: %s [options] [testfunction[:testdata]]...\n"
+"    By default, all testfunctions will be run.\n\n"
+"%s", argv[0], testOptions);
+exit(0);
+} else if (strcmp(argv[i], "-functions") == 0) {
+qPrintTestSlots();
+exit(0);
+} else if(strcmp(argv[i], "-xunitxml") == 0){
+QTestLog::setLogMode(QTestLog::XunitXML);
+} 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], "-flush") == 0){
+QTestLog::setFlushMode(QTestLog::FLushOn);
+} else if (strcmp(argv[i], "-silent") == 0) {
+QTestLog::setVerboseLevel(-1);
+} else if (strcmp(argv[i], "-v1") == 0) {
+QTestLog::setVerboseLevel(1);
+} else if (strcmp(argv[i], "-v2") == 0) {
+QTestLog::setVerboseLevel(2);
+} else if (strcmp(argv[i], "-vs") == 0) {
+QSignalDumper::startDump();
+} else if (strcmp(argv[i], "-o") == 0) {
+if (i + 1 >= argc) {
+printf("-o needs an extra parameter specifying the filename\n");
+exit(1);
+} else {
+QTestLog::redirectOutput(argv[++i]);
+}
+} else if (strcmp(argv[i], "-eventdelay") == 0) {
+if (i + 1 >= argc) {
+printf("-eventdelay needs an extra parameter to indicate the delay(ms)\n");
+exit(1);
+} else {
+QTest::eventDelay = qToInt(argv[++i]);
+}
+} else if (strcmp(argv[i], "-keydelay") == 0) {
+if (i + 1 >= argc) {
+printf("-keydelay needs an extra parameter to indicate the delay(ms)\n");
+exit(1);
+} else {
+QTest::keyDelay = qToInt(argv[++i]);
+}
+} else if (strcmp(argv[i], "-mousedelay") == 0) {
+if (i + 1 >= argc) {
+printf("-mousedelay needs an extra parameter to indicate the delay(ms)\n");
+exit(1);
+} else {
+QTest::mouseDelay = qToInt(argv[++i]);
+}
+} else if (strcmp(argv[i], "-maxwarnings") == 0) {
+if (i + 1 >= argc) {
+printf("-maxwarnings needs an extra parameter with the amount of warnings\n");
+exit(1);
+} else {
+QTestLog::setMaxWarnings(qToInt(argv[++i]));
+}
+} else if (strcmp(argv[i], "-keyevent-verbose") == 0) {
+QTest::keyVerbose = 1;
+#ifdef QTESTLIB_USE_VALGRIND
+} else if (strcmp(argv[i], "-callgrind") == 0) {
+if (QBenchmarkValgrindUtils::haveValgrind())
+if (QFileInfo(QDir::currentPath()).isWritable()) {
+QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::CallgrindParentProcess);
+} else {
+printf("WARNING: Current directory not writable. Using the walltime measurer.\n");
+}
+else {
+printf("WARNING: Valgrind not found or too old. Make sure it is installed and in your path. "
+"Using the walltime measurer.\n");
+}
+} else if (strcmp(argv[i], "-callgrindchild") == 0) { // "private" option
+QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::CallgrindChildProcess);
+QBenchmarkGlobalData::current->callgrindOutFileBase =
+QBenchmarkValgrindUtils::outFileBase();
+#endif
+#ifdef HAVE_TICK_COUNTER
+} else if (strcmp(argv[i], "-tickcounter") == 0) {
+QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::TickCounter);
+#endif
+} else if (strcmp(argv[i], "-eventcounter") == 0) {
+QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::EventCounter);
+} else if (strcmp(argv[i], "-minimumvalue") == 0) {
+if (i + 1 >= argc) {
+printf("-minimumvalue needs an extra parameter to indicate the minimum time(ms)\n");
+exit(1);
+} else {
+QBenchmarkGlobalData::current->walltimeMinimum = qToInt(argv[++i]);
+}
+} else if (strcmp(argv[i], "-iterations") == 0) {
+if (i + 1 >= argc) {
+printf("-iterations needs an extra parameter to indicate the number of iterations\n");
+exit(1);
+} else {
+QBenchmarkGlobalData::current->iterationCount = qToInt(argv[++i]);
+}
+} else if (strcmp(argv[i], "-median") == 0) {
+if (i + 1 >= argc) {
+printf("-median needs an extra parameter to indicate the number of median iterations\n");
+exit(1);
+} else {
+QBenchmarkGlobalData::current->medianIterationCount = qToInt(argv[++i]);
+}
+} else if (strcmp(argv[i], "-vb") == 0) {
+QBenchmarkGlobalData::current->verboseOutput = true;
+#if !defined(QT_NO_PROCESS) && !defined(QT_NO_SETTINGS)
+} else if (strcmp(argv[i], "-chart") == 0) {
+QBenchmarkGlobalData::current->createChart = true;
+QTestLog::setLogMode(QTestLog::XML);
+QTestLog::redirectOutput("results.xml");
+#endif
+} else if (strcmp(argv[i], "-qws") == 0) {
+// do nothing
+} else if (argv[i][0] == '-') {
+printf("Unknown option: '%s'\n\n%s", argv[i], testOptions);
+exit(1);
+} else {
+int colon = -1;
+char buf[512], *data=0;
+int off;
+for(off = 0; *(argv[i]+off); ++off) {
+if (*(argv[i]+off) == ':') {
+colon = off;
+break;
+}
+}
+if(colon != -1) {
+data = qstrdup(argv[i]+colon+1);
+}
+QTest::qt_snprintf(buf, qMin(512, off + 1), "%s", argv[i]); // copy text before the ':' into buf
+QTest::qt_snprintf(buf + off, qMin(512 - off, 3), "()");    // append "()"
+int idx = QTest::currentTestObject->metaObject()->indexOfMethod(buf);
+if (idx < 0 || !isValidSlot(QTest::currentTestObject->metaObject()->method(idx))) {
+printf("Unknown testfunction: '%s'\n", buf);
+printf("Available testfunctions:\n");
+qPrintTestSlots();
+exit(1);
+}
+++QTest::lastTestFuncIdx;
+if (!QTest::testFuncs) {
+struct Cleanup { ~Cleanup() { delete[] QTest::testFuncs; } };
+static Cleanup cleanup;
+QTest::testFuncs = new TestFunction[512];
+}
+QTest::testFuncs[QTest::lastTestFuncIdx].function = idx;
+QTest::testFuncs[QTest::lastTestFuncIdx].data = data;
+QTEST_ASSERT(QTest::lastTestFuncIdx < 512);
+}
+}
+}
+QBenchmarkResult qMedian(const QList<QBenchmarkResult> &container)
+{
+const int count = container.count();
+if (count == 0)
+return QBenchmarkResult();
+if (count == 1)
+return container.at(0);
+QList<QBenchmarkResult> containerCopy = container;
+qSort(containerCopy);
+const int middle = count / 2;
+// ### handle even-sized containers here by doing an aritmetic mean of the two middle items.
+return containerCopy.at(middle);
+}
+struct QTestDataSetter
+{
+QTestDataSetter(QTestData *data)
+{
+QTestResult::setCurrentTestData(data);
+}
+~QTestDataSetter()
+{
+QTestResult::setCurrentTestData(0);
+}
+};
+static void qInvokeTestMethodDataEntry(char *slot)
+{
+/* Benchmarking: for each median iteration*/
+int i = (QBenchmarkGlobalData::current->measurer->needsWarmupIteration()) ? -1 : 0;
+QList<QBenchmarkResult> results;
+do {
+QBenchmarkTestMethodData::current->beginDataRun();
+/* Benchmarking: for each accumulation iteration*/
+bool invokeOk;
+do {
+QTestResult::setCurrentTestLocation(QTestResult::InitFunc);
+QMetaObject::invokeMethod(QTest::currentTestObject, "init");
+if (QTestResult::skipCurrentTest())
+break;
+QTestResult::setCurrentTestLocation(QTestResult::Func);
+QBenchmarkTestMethodData::current->result = QBenchmarkResult();
+QBenchmarkTestMethodData::current->resultAccepted = false;
+QBenchmarkGlobalData::current->context.tag =
+QLatin1String(
+QTestResult::currentDataTag()
+? QTestResult::currentDataTag() : "");
+invokeOk = QMetaObject::invokeMethod(QTest::currentTestObject, slot,
+Qt::DirectConnection);
+if (!invokeOk)
+QTestResult::addFailure("Unable to execute slot", __FILE__, __LINE__);
+QTestResult::setCurrentTestLocation(QTestResult::CleanupFunc);
+QMetaObject::invokeMethod(QTest::currentTestObject, "cleanup");
+QTestResult::setCurrentTestLocation(QTestResult::NoWhere);
+// If this test method has a benchmark, repeat until all measurements are
+// acceptable.
+// The QBENCHMARK macro increases the number of iterations for each run until
+// this happens.
+} while (invokeOk
+&& QBenchmarkTestMethodData::current->isBenchmark()
+&& QBenchmarkTestMethodData::current->resultsAccepted() == false);
+QBenchmarkTestMethodData::current->endDataRun();
+if (i > -1)  // iteration -1 is the warmup iteration.
+results.append(QBenchmarkTestMethodData::current->result);
+if (QBenchmarkTestMethodData::current->isBenchmark() &&
+QBenchmarkGlobalData::current->verboseOutput) {
+if (i == -1) {
+qDebug() << "warmup stage result      :" << QBenchmarkTestMethodData::current->result.value;
+} else {
+qDebug() << "accumulation stage result:" << QBenchmarkTestMethodData::current->result.value;
+}
+}
+} while (QBenchmarkTestMethodData::current->isBenchmark()
+&& (++i < QBenchmarkGlobalData::current->adjustMedianIterationCount()));
+if (QBenchmarkTestMethodData::current->isBenchmark()
+&& QBenchmarkTestMethodData::current->resultsAccepted())
+QTestLog::addBenchmarkResult(qMedian(results));
+}
+/*!
+\internal
+Call init(), slot_data(), slot(), slot(), slot()..., cleanup()
+If data is set then it is the only test that is performed
+If the function was successfully called, true is returned, otherwise
+false.
+*/
+static bool qInvokeTestMethod(const char *slotName, const char *data=0)
+{
+QTEST_ASSERT(slotName);
+QBenchmarkTestMethodData benchmarkData;
+QBenchmarkTestMethodData::current = &benchmarkData;
+QBenchmarkGlobalData::current->context.slotName = QLatin1String(slotName);
+char member[512];
+QTestTable table;
+char *slot = qstrdup(slotName);
+slot[strlen(slot) - 2] = '\0';
+QTestResult::setCurrentTestFunction(slot);
+const QTestTable *gTable = QTestTable::globalTestTable();
+const int globalDataCount = gTable->dataCount();
+int curGlobalDataIndex = 0;
+/* For each test function that has a *_data() table/function, do: */
+do {
+if (!gTable->isEmpty())
+QTestResult::setCurrentGlobalTestData(gTable->testData(curGlobalDataIndex));
+if (curGlobalDataIndex == 0) {
+QTestResult::setCurrentTestLocation(QTestResult::DataFunc);
+QTest::qt_snprintf(member, 512, "%s_data", slot);
+QMetaObject::invokeMethod(QTest::currentTestObject, member, Qt::DirectConnection);
+// if we encounter a SkipAll in the _data slot, we skip the whole
+// testfunction, no matter how much global data exists
+if (QTestResult::skipCurrentTest()) {
+QTestResult::setCurrentGlobalTestData(0);
+break;
+}
+}
+bool foundFunction = false;
+if (!QTestResult::skipCurrentTest()) {
+int curDataIndex = 0;
+const int dataCount = table.dataCount();
+QTestResult::setSkipCurrentTest(false);
+/* For each entry in the data table, do: */
+do {
+if (!data || !qstrcmp(data, table.testData(curDataIndex)->dataTag())) {
+foundFunction = true;
+QTestDataSetter s(table.isEmpty() ? static_cast<QTestData *>(0)
+: table.testData(curDataIndex));
+qInvokeTestMethodDataEntry(slot);
+if (QTestResult::skipCurrentTest())
+// check whether SkipAll was requested
+break;
+if (data)
+break;
+}
+++curDataIndex;
+} while (curDataIndex < dataCount);
+}
+if (data && !foundFunction) {
+printf("Unknown testdata for function %s: '%s'\n", slotName, data);
+printf("Available testdata:\n");
+for(int i = 0; i < table.dataCount(); ++i)
+printf("%s\n", table.testData(i)->dataTag());
+return false;
+}
+QTestResult::setCurrentGlobalTestData(0);
+++curGlobalDataIndex;
+} while (curGlobalDataIndex < globalDataCount);
+QTestResult::finishedCurrentTestFunction();
+QTestResult::setSkipCurrentTest(false);
+QTestResult::setCurrentTestData(0);
+delete[] slot;
+return true;
+}
+void *fetchData(QTestData *data, const char *tagName, int typeId)
+{
+QTEST_ASSERT(typeId);
+QTEST_ASSERT_X(data, "QTest::fetchData()", "Test data requested, but no testdata available.");
+QTEST_ASSERT(data->parent());
+int idx = data->parent()->indexOf(tagName);
+if (idx == -1 || idx >= data->dataCount()) {
+qFatal("QFETCH: Requested testdata '%s' not available, check your _data function.",
+tagName);
+}
+if (typeId != data->parent()->elementTypeId(idx)) {
+qFatal("Requested type '%s' does not match available type '%s'.",
+QMetaType::typeName(typeId),
+QMetaType::typeName(data->parent()->elementTypeId(idx)));
+}
+return data->data(idx);
+}
+/*!
+\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
+considered too long, it is truncated. A trucation is indicated in
+the returned string as an ellipsis at the end.
+\a length is the length of the string \a ba.
+*/
+char *toHexRepresentation(const char *ba, int length)
+{
+if(length == 0)
+return qstrdup("");
+/* We output at maximum about maxLen characters in order to avoid
+* running out of memory and flooding things when the byte array
+* is large.
+*
+* maxLen can't be for example 200 because QTestLib is sprinkled with fixed
+* size char arrays.
+* */
+const int maxLen = 50;
+const int len = qMin(maxLen, length);
+char *result = 0;
+if(length > maxLen) {
+const int size = len * 3 + 4;
+result = new char[size];
+char *const forElipsis = result + size - 5;
+forElipsis[0] = ' ';
+forElipsis[1] = '.';
+forElipsis[2] = '.';
+forElipsis[3] = '.';
+result[size - 1] = '\0';
+}
+else {
+const int size = len * 3;
+result = new char[size];
+result[size - 1] = '\0';
+}
+const char toHex[] = "0123456789ABCDEF";
+int i = 0;
+int o = 0;
+while(true) {
+const char at = ba[i];
+result[o] = toHex[(at >> 4) & 0x0F];
+++o;
+result[o] = toHex[at & 0x0F];
+++i;
+++o;
+if(i == len)
+break;
+else {
+result[o] = ' ';
+++o;
+}
+}
+return result;
+}
+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
+/*!
+Executes tests declared in \a testObject. In addition, the private slots
+\c{initTestCase()}, \c{cleanupTestCase()}, \c{init()} and \c{cleanup()}
+are executed if they exist. See \l{Creating a Test} for more details.
+Optionally, the command line arguments \a argc and \a argv can be provided.
+For a list of recognized arguments, read \l {QTestLib Command Line Arguments}.
+For stand-alone tests, the convenience macro \l QTEST_MAIN() can
+be used to declare a main method that parses the command line arguments
+and executes the tests.
+Returns 0 if all tests passed. Returns a value other than 0 if tests failed
+or in case of unhandled exceptions. The return value from this function is
+also the exit code of the test application when the \l QTEST_MAIN() macro
+is used.
+The following example will run all tests in \c MyFirstTestObject and
+\c{MySecondTestObject}:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 18
+Note: This function is not reentrant, only one test can run at a time. A
+test that was executed with qExec() can't run another test via qExec() and
+threads are not allowed to call qExec() simultaneously.
+If you have programatically created the arguments, as opposed to getting them
+from the arguments in \c main(), it is likely of interest to use
+QTest::qExec(QObject *, const QStringList &) since it is Unicode safe.
+\sa QTEST_MAIN()
+*/
+int QTest::qExec(QObject *testObject, int argc, char **argv)
+{
+QBenchmarkGlobalData benchmarkData;
+QBenchmarkGlobalData::current = &benchmarkData;
+#ifdef QTESTLIB_USE_VALGRIND
+int callgrindChildExitCode = 0;
+#endif
+#ifdef Q_WS_MAC
+bool macNeedsActivate = qApp && (qstrcmp(qApp->metaObject()->className(), "QApplication") == 0);
+#ifdef QT_MAC_USE_COCOA
+IOPMAssertionID powerID;
+#endif
+#endif
+#ifndef QT_NO_EXCEPTIONS
+try {
+#endif
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+SetErrorMode(SetErrorMode(0) | SEM_NOGPFAULTERRORBOX);
+#endif
+#ifdef Q_WS_MAC
+// Starting with Qt 4.4, applications launched from the command line
+// no longer get focus automatically. Since some tests might depend
+// on this, call SetFrontProcess here to get the pre 4.4 behavior.
+if (macNeedsActivate) {
+ProcessSerialNumber psn = { 0, kCurrentProcess };
+SetFrontProcess(&psn);
+#  ifdef QT_MAC_USE_COCOA
+IOReturn ok = IOPMAssertionCreate(kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionLevelOn, &powerID);
+if (ok != kIOReturnSuccess)
+macNeedsActivate = false; // no need to release the assertion on exit.
+#  else
+UpdateSystemActivity(1); // Wake the display.
+#  endif
+}
+#endif
+#if defined(Q_OS_SYMBIAN) && defined(Q_CC_NOKIAX86)
+// Delay execution of tests in Symbian emulator.
+// Needed to allow worst of other higher priority apps and services launched by emulator
+// to get out of the way before we run our test. Otherwise some of the timing sensitive tests
+// will not work properly.
+qSleep(3000);
+#endif
+QTestResult::reset();
+QTEST_ASSERT(testObject);
+QTEST_ASSERT(!currentTestObject);
+currentTestObject = testObject;
+const QMetaObject *metaObject = testObject->metaObject();
+QTEST_ASSERT(metaObject);
+QTestResult::setCurrentTestObject(metaObject->className());
+qParseArgs(argc, argv);
+#ifdef QTESTLIB_USE_VALGRIND
+if (QBenchmarkGlobalData::current->mode() == QBenchmarkGlobalData::CallgrindParentProcess) {
+const QStringList origAppArgs(QCoreApplication::arguments());
+if (!QBenchmarkValgrindUtils::rerunThroughCallgrind(origAppArgs, callgrindChildExitCode))
+return -1;
+QBenchmarkValgrindUtils::cleanup();
+} else
+#endif
+{
+#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
+FatalSignalHandler handler;
+#endif
+qInvokeTestMethods(testObject);
+}
+#ifndef QT_NO_EXCEPTIONS
+} catch (...) {
+QTestResult::addFailure("Caught unhandled exception", __FILE__, __LINE__);
+if (QTestResult::currentTestFunction()) {
+QTestResult::finishedCurrentTestFunction();
+QTestResult::setCurrentTestFunction(0);
+}
+QTestLog::stopLogging();
+#ifdef QT_MAC_USE_COCOA
+if (macNeedsActivate) {
+IOPMAssertionRelease(powerID);
+}
+#endif
+// Rethrow exception to make debugging easier.
+throw;
+return 1;
+}
+#  endif
+currentTestObject = 0;
+#ifdef QT_MAC_USE_COCOA
+if (macNeedsActivate) {
+IOPMAssertionRelease(powerID);
+}
+#endif
+#if !defined(QT_NO_PROCESS) && !defined(QT_NO_SETTINGS)
+if (QBenchmarkGlobalData::current->createChart) {
+QString chartLocation = QLibraryInfo::location(QLibraryInfo::BinariesPath);
+#ifdef Q_OS_WIN
+chartLocation += QLatin1String("/../tools/qtestlib/chart/release/chart.exe");
+#else
+chartLocation += QLatin1String("/../tools/qtestlib/chart/chart");
+#endif
+if (QFile::exists(chartLocation)) {
+QProcess p;
+p.setProcessChannelMode(QProcess::ForwardedChannels);
+p.start(chartLocation, QStringList() << QLatin1String("results.xml"));
+p.waitForFinished(-1);
+} else {
+qDebug() << QLatin1String("Could not find the chart tool in ") + chartLocation + QLatin1String(", please make sure it is compiled.");
+}
+}
+#endif
+#if defined(QTEST_NOEXITCODE)
+return 0;
+#else
+#ifdef QTESTLIB_USE_VALGRIND
+if (QBenchmarkGlobalData::current->mode() == QBenchmarkGlobalData::CallgrindParentProcess)
+return callgrindChildExitCode;
+#endif
+// make sure our exit code is never going above 127
+// since that could wrap and indicate 0 test fails
+return qMin(QTestResult::failCount(), 127);
+#endif
+}
+/*!
+\overload
+\since 4.4
+Behaves identically to qExec(QObject *, int, char**) but takes a
+QStringList of \a arguments instead of a \c char** list.
+*/
+int QTest::qExec(QObject *testObject, const QStringList &arguments)
+{
+const int argc = arguments.count();
+QVarLengthArray<char *> argv(argc);
+QVector<QByteArray> args;
+args.reserve(argc);
+for(int i = 0; i < argc; ++i)
+{
+args.append(arguments.at(i).toLocal8Bit().constData());
+argv[i] = args.last().data();
+}
+return qExec(testObject, argc, argv.data());
+}
+/*! \internal
+*/
+void QTest::qFail(const char *statementStr, const char *file, int line)
+{
+QTestResult::addFailure(statementStr, file, line);
+}
+/*! \internal
+*/
+bool QTest::qVerify(bool statement, const char *statementStr, const char *description,
+const char *file, int line)
+{
+return QTestResult::verify(statement, statementStr, description, file, line);
+}
+/*! \fn void QTest::qSkip(const char *message, SkipMode mode, const char *file, int line)
+\internal
+*/
+void QTest::qSkip(const char *message, QTest::SkipMode mode,
+const char *file, int line)
+{
+QTestResult::addSkip(message, mode, file, line);
+if (mode == QTest::SkipAll)
+QTestResult::setSkipCurrentTest(true);
+}
+/*! \fn bool QTest::qExpectFail(const char *dataIndex, const char *comment, TestFailMode mode, const char *file, int line)
+\internal
+*/
+bool QTest::qExpectFail(const char *dataIndex, const char *comment,
+QTest::TestFailMode mode, const char *file, int line)
+{
+return QTestResult::expectFail(dataIndex, qstrdup(comment), mode, file, line);
+}
+/*! \internal
+*/
+void QTest::qWarn(const char *message)
+{
+QTestLog::warn(message);
+}
+/*!
+Ignores messages created by qDebug() or qWarning(). If the \a message
+with the corresponding \a type is outputted, it will be removed from the
+test log. If the test finished and the \a message was not outputted,
+a test failure is appended to the test log.
+\bold {Note:} Invoking this function will only ignore one message.
+If the message you want to ignore is outputted twice, you have to
+call ignoreMessage() twice, too.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 19
+The example above tests that QDir::mkdir() outputs the right warning when invoked
+with an invalid file name.
+*/
+void QTest::ignoreMessage(QtMsgType type, const char *message)
+{
+QTestResult::ignoreMessage(type, message);
+}
+/*! \internal
+*/
+void *QTest::qData(const char *tagName, int typeId)
+{
+return fetchData(QTestResult::currentTestData(), tagName, typeId);
+}
+/*! \internal
+*/
+void *QTest::qGlobalData(const char *tagName, int typeId)
+{
+return fetchData(QTestResult::currentGlobalTestData(), tagName, typeId);
+}
+/*! \internal
+*/
+void *QTest::qElementData(const char *tagName, int metaTypeId)
+{
+QTEST_ASSERT(tagName);
+QTestData *data = QTestResult::currentTestData();
+QTEST_ASSERT(data);
+QTEST_ASSERT(data->parent());
+int idx = data->parent()->indexOf(tagName);
+QTEST_ASSERT(idx != -1);
+QTEST_ASSERT(data->parent()->elementTypeId(idx) == metaTypeId);
+return data->data(data->parent()->indexOf(tagName));
+}
+/*! \internal
+*/
+void QTest::addColumnInternal(int id, const char *name)
+{
+QTestTable *tbl = QTestTable::currentTestTable();
+QTEST_ASSERT_X(tbl, "QTest::addColumn()", "Cannot add testdata outside of a _data slot.");
+tbl->addColumn(id, name);
+}
+/*!
+Appends a new row to the current test data. \a dataTag is the name of
+the testdata that will appear in the test output. Returns a QTestData reference
+that can be used to stream in data.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 20
+\bold {Note:} This macro can only be used in a test's data function
+that is invoked by the test framework.
+See \l {Chapter 2: Data Driven Testing}{Data Driven Testing} for
+a more extensive example.
+\sa addColumn(), QFETCH()
+*/
+QTestData &QTest::newRow(const char *dataTag)
+{
+QTestTable *tbl = QTestTable::currentTestTable();
+QTEST_ASSERT_X(tbl, "QTest::addColumn()", "Cannot add testdata outside of a _data slot.");
+return *tbl->newData(dataTag);
+}
+/*! \fn void QTest::addColumn(const char *name, T *dummy = 0)
+Adds a column with type \c{T} to the current test data.
+\a name is the name of the column. \a dummy is a workaround
+for buggy compilers and can be ignored.
+To populate the column with values, newRow() can be used. Use
+\l QFETCH() to fetch the data in the actual test.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 21
+To add custom types to the testdata, the type must be registered with
+QMetaType via \l Q_DECLARE_METATYPE().
+\bold {Note:} This macro can only be used in a test's data function
+that is invoked by the test framework.
+See \l {Chapter 2: Data Driven Testing}{Data Driven Testing} for
+a more extensive example.
+\sa QTest::newRow(), QFETCH(), QMetaType
+*/
+/*!
+Returns the name of the test function that is currently executed.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 22
+*/
+const char *QTest::currentTestFunction()
+{
+return QTestResult::currentTestFunction();
+}
+/*!
+Returns the name of the current test data. If the test doesn't
+have any assigned testdata, the function returns 0.
+*/
+const char *QTest::currentDataTag()
+{
+return QTestResult::currentDataTag();
+}
+/*!
+Returns true if the current test function failed, otherwise false.
+*/
+bool QTest::currentTestFailed()
+{
+return QTestResult::currentTestFailed();
+}
+/*!
+Sleeps for \a ms milliseconds, blocking execution of the
+test. qSleep() will not do any event processing and leave your test
+unresponsive. Network communication might time out while
+sleeping. Use \l qWait() to do non-blocking sleeping.
+\a ms must be greater than 0.
+\bold {Note:} The qSleep() function calls either \c nanosleep() on
+unix or \c Sleep() on windows, so the accuracy of time spent in
+qSleep() depends on the operating system.
+Example:
+\snippet doc/src/snippets/code/src_qtestlib_qtestcase.cpp 23
+\sa qWait()
+*/
+void QTest::qSleep(int ms)
+{
+QTEST_ASSERT(ms > 0);
+#ifdef Q_OS_WIN
+Sleep(uint(ms));
+#else
+struct timespec ts = { ms / 1000, (ms % 1000) * 1000 * 1000 };
+nanosleep(&ts, NULL);
+#endif
+}
+/*! \internal
+*/
+QObject *QTest::testObject()
+{
+return currentTestObject;
+}
+/*! \internal
+*/
+bool QTest::compare_helper(bool success, const char *msg, const char *file, int line)
+{
+return QTestResult::compare(success, msg, file, line);
+}
+/*! \internal
+*/
+bool QTest::compare_helper(bool success, const char *msg, char *val1, char *val2,
+const char *actual, const char *expected, const char *file, int line)
+{
+return QTestResult::compare(success, msg, val1, val2, actual, expected, file, line);
+}
+/*! \fn bool QTest::qCompare<float>(float const &t1, float const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+template <>
+Q_TESTLIB_EXPORT bool QTest::qCompare<float>(float const &t1, float const &t2, const char *actual, const char *expected,
+const char *file, int line)
+{
+return qFuzzyCompare(t1, t2)
+? compare_helper(true, "COMPARE()", file, line)
+: compare_helper(false, "Compared floats are not the same (fuzzy compare)",
+toString(t1), toString(t2), actual, expected, file, line);
+}
+/*! \fn bool QTest::qCompare<double>(double const &t1, double const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+template <>
+Q_TESTLIB_EXPORT bool QTest::qCompare<double>(double const &t1, double const &t2, const char *actual, const char *expected,
+const char *file, int line)
+{
+return qFuzzyCompare(t1, t2)
+? compare_helper(true, "COMPARE()", file, line)
+: compare_helper(false, "Compared doubles are not the same (fuzzy compare)",
+toString(t1), toString(t2), actual, expected, file, line);
+}
+#define COMPARE_IMPL2(TYPE, FORMAT) \
+template <> Q_TESTLIB_EXPORT char *QTest::toString<TYPE >(const TYPE &t) \
+{ \
+char *msg = new char[128]; \
+qt_snprintf(msg, 128, #FORMAT, t); \
+return msg; \
+}
+COMPARE_IMPL2(short, %hd)
+COMPARE_IMPL2(ushort, %hu)
+COMPARE_IMPL2(int, %d)
+COMPARE_IMPL2(uint, %u)
+COMPARE_IMPL2(long, %ld)
+COMPARE_IMPL2(ulong, %lu)
+#if defined(Q_OS_WIN)
+COMPARE_IMPL2(qint64, %I64d)
+COMPARE_IMPL2(quint64, %I64u)
+#else
+COMPARE_IMPL2(qint64, %lld)
+COMPARE_IMPL2(quint64, %llu)
+#endif
+COMPARE_IMPL2(bool, %d)
+COMPARE_IMPL2(char, %c)
+COMPARE_IMPL2(float, %g)
+COMPARE_IMPL2(double, %lg)
+/*! \internal
+*/
+char *QTest::toString(const char *str)
+{
+if (!str)
+return 0;
+char *msg = new char[strlen(str) + 1];
+return qstrcpy(msg, str);
+}
+/*! \internal
+*/
+char *QTest::toString(const void *p)
+{
+char *msg = new char[128];
+qt_snprintf(msg, 128, "%p", p);
+return msg;
+}
+/*! \internal
+*/
+bool QTest::compare_string_helper(const char *t1, const char *t2, const char *actual,
+const char *expected, const char *file, int line)
+{
+return (qstrcmp(t1, t2) == 0)
+? compare_helper(true, "COMPARE()", file, line)
+: compare_helper(false, "Compared strings are not the same",
+toString(t1), toString(t2), actual, expected, file, line);
+}
+/*! \fn bool QTest::compare_ptr_helper(const void *t1, const void *t2, const char *actual, const char *expected, const char *file, int line);
+\internal
+*/
+/*! \fn bool QTest::qCompare(T1 const &, T2 const &, const char *, const char *, const char *, int);
+\internal
+*/
+/*! \fn void QTest::mouseEvent(MouseAction action, QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers stateKey, QPoint pos, int delay=-1)
+\internal
+*/
+/*! \fn bool QTest::qCompare(QIcon const &t1, QIcon const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(QPixmap const &t1, QPixmap const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(T const &t1, T const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(const T *t1, const T *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(T *t1, T *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(const T1 *t1, const T2 *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(T1 *t1, T2 *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(const char *t1, const char *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(char *t1, char *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(char *t1, const char *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(const char *t1, char *t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(QString const &t1, QLatin1String const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(QLatin1String const &t1, QString const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(QStringList const &t1, QStringList const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(QFlags<T> const &t1, T const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(QFlags<T> const &t1, int const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qCompare(bool const &t1, int const &t2, const char *actual, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn bool QTest::qTest(const T& actual, const char *elementName, const char *actualStr, const char *expected, const char *file, int line)
+\internal
+*/
+/*! \fn void QTest::sendKeyEvent(KeyAction action, QWidget *widget, Qt::Key code, QString text, Qt::KeyboardModifiers modifier, int delay=-1)
+\internal
+*/
+/*! \fn void QTest::sendKeyEvent(KeyAction action, QWidget *widget, Qt::Key code, char ascii, Qt::KeyboardModifiers modifier, int delay=-1)
+\internal
+*/
+/*! \fn void QTest::simulateEvent(QWidget *widget, bool press, int code, Qt::KeyboardModifiers modifier, QString text, bool repeat, int delay=-1)
+\internal
+*/
+QT_END_NAMESPACE

changeset 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c
child 18	2f34d5167611