QTest Namespace Reference

The QTest namespace contains all the functions and declarations that are related to the QTestLib tool. More...

Classes
class	FatalSignalHandler
struct	IgnoreResultList
class	QBenchmarkIterationController
	The QBenchmarkIterationController class is used by the QBENCHMARK macro to drive the benchmarking loop. More...
struct	QTestDataSetter
class	QTouchEventSequence
	The QTouchEventSequence class is used to simulate a sequence of touch events. More...
struct	TestFuncCleanup
class	TestFunction

Enumerations
enum	{ IndentSpacesCount = 4 }
enum	AttributeIndex {   AI_Undefined = -1, AI_Name = 0, AI_Result = 1, AI_Tests = 2,   AI_Failures = 3, AI_Errors = 4, AI_Type = 5, AI_Description = 6,   AI_PropertyValue = 7, AI_QTestVersion = 8, AI_QtVersion = 9, AI_File = 10,   AI_Line = 11, AI_Metric = 12, AI_Tag = 13, AI_Value = 14,   AI_Iterations = 15 }
	This enum numbers the different tests. More...
enum	KeyAction { Press, Release, Click }
	This enum describes possible actions for key handling. More...
enum	LogElementType {   LET_Undefined = -1, LET_Property = 0, LET_Properties = 1, LET_Failure = 2,   LET_Error = 3, LET_TestCase = 4, LET_TestSuite = 5, LET_Benchmark = 6,   LET_SystemError = 7 }
	The enum specifies the kinds of test log messages. More...
enum	MouseAction {   MousePress, MouseRelease, MouseClick, MouseDClick,   MouseMove }
	This enum describes possible actions for mouse handling. More...
enum	QBenchmarkMetric {   FramesPerSecond, BitsPerSecond, BytesPerSecond, WalltimeMilliseconds,   CPUTicks, InstructionReads, Events }
	This enum lists all the things that can be benchmarked. More...
enum	SkipMode { SkipSingle = 1, SkipAll = 2 }
	This enum describes the modes for skipping tests during execution of the test data. More...
enum	TestFailMode { Abort = 1, Continue = 2 }
	This enum describes the modes for handling an expected failure of the QVERIFY() or QCOMPARE() macros. More...

Functions
template<typename T >
void	addColumn (const char *name, T *=0)
	Adds a column with type T to the current test data. More...
Q_TESTLIB_EXPORT void	addColumnInternal (int id, const char *name)
Q_TESTLIB_EXPORT Qt::Key	asciiToKey (char ascii)
	Convert an ascii char key value to a Qt Key value. More...
Q_TESTLIB_EXPORT void	beginBenchmarkMeasurement ()
const char *	benchmarkMetricName (QBenchmarkMetric metric)
const char *	benchmarkMetricUnit (QBenchmarkMetric metric)
static const char *	benchmarkResult2String ()
static const char *	benchmarkResultFormatString ()
Q_TESTLIB_EXPORT bool	compare_helper (bool success, const char *msg, const char *file, int line)
Q_TESTLIB_EXPORT bool	compare_helper (bool success, const char *msg, char *val1, char *val2, const char *expected, const char *actual, const char *file, int line)
bool	compare_ptr_helper (const void *t1, const void *t2, const char *actual, const char *expected, const char *file, int line)
Q_TESTLIB_EXPORT bool	compare_string_helper (const char *t1, const char *t2, const char *actual, const char *expected, const char *file, int line)
template<typename T >
static int	countSignificantDigits (T num)
Q_TESTLIB_EXPORT const char *	currentAppName ()
	Returns the name of the binary that is currently executed. More...
Q_TESTLIB_EXPORT const char *	currentDataTag ()
	Returns the name of the current test data. More...
Q_TESTLIB_EXPORT bool	currentTestFailed ()
	Returns true if the current test function failed, otherwise false. More...
Q_TESTLIB_EXPORT const char *	currentTestFunction ()
	Returns the name of the test function that is currently executed. More...
int	defaultEventDelay ()
int Q_TESTLIB_EXPORT	defaultKeyDelay ()
bool Q_TESTLIB_EXPORT	defaultKeyVerbose ()
int Q_TESTLIB_EXPORT	defaultMouseDelay ()
Q_TESTLIB_EXPORT quint64	endBenchmarkMeasurement ()
void *	fetchData (QTestData *data, const char *tagName, int typeId)
void	filter_unprintable (char *str)
template<typename T >
QString	formatResult (T number, int significantDigits)
template<typename T >
int	formatResult (char *buffer, int bufferSize, T number, int significantDigits)
static bool	handleIgnoredMessage (QtMsgType type, const char *msg)
Q_TESTLIB_EXPORT void	ignoreMessage (QtMsgType type, const char *message)
	Ignores messages created by qDebug() or qWarning(). More...
static const char *	incidentFormatString (bool noDescription, bool noTag)
static const char *	incidentType2String (QAbstractTestLogger::IncidentTypes type)
void	initLogger ()
static void	invokeMethod (QObject *obj, const char *methodName)
static bool	isEmpty (const char *str)
static bool	isValidSlot (const QMetaMethod &sl)
int	iterationCount ()
static void	keyClick (QWidget *widget, char key, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
static void	keyClick (QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
static void	keyClicks (QWidget *widget, const QString &sequence, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
	Simulates clicking a sequence of keys on a widget. More...
static void	keyEvent (KeyAction action, QWidget *widget, char ascii, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
static void	keyEvent (KeyAction action, QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
static void	keyPress (QWidget *widget, char key, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
static void	keyPress (QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
static void	keyRelease (QWidget *widget, char key, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
static void	keyRelease (QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
Q_TESTLIB_EXPORT char	keyToAscii (Qt::Key key)
	Convert a Qt Key to an ascii char value. More...
static QByteArray	memberName (const QMetaMethod &member)
static const char *	messageFormatString (bool noDescription, bool noTag)
static void	messageHandler (QtMsgType type, const char *msg)
static const char *	messageType2String (QAbstractTestLogger::MessageTypes type)
void	mouseClick (QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers stateKey=0, QPoint pos=QPoint(), int delay=-1)
	Simulates clicking a mouse button with an optional modifier on a widget. More...
void	mouseDClick (QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers stateKey=0, QPoint pos=QPoint(), int delay=-1)
	Simulates double clicking a mouse button with an optional modifier on a widget. More...
static void	mouseEvent (MouseAction action, QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers stateKey, QPoint pos, int delay=-1)
void	mouseMove (QWidget *widget, QPoint pos=QPoint(), int delay=-1)
	Moves the mouse pointer to a widget. More...
void	mousePress (QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers stateKey=0, QPoint pos=QPoint(), int delay=-1)
	Simulates pressing a mouse button with an optional modifier on a widget. More...
void	mouseRelease (QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers stateKey=0, QPoint pos=QPoint(), int delay=-1)
	Simulates releasing a mouse button with an optional modifier on a widget. More...
Q_TESTLIB_EXPORT QTestData &	newRow (const char *dataTag)
	Appends a new row to the current test data. More...
static void	outputMessage (const char *str)
static void	printBenchmarkResult (const QBenchmarkResult &result)
static void	printMessage (const char *type, const char *msg, const char *file=0, int line=0)
template<>
bool	qCompare (QIcon const &t1, QIcon const &t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare (QPixmap const &t1, QPixmap const &t2, const char *actual, const char *expected, const char *file, int line)
template<typename T >
bool	qCompare (T const &t1, T const &t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare (QString const &t1, QLatin1String const &t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare (QLatin1String const &t1, QString const &t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare (QStringList const &t1, QStringList const &t2, const char *actual, const char *expected, const char *file, int line)
template<typename T >
bool	qCompare (QFlags< T > const &t1, T const &t2, const char *actual, const char *expected, const char *file, int line)
template<typename T1 , typename T2 >
bool	qCompare (T1 const &, T2 const &, const char *, const char *, const char *, int)
template<typename T >
bool	qCompare (QFlags< T > const &t1, int const &t2, const char *actual, const char *expected, const char *file, int line)
template<typename T >
bool	qCompare (const T *t1, const T *t2, const char *actual, const char *expected, const char *file, int line)
template<typename T >
bool	qCompare (T *t1, T *t2, const char *actual, const char *expected, const char *file, int line)
template<typename T1 , typename T2 >
bool	qCompare (const T1 *t1, const T2 *t2, const char *actual, const char *expected, const char *file, int line)
template<typename T1 , typename T2 >
bool	qCompare (T1 *t1, T2 *t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare (char *t1, const char *t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare (const char *t1, char *t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare (bool const &t1, int const &t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare< char > (const char *t1, const char *t2, const char *actual, const char *expected, const char *file, int line)
template<>
bool	qCompare< char > (char *t1, char *t2, const char *actual, const char *expected, const char *file, int line)
template<>
Q_TESTLIB_EXPORT bool	qCompare< double > (double const &t1, double const &t2, const char *actual, const char *expected, const char *file, int line)
template<>
Q_TESTLIB_EXPORT bool	qCompare< float > (float const &t1, float const &t2, const char *actual, const char *expected, const char *file, int line)
Q_TESTLIB_EXPORT void *	qData (const char *tagName, int typeId)
Q_TESTLIB_EXPORT void *	qElementData (const char *elementName, int metaTypeId)
Q_TESTLIB_EXPORT int	qExec (QObject *testObject, int argc=0, char **argv=0)
	Executes tests declared in testObject. More...
Q_TESTLIB_EXPORT int	qExec (QObject *testObject, const QStringList &arguments)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
Q_TESTLIB_EXPORT bool	qExpectFail (const char *dataIndex, const char *comment, TestFailMode mode, const char *file, int line)
Q_TESTLIB_EXPORT void	qFail (const char *statementStr, const char *file, int line)
Q_TESTLIB_EXPORT void *	qGlobalData (const char *tagName, int typeId)
static bool	qInvokeTestMethod (const char *slotName, const char *data=0)
	Call init(), slot_data(), slot(), slot(), slot(). More...
static void	qInvokeTestMethodDataEntry (char *slot)
static void	qInvokeTestMethods (QObject *testObject)
QBenchmarkResult	qMedian (const QList< QBenchmarkResult > &container)
static void	qPrintDataTags ()
static void	qPrintMessage (const QByteArray &ba)
static void	qPrintTestSlots ()
static void	qSignalDumperCallback (QObject *caller, int method_index, void **argv)
static void	qSignalDumperCallbackEndSignal (QObject *caller, int)
static void	qSignalDumperCallbackSlot (QObject *caller, int method_index, void **argv)
Q_TESTLIB_EXPORT void	qSkip (const char *message, SkipMode mode, const char *file, int line)
Q_TESTLIB_EXPORT void	qSleep (int ms)
	Sleeps for ms milliseconds, blocking execution of the test. More...
int	qt_asprintf (QTestCharBuffer *str, const char *format,...)
int Q_TESTLIB_EXPORT	qt_snprintf (char *str, int size, const char *format,...)
template<class T >
bool	qTest (const T &actual, const char *elementName, const char *actualStr, const char *expected, const char *file, int line)
Q_TESTLIB_EXPORT void	qtest_qParseArgs (int argc, char *argv[], bool qml)
int	qTestRandomSeed ()
static int	qToInt (char *str)
Q_TESTLIB_EXPORT bool	qVerify (bool statement, const char *statementStr, const char *description, const char *file, int line)
static void	qWait (int ms)
	Waits for ms milliseconds. More...
static bool	qWaitForWindowShown (QWidget *window)
Q_TESTLIB_EXPORT void	qWarn (const char *message)
template<typename T >
static void	randomizeList (T *array, int size)
void	seedRandom ()
static void	sendKeyEvent (KeyAction action, QWidget *widget, Qt::Key code, QString text, Qt::KeyboardModifiers modifier, int delay=-1)
static void	sendKeyEvent (KeyAction action, QWidget *widget, Qt::Key code, char ascii, Qt::KeyboardModifiers modifier, int delay=-1)
void Q_TESTLIB_EXPORT	setBenchmarkResult (qreal result, QBenchmarkMetric metric)
	Sets the benchmark result for this test function to result. More...
void	setIterationCount (int count)
void	setIterationCountHint (int count)
static void	simulateEvent (QWidget *widget, bool press, int code, Qt::KeyboardModifiers modifier, QString text, bool repeat, int delay=-1)
template<typename T >
void	swap (T *array, int pos, int otherPos)
Q_TESTLIB_EXPORT QObject *	testObject ()
char *	toHexRepresentation (const char *ba, int length)
	Returns a pointer to a string that is the string ba represented as a space-separated sequence of hex characters. More...
template<>
char *	toString (const QLatin1String &str)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given string. More...
template<>
char *	toString (const QString &str)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given string. More...
template<>
char *	toString (const QByteArray &ba)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the byte array ba. More...
template<>
char *	toString (const QTime &time)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given time. More...
template<>
char *	toString (const QDate &date)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given date. More...
template<>
char *	toString (const QDateTime &dateTime)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the date and time specified by dateTime. More...
template<>
char *	toString (const QChar &c)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given character. More...
template<>
char *	toString (const QPoint &p)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given point. More...
template<>
char *	toString (const QSize &s)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given size. More...
template<typename T >
char *	toString (const T &)
	Returns a textual representation of value. More...
template<>
char *	toString (const QRect &s)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given rectangle. More...
template<>
char *	toString (const QPointF &p)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given point. More...
Q_TESTLIB_EXPORT char *	toString (const char *)
Q_TESTLIB_EXPORT char *	toString (const void *)
template<>
char *	toString (const QSizeF &s)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given size. More...
template<>
char *	toString (const QRectF &s)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given rectangle. More...
template<>
char *	toString (const QUrl &uri)
template<>
char *	toString (const QVariant &v)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given variant. More...
QTouchEventSequence	touchEvent (QWidget *widget=0, QTouchEvent::DeviceType deviceType=QTouchEvent::TouchScreen)
	Creates and returns a QTouchEventSequence for the device deviceType to simulate events for widget. More...
static const char *	xmlIncidentType2String (QAbstractTestLogger::IncidentTypes type)
static const char *	xmlMessageType2String (QAbstractTestLogger::MessageTypes type)

Variables
static const char *	currentAppName = 0
static QTestData *	currentGlobalTestData = 0
static QTestData *	currentTestData = 0
static const char *	currentTestFunc = 0
static QObject *	currentTestObject = 0
static const char *	currentTestObjectName = 0
static bool	dataFailed = false
static int	eventDelay = -1
static const char *	expectFailComment = 0
static int	expectFailMode = 0
static bool	failed = false
static int	fails = 0
static QTestLog::FlushMode	flushMode = QTestLog::NoFlush
static int	ignoreLevel = 0
static IgnoreResultList *	ignoreResultList = 0
static int	iLevel = 0
static int	keyDelay = -1
static int	keyVerbose = -1
static QTestResult::TestLocation	location = QTestResult::NoWhere
static QTestLog::LogMode	logMode = QTestLog::Plain
static int	maxWarnings = 2002
static int	mouseDelay = -1
static bool	noCrashHandler = false
static QtMsgHandler	oldMessageHandler
static const char *	outFile = 0
static int	passes = 0
Q_TESTLIB_EXPORT bool	printAvailableFunctions = false
Q_TESTLIB_EXPORT bool	printAvailableTags = false
static bool	randomOrder = false
static unsigned int	seed = 0
static bool	seedSet = false
static bool	skipCurrentTest = false
static int	skips = 0
static FILE *	stream = 0
static FILE *	stream = 0
static FILE *	stream = 0
static struct QTest::TestFuncCleanup	testFuncCleaner
static int	testFuncCount = 0
static TestFunction *	testFuncs = 0
Q_TESTLIB_EXPORT QStringList	testFunctions
static QAbstractTestLogger *	testLogger = 0
Q_TESTLIB_EXPORT QStringList	testTags
static int	verbosity = 0

Detailed Description

The QTest namespace contains all the functions and declarations that are related to the QTestLib tool.

Attention

Module: QtTest

Please refer to the QTestLib Manual documentation for information on how to write unit tests.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
IndentSpacesCount

Definition at line 65 of file qsignaldumper.cpp.

{ IndentSpacesCount = 4 };

AttributeIndex

enum QTest::AttributeIndex

This enum numbers the different tests.

• AI_Undefined

• AI_Name

• AI_Result

• AI_Tests

• AI_Failures

• AI_Errors

• AI_Type

• AI_Description

• AI_PropertyValue

• AI_QTestVersion

• AI_QtVersion

• AI_File

• AI_Line

• AI_Metric

• AI_Tag

• AI_Value

• AI_Iterations

Enumerator
AI_Undefined
AI_Name
AI_Result
AI_Tests
AI_Failures
AI_Errors
AI_Type
AI_Description
AI_PropertyValue
AI_QTestVersion
AI_QtVersion
AI_File
AI_Line
AI_Metric
AI_Tag
AI_Value
AI_Iterations

Definition at line 55 of file qtestelementattribute.h.

    {
        AI_Undefined = -1,
        AI_Name = 0,
        AI_Result = 1,
        AI_Tests = 2,
        AI_Failures = 3,
        AI_Errors = 4,
        AI_Type = 5,
        AI_Description = 6,
        AI_PropertyValue = 7,
        AI_QTestVersion = 8,
        AI_QtVersion = 9,
        AI_File = 10,
        AI_Line = 11,
        AI_Metric = 12,
        AI_Tag = 13,
        AI_Value = 14,
        AI_Iterations = 15
    };

KeyAction

enum QTest::KeyAction

This enum describes possible actions for key handling.

• Press The key is pressed.
• Release The key is released.
• Click The key is clicked (pressed and released).

Enumerator
Press
Release
Click

Definition at line 68 of file qtestkeyboard.h.

{ Press, Release, Click };

LogElementType

enum QTest::LogElementType

The enum specifies the kinds of test log messages.

• LET_Undefined

• LET_Property

• LET_Properties

• LET_Failure

• LET_Error

• LET_TestCase

• LET_TestSuite

• LET_Benchmark

• LET_SystemError

Enumerator
LET_Undefined
LET_Property
LET_Properties
LET_Failure
LET_Error
LET_TestCase
LET_TestSuite
LET_Benchmark
LET_SystemError

Definition at line 76 of file qtestelementattribute.h.

    {
        LET_Undefined = -1,
        LET_Property = 0,
        LET_Properties = 1,
        LET_Failure = 2,
        LET_Error = 3,
        LET_TestCase = 4,
        LET_TestSuite = 5,
        LET_Benchmark = 6,
        LET_SystemError = 7
    };

MouseAction

enum QTest::MouseAction

This enum describes possible actions for mouse handling.

• MousePress A mouse button is pressed.
• MouseRelease A mouse button is released.
• MouseClick A mouse button is clicked (pressed and released).
• MouseDClick A mouse button is double clicked (pressed and released twice).
• MouseMove The mouse pointer has moved.

Enumerator
MousePress
MouseRelease
MouseClick
MouseDClick
MouseMove

Definition at line 69 of file qtestmouse.h.

{ MousePress, MouseRelease, MouseClick, MouseDClick, MouseMove };

QBenchmarkMetric

enum QTest::QBenchmarkMetric

This enum lists all the things that can be benchmarked.

Since

4.7

• FramesPerSecond Frames per second
• BitsPerSecond Bits per second
• BytesPerSecond Bytes per second
• WalltimeMilliseconds Clock time in milliseconds
• CPUTicks CPU time
• InstructionReads Instruction reads
• Events Event count

See also

QTest::benchmarkMetricName(), QTest::benchmarkMetricUnit()

Enumerator
FramesPerSecond
BitsPerSecond
BytesPerSecond
WalltimeMilliseconds
CPUTicks
InstructionReads
Events

Definition at line 55 of file qbenchmarkmetric.h.

                      {
    FramesPerSecond,
    BitsPerSecond,
    BytesPerSecond,
    WalltimeMilliseconds,
    CPUTicks,
    InstructionReads,
    Events
};

SkipMode

enum QTest::SkipMode

This enum describes the modes for skipping tests during execution of the test data.

• SkipSingle Skips the current entry in the test table; continues execution of all the other entries in the table.

• SkipAll Skips all the entries in the test table; the test won't be executed further.

See also

QSKIP()

Enumerator
SkipSingle
SkipAll

Definition at line 82 of file qtest_global.h.

{ SkipSingle = 1, SkipAll = 2 };

TestFailMode

enum QTest::TestFailMode

This enum describes the modes for handling an expected failure of the QVERIFY() or QCOMPARE() macros.

• 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.

• Continue Continues execution of the test after the expected failure.

See also

QEXPECT_FAIL()

Enumerator
Abort
Continue

Definition at line 83 of file qtest_global.h.

{ Abort = 1, Continue = 2 };

Function Documentation

addColumn()

template<typename T >

void QTest::addColumn ( const char *  name, T *  dummy = 0  )

inline

Adds a column with type T to the current test data.

name is the name of the column. dummy is a workaround for buggy compilers and can be ignored.

To populate the column with values, newRow() can be used. Use QFETCH() to fetch the data in the actual test.

Example:

void myTestFunction_data() {
    QTest::addColumn<int>("intval");
    QTest::addColumn<QString>("str");
    QTest::addColumn<double>("dbl");

    QTest::newRow("row1") << 1 << "hello" << 1.5;
}

To add custom types to the testdata, the type must be registered with QMetaType via Q_DECLARE_METATYPE() .

Note: This macro can only be used in a test's data function that is invoked by the test framework.

See Chapter 2: Data Driven Testing for a more extensive example.

See also

QTest::newRow(), QFETCH(), QMetaType

Definition at line 168 of file qtestcase.h.

    {
        addColumnInternal(qMetaTypeId<T>(), name);
    }

addColumnInternal()

void QTest::addColumnInternal	(	int	id,
		const char *	name
	)

Warning

This function is not part of the public interface.

Definition at line 2160 of file qtestcase.cpp.

Referenced by addColumn(), and toString().

{
    QTestTable *tbl = QTestTable::currentTestTable();
    QTEST_ASSERT_X(tbl, "QTest::addColumn()", "Cannot add testdata outside of a _data slot.");

    tbl->addColumn(id, name);
}

asciiToKey()

Qt::Key QTest::asciiToKey

(

char

ascii

)

Convert an ascii char key value to a Qt Key value.

Warning

This function is not part of the public interface.

If the key is unknown a 0 is returned.

Note: this may happen more than you like since not all known ascii keys are converted already. So feel free to add all the keys you need.

Definition at line 57 of file qasciikey.cpp.

Referenced by keyEvent(), and toString().

{
    switch ((unsigned char)ascii) {
    case 0x08: return Qt::Key_Backspace;
    case 0x09: return Qt::Key_Tab;
    case 0x0b: return Qt::Key_Backtab;
    case 0x0d: return Qt::Key_Return;
    case 0x1b: return Qt::Key_Escape;
    case 0x20: return Qt::Key_Space;
    case 0x21: return Qt::Key_Exclam;
    case 0x22: return Qt::Key_QuoteDbl;
    case 0x23: return Qt::Key_NumberSign;
    case 0x24: return Qt::Key_Dollar;
    case 0x25: return Qt::Key_Percent;
    case 0x26: return Qt::Key_Ampersand;
    case 0x27: return Qt::Key_Apostrophe;
    case 0x28: return Qt::Key_ParenLeft;
    case 0x29: return Qt::Key_ParenRight;
    case 0x2a: return Qt::Key_Asterisk;
    case 0x2b: return Qt::Key_Plus;
    case 0x2c: return Qt::Key_Comma;
    case 0x2d: return Qt::Key_Minus;
    case 0x2e: return Qt::Key_Period;
    case 0x2f: return Qt::Key_Slash;
    case 0x30: return Qt::Key_0;
    case 0x31: return Qt::Key_1;
    case 0x32: return Qt::Key_2;
    case 0x33: return Qt::Key_3;
    case 0x34: return Qt::Key_4;
    case 0x35: return Qt::Key_5;
    case 0x36: return Qt::Key_6;
    case 0x37: return Qt::Key_7;
    case 0x38: return Qt::Key_8;
    case 0x39: return Qt::Key_9;
    case 0x3a: return Qt::Key_Colon;
    case 0x3b: return Qt::Key_Semicolon;
    case 0x3c: return Qt::Key_Less;
    case 0x3d: return Qt::Key_Equal;
    case 0x3e: return Qt::Key_Greater;
    case 0x3f: return Qt::Key_Question;
    case 0x40: return Qt::Key_At;
    case 0x41: return Qt::Key_A;
    case 0x42: return Qt::Key_B;
    case 0x43: return Qt::Key_C;
    case 0x44: return Qt::Key_D;
    case 0x45: return Qt::Key_E;
    case 0x46: return Qt::Key_F;
    case 0x47: return Qt::Key_G;
    case 0x48: return Qt::Key_H;
    case 0x49: return Qt::Key_I;
    case 0x4a: return Qt::Key_J;
    case 0x4b: return Qt::Key_K;
    case 0x4c: return Qt::Key_L;
    case 0x4d: return Qt::Key_M;
    case 0x4e: return Qt::Key_N;
    case 0x4f: return Qt::Key_O;
    case 0x50: return Qt::Key_P;
    case 0x51: return Qt::Key_Q;
    case 0x52: return Qt::Key_R;
    case 0x53: return Qt::Key_S;
    case 0x54: return Qt::Key_T;
    case 0x55: return Qt::Key_U;
    case 0x56: return Qt::Key_V;
    case 0x57: return Qt::Key_W;
    case 0x58: return Qt::Key_X;
    case 0x59: return Qt::Key_Y;
    case 0x5a: return Qt::Key_Z;
    case 0x5b: return Qt::Key_BracketLeft;
    case 0x5c: return Qt::Key_Backslash;
    case 0x5d: return Qt::Key_BracketRight;
    case 0x5e: return Qt::Key_AsciiCircum;
    case 0x5f: return Qt::Key_Underscore;
    case 0x60: return Qt::Key_QuoteLeft;
    case 0x61: return Qt::Key_A;
    case 0x62: return Qt::Key_B;
    case 0x63: return Qt::Key_C;
    case 0x64: return Qt::Key_D;
    case 0x65: return Qt::Key_E;
    case 0x66: return Qt::Key_F;
    case 0x67: return Qt::Key_G;
    case 0x68: return Qt::Key_H;
    case 0x69: return Qt::Key_I;
    case 0x6a: return Qt::Key_J;
    case 0x6b: return Qt::Key_K;
    case 0x6c: return Qt::Key_L;
    case 0x6d: return Qt::Key_M;
    case 0x6e: return Qt::Key_N;
    case 0x6f: return Qt::Key_O;
    case 0x70: return Qt::Key_P;
    case 0x71: return Qt::Key_Q;
    case 0x72: return Qt::Key_R;
    case 0x73: return Qt::Key_S;
    case 0x74: return Qt::Key_T;
    case 0x75: return Qt::Key_U;
    case 0x76: return Qt::Key_V;
    case 0x77: return Qt::Key_W;
    case 0x78: return Qt::Key_X;
    case 0x79: return Qt::Key_Y;
    case 0x7a: return Qt::Key_Z;
    case 0x7b: return Qt::Key_BraceLeft;
    case 0x7c: return Qt::Key_Bar;
    case 0x7d: return Qt::Key_BraceRight;
    case 0x7e: return Qt::Key_AsciiTilde;

    // Latin 1 codes adapted from X: keysymdef.h,v 1.21 94/08/28 16:17:06
    case 0xa0: return Qt::Key_nobreakspace;
    case 0xa1: return Qt::Key_exclamdown;
    case 0xa2: return Qt::Key_cent;
    case 0xa3: return Qt::Key_sterling;
    case 0xa4: return Qt::Key_currency;
    case 0xa5: return Qt::Key_yen;
    case 0xa6: return Qt::Key_brokenbar;
    case 0xa7: return Qt::Key_section;
    case 0xa8: return Qt::Key_diaeresis;
    case 0xa9: return Qt::Key_copyright;
    case 0xaa: return Qt::Key_ordfeminine;
    case 0xab: return Qt::Key_guillemotleft;
    case 0xac: return Qt::Key_notsign;
    case 0xad: return Qt::Key_hyphen;
    case 0xae: return Qt::Key_registered;
    case 0xaf: return Qt::Key_macron;
    case 0xb0: return Qt::Key_degree;
    case 0xb1: return Qt::Key_plusminus;
    case 0xb2: return Qt::Key_twosuperior;
    case 0xb3: return Qt::Key_threesuperior;
    case 0xb4: return Qt::Key_acute;
    case 0xb5: return Qt::Key_mu;
    case 0xb6: return Qt::Key_paragraph;
    case 0xb7: return Qt::Key_periodcentered;
    case 0xb8: return Qt::Key_cedilla;
    case 0xb9: return Qt::Key_onesuperior;
    case 0xba: return Qt::Key_masculine;
    case 0xbb: return Qt::Key_guillemotright;
    case 0xbc: return Qt::Key_onequarter;
    case 0xbd: return Qt::Key_onehalf;
    case 0xbe: return Qt::Key_threequarters;
    case 0xbf: return Qt::Key_questiondown;
    case 0xc0: return Qt::Key_Agrave;
    case 0xc1: return Qt::Key_Aacute;
    case 0xc2: return Qt::Key_Acircumflex;
    case 0xc3: return Qt::Key_Atilde;
    case 0xc4: return Qt::Key_Adiaeresis;
    case 0xc5: return Qt::Key_Aring;
    case 0xc6: return Qt::Key_AE;
    case 0xc7: return Qt::Key_Ccedilla;
    case 0xc8: return Qt::Key_Egrave;
    case 0xc9: return Qt::Key_Eacute;
    case 0xca: return Qt::Key_Ecircumflex;
    case 0xcb: return Qt::Key_Ediaeresis;
    case 0xcc: return Qt::Key_Igrave;
    case 0xcd: return Qt::Key_Iacute;
    case 0xce: return Qt::Key_Icircumflex;
    case 0xcf: return Qt::Key_Idiaeresis;
    case 0xd0: return Qt::Key_ETH;
    case 0xd1: return Qt::Key_Ntilde;
    case 0xd2: return Qt::Key_Ograve;
    case 0xd3: return Qt::Key_Oacute;
    case 0xd4: return Qt::Key_Ocircumflex;
    case 0xd5: return Qt::Key_Otilde;
    case 0xd6: return Qt::Key_Odiaeresis;
    case 0xd7: return Qt::Key_multiply;
    case 0xd8: return Qt::Key_Ooblique;
    case 0xd9: return Qt::Key_Ugrave;
    case 0xda: return Qt::Key_Uacute;
    case 0xdb: return Qt::Key_Ucircumflex;
    case 0xdc: return Qt::Key_Udiaeresis;
    case 0xdd: return Qt::Key_Yacute;
    case 0xde: return Qt::Key_THORN;
    case 0xdf: return Qt::Key_ssharp;
    case 0xe5: return Qt::Key_Aring;
    case 0xe6: return Qt::Key_AE;
    case 0xf7: return Qt::Key_division;
    case 0xf8: return Qt::Key_Ooblique;
    case 0xff: return Qt::Key_ydiaeresis;
    default: QTEST_ASSERT(false); return Qt::Key(0);
    }
}

beginBenchmarkMeasurement()

void QTest::beginBenchmarkMeasurement

(

)

Warning

This function is not part of the public interface.

Definition at line 260 of file qbenchmark.cpp.

Referenced by QTest::QBenchmarkIterationController::QBenchmarkIterationController().

{
    QBenchmarkGlobalData::current->measurer->start();
    // the clock is ticking after the line above, don't add code here.
}

benchmarkMetricName()

const char* QTest::benchmarkMetricName

(

QBenchmarkMetric

metric

)

Referenced by QXmlTestLogger::addBenchmarkResult(), and QTestLogger::addBenchmarkResult().

benchmarkMetricUnit()

const char* QTest::benchmarkMetricUnit

(

QBenchmarkMetric

metric

)

Referenced by printBenchmarkResult().

benchmarkResult2String()

static const char* QTest::benchmarkResult2String ( )

static

Definition at line 125 of file qplaintestlogger.cpp.

Referenced by printBenchmarkResult().

    {
        static bool colored = (!qgetenv("QTEST_COLORED").isEmpty());
        return COLORED_MSG(0, 36, "RESULT "); // cyan
    }

benchmarkResultFormatString()

static const char* QTest::benchmarkResultFormatString ( )

static

Definition at line 189 of file qxmltestlogger.cpp.

Referenced by QXmlTestLogger::addBenchmarkResult().

{
    return "<BenchmarkResult metric=\"%s\" tag=\"%s\" value=\"%s\" iterations=\"%d\" />\n";
}

compare_helper() [1/2]

bool QTest::compare_helper	(	bool	success,
		const char *	msg,
		const char *	file,
		int	line
	)

Warning

This function is not part of the public interface.

Definition at line 2290 of file qtestcase.cpp.

Referenced by compare_ptr_helper(), compare_string_helper(), qCompare(), qCompare< double >(), qCompare< float >(), and toString().

{
    return QTestResult::compare(success, msg, file, line);
}

compare_helper() [2/2]

bool QTest::compare_helper	(	bool	success,
		const char *	msg,
		char *	val1,
		char *	val2,
		const char *	actual,
		const char *	expected,
		const char *	file,
		int	line
	)

Warning

This function is not part of the public interface.

Definition at line 2297 of file qtestcase.cpp.

{
    return QTestResult::compare(success, msg, val1, val2, actual, expected, file, line);
}

compare_ptr_helper()

bool QTest::compare_ptr_helper ( const void *  t1, const void *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 193 of file qtestcase.h.

Referenced by qCompare().

    {
        return (t1 == t2)
            ? compare_helper(true, "COMPARE()", file, line)
            : compare_helper(false, "Compared pointers are not the same",
                             toString(t1), toString(t2), actual, expected, file, line);
    }

compare_string_helper()

bool QTest::compare_string_helper	(	const char *	t1,
		const char *	t2,
		const char *	actual,
		const char *	expected,
		const char *	file,
		int	line
	)

Warning

This function is not part of the public interface.

Definition at line 2376 of file qtestcase.cpp.

Referenced by compare_ptr_helper(), qCompare(), and qCompare< char >().

{
    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);
}

countSignificantDigits()

template<typename T >

static int QTest::countSignificantDigits ( T  num )

static

Definition at line 233 of file qplaintestlogger.cpp.

Referenced by printBenchmarkResult().

    {
        if (num <= 0)
            return 0;

        int digits = 0;
        qreal divisor = 1;

        while (num / divisor >= 1) {
            divisor *= 10;
            ++digits;
        }

        return digits;
    }

currentAppName()

const char * QTest::currentAppName

(

)

Returns the name of the binary that is currently executed.

Definition at line 2218 of file qtestcase.cpp.

{
    return QTestResult::currentAppName();
}

currentDataTag()

const char * QTest::currentDataTag

(

)

Returns the name of the current test data.

If the test doesn't have any assigned testdata, the function returns 0.

Definition at line 2239 of file qtestcase.cpp.

Referenced by toString().

{
    return QTestResult::currentDataTag();
}

currentTestFailed()

bool QTest::currentTestFailed

(

)

Returns true if the current test function failed, otherwise false.

Definition at line 2247 of file qtestcase.cpp.

Referenced by qInvokeTestMethods(), and toString().

{
    return QTestResult::currentTestFailed();
}

currentTestFunction()

const char * QTest::currentTestFunction

(

)

Returns the name of the test function that is currently executed.

Example:

void MyTestClass::cleanup()
{
    if (qstrcmp(currentTestFunction(), "myDatabaseTest") == 0) {
        // clean up all database connections
        closeAllDatabases();
    }
}

Definition at line 2230 of file qtestcase.cpp.

Referenced by toString().

{
    return QTestResult::currentTestFunction();
}

defaultEventDelay()

int QTest::defaultEventDelay

(

)

Definition at line 997 of file qtestcase.cpp.

Referenced by defaultKeyDelay(), and defaultMouseDelay().

{
    if (eventDelay == -1) {
        if (qgetenv("QTEST_EVENT_DELAY").constData())
            eventDelay = atoi(qgetenv("QTEST_EVENT_DELAY"));
        else
            eventDelay = 0;
    }
    return eventDelay;
}

defaultKeyDelay()

int Q_TESTLIB_EXPORT QTest::defaultKeyDelay

(

)

Definition at line 1019 of file qtestcase.cpp.

Referenced by simulateEvent().

{
    if (keyDelay == -1) {
        if (qgetenv("QTEST_KEYEVENT_DELAY").constData())
            keyDelay = atoi(qgetenv("QTEST_KEYEVENT_DELAY").constData());
        else
            keyDelay = defaultEventDelay();
    }
    return keyDelay;
}

defaultKeyVerbose()

bool Q_TESTLIB_EXPORT QTest::defaultKeyVerbose

(

)

Definition at line 989 of file qtestcase.cpp.

{
    if (keyVerbose == -1) {
        keyVerbose = qgetenv("QTEST_KEYEVENT_VERBOSE").constData() ? 1 : 0;
    }
    return keyVerbose == 1;
}

defaultMouseDelay()

int Q_TESTLIB_EXPORT QTest::defaultMouseDelay

(

)

Definition at line 1008 of file qtestcase.cpp.

Referenced by mouseEvent().

{
    if (mouseDelay == -1) {
        if (qgetenv("QTEST_MOUSEEVENT_DELAY").constData())
            mouseDelay = atoi((qgetenv("QTEST_MOUSEEVENT_DELAY")));
        else
            mouseDelay = defaultEventDelay();
    }
    return mouseDelay;
}

endBenchmarkMeasurement()

quint64 QTest::endBenchmarkMeasurement

(

)

Warning

This function is not part of the public interface.

Definition at line 268 of file qbenchmark.cpp.

Referenced by QTest::QBenchmarkIterationController::~QBenchmarkIterationController().

{
    // the clock is ticking before the line below, don't add code here.
    return QBenchmarkGlobalData::current->measurer->stop();    
}

fetchData()

void* QTest::fetchData	(	QTestData *	data,
		const char *	tagName,
		int	typeId
	)

Definition at line 1635 of file qtestcase.cpp.

Referenced by QXmlInputSource::next(), qData(), and qGlobalData().

{
    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);
}

filter_unprintable()

void QTest::filter_unprintable

(

char *

str

)

Definition at line 949 of file qtestcase.cpp.

Referenced by qt_asprintf(), qt_snprintf(), and QAbstractTestLogger::stopLogging().

{
    char *idx = str;
    while (*idx) {
        if (((*idx < 0x20 && *idx != '\n' && *idx != '\t') || *idx > 0x7e))
            *idx = '?';
        ++idx;
    }
}

formatResult() [1/2]

template<typename T >

QString QTest::formatResult	(	T	number,
		int	significantDigits
	)

Definition at line 250 of file qplaintestlogger.cpp.

Referenced by formatResult(), and printBenchmarkResult().

    {
        if (number < T(0))
            return QLatin1String("NAN");
        if (number == T(0))
            return QLatin1String("0");

        QString beforeDecimalPoint = QString::number(qint64(number), 'f', 0);
        QString afterDecimalPoint = QString::number(number, 'f', 20);
        afterDecimalPoint.remove(0, beforeDecimalPoint.count() + 1);

        int beforeUse = qMin(beforeDecimalPoint.count(), significantDigits);
        int beforeRemove = beforeDecimalPoint.count() - beforeUse;

        // Replace insignificant digits before the decimal point with zeros.
        beforeDecimalPoint.chop(beforeRemove);
        for (int i = 0; i < beforeRemove; ++i) {
            beforeDecimalPoint.append(QLatin1Char('0'));
        }

        int afterUse = significantDigits - beforeUse;

        // leading zeroes after the decimal point does not count towards the digit use.
        if (beforeDecimalPoint == QLatin1String("0") && afterDecimalPoint.isEmpty() == false) {
            ++afterUse;

            int i = 0;
            while (i < afterDecimalPoint.count() && afterDecimalPoint.at(i) == QLatin1Char('0')) {
                ++i;
            }

            afterUse += i;
        }

        int afterRemove = afterDecimalPoint.count() - afterUse;
        afterDecimalPoint.chop(afterRemove);

        QChar separator = QLatin1Char(',');
        QChar decimalPoint = QLatin1Char('.');

        // insert thousands separators
        int length = beforeDecimalPoint.length();
        for (int i = beforeDecimalPoint.length() -1; i >= 1; --i) {
            if ((length - i) % 3 == 0)
                beforeDecimalPoint.insert(i, separator);
        }

        QString print;
        print = beforeDecimalPoint;
        if (afterUse > 0)
            print.append(decimalPoint);

        print += afterDecimalPoint;


        return print;
    }

formatResult() [2/2]

template<typename T >

int QTest::formatResult	(	char *	buffer,
		int	bufferSize,
		T	number,
		int	significantDigits
	)

Definition at line 309 of file qplaintestlogger.cpp.

    {
        QString result = formatResult(number, significantDigits);
        qstrncpy(buffer, result.toAscii().constData(), bufferSize);
        int size = result.count();
        return size;
    }

handleIgnoredMessage()

static bool QTest::handleIgnoredMessage ( QtMsgType  type, const char *  msg  )

static

Definition at line 97 of file qtestlog.cpp.

Referenced by messageHandler().

    {
        IgnoreResultList *last = 0;
        IgnoreResultList *list = ignoreResultList;
        while (list) {
            if (list->type == type && strcmp(msg, list->msg) == 0) {
                // remove the item from the list
                if (last)
                    last->next = list->next;
                else if (list->next)
                    ignoreResultList = list->next;
                else
                    ignoreResultList = 0;

                delete list;
                return true;
            }

            last = list;
            list = list->next;
        }
        return false;
    }

ignoreMessage()

void QTest::ignoreMessage	(	QtMsgType	type,
		const char *	message
	)

Ignores messages created by qDebug() or qWarning().

If the message with the corresponding type is outputted, it will be removed from the test log. If the test finished and the message was not outputted, a test failure is appended to the test log.

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:

QDir dir;

QTest::ignoreMessage(QtWarningMsg, "QDir::mkdir: Empty or null file name(s)");
dir.mkdir("");

The example above tests that QDir::mkdir() outputs the right warning when invoked with an invalid file name.

Definition at line 2123 of file qtestcase.cpp.

Referenced by toString().

{
    QTestResult::ignoreMessage(type, message);
}

incidentFormatString()

static const char* QTest::incidentFormatString ( bool  noDescription, bool  noTag  )

static

Definition at line 167 of file qxmltestlogger.cpp.

Referenced by QXmlTestLogger::addIncident().

{
    if (noDescription) {
        if (noTag)
            return "<Incident type=\"%s\" file=\"%s\" line=\"%d\" />\n";
        else
            return "<Incident type=\"%s\" file=\"%s\" line=\"%d\">\n"
                "    <DataTag><![CDATA[%s%s%s%s]]></DataTag>\n"
                "</Incident>\n";
    } else {
        if (noTag)
            return "<Incident type=\"%s\" file=\"%s\" line=\"%d\">\n"
                "    <Description><![CDATA[%s%s%s%s]]></Description>\n"
                "</Incident>\n";
        else
            return "<Incident type=\"%s\" file=\"%s\" line=\"%d\">\n"
                "    <DataTag><![CDATA[%s%s%s]]></DataTag>\n"
                "    <Description><![CDATA[%s]]></Description>\n"
                "</Incident>\n";
    }
}

incidentType2String()

static const char* QTest::incidentType2String ( QAbstractTestLogger::IncidentTypes  type )

static

Definition at line 109 of file qplaintestlogger.cpp.

Referenced by QPlainTestLogger::addIncident().

    {
        static bool colored = (!qgetenv("QTEST_COLORED").isEmpty());
        switch (type) {
        case QAbstractTestLogger::Pass:
            return COLORED_MSG(0, 32, "PASS   "); //green
        case QAbstractTestLogger::XFail:
            return COLORED_MSG(1, 32, "XFAIL  "); //light green
        case QAbstractTestLogger::Fail:
            return COLORED_MSG(0, 31, "FAIL!  "); //red
        case QAbstractTestLogger::XPass:
            return COLORED_MSG(0, 31, "XPASS  "); //red, too
        }
        return "??????";
    }

initLogger()

void QTest::initLogger

(

)

Definition at line 171 of file qtestlog.cpp.

Referenced by QTestLog::startLogging().

{
    switch (QTest::logMode) {
        case QTestLog::Plain:
            QTest::testLogger = new QPlainTestLogger;
            break;
        case QTestLog::XML:{
            if(QTest::flushMode == QTestLog::FLushOn)
                QTest::testLogger = new QXmlTestLogger(QXmlTestLogger::Complete);
            else
                QTest::testLogger = new QTestLogger(QTestLogger::TLF_XML);
            break;
        }case QTestLog::LightXML:{
            if(QTest::flushMode == QTestLog::FLushOn)
                QTest::testLogger = new QXmlTestLogger(QXmlTestLogger::Light);
            else
                QTest::testLogger = new QTestLogger(QTestLogger::TLF_LightXml);
            break;
        }case QTestLog::XunitXML:
            QTest::testLogger = new QTestLogger(QTestLogger::TLF_XunitXml);
        }
}

invokeMethod()

static void QTest::invokeMethod ( QObject *  obj, const char *  methodName  )

static

Warning

This function is not part of the public interface. Invoke a method of the object without generating warning if the method does not exist

Definition at line 979 of file qtestcase.cpp.

Referenced by QAccessibleInterface::backgroundColor(), QAccessibleInterface::foregroundColor(), QMetaObject::invokeMethod(), qInvokeTestMethod(), qInvokeTestMethodDataEntry(), qInvokeTestMethods(), qPrintDataTags(), QAccessibleInterface::supportedMethods(), and QAccessibleInterface::~QAccessibleInterface().

{
    const QMetaObject *metaObject = obj->metaObject();
    int funcIndex = metaObject->indexOfMethod(methodName);
    if (funcIndex >= 0) {
        QMetaMethod method = metaObject->method(funcIndex);
        method.invoke(obj, Qt::DirectConnection);
    }
}

isEmpty()

static bool QTest::isEmpty ( const char *  str )

inlinestatic

Definition at line 162 of file qxmltestlogger.cpp.

Referenced by QTimerInfoList::activateTimers(), QSvgStructureNode::addChild(), QPostEventList::addEvent(), QXmlTestLogger::addIncident(), QXmlTestLogger::addMessage(), QCopChannel::answer(), QSvgNode::appendStyleProperty(), QCoreApplication::applicationFilePath(), QPatternist::TypeChecker::applyFunctionConversion(), QAxWidget::clear(), QApplicationPrivate::closePopup(), QPainterPath::contains(), QString::count(), QPatternist::AbstractDuration::create(), QEglFSScreen::createAndSetPlatformContext(), QCoreApplicationPrivate::createEventDispatcher(), QThreadPrivate::createEventDispatcher(), createReadHandlerHelper(), QDeclarativeTypeData::dataReceived(), QETWidget::doDeferredMap(), QDeclarativeXmlQueryEngine::doSubQueryJob(), QTextLayout::draw(), QObject::dumpObjectInfo(), QAxBase::dynamicCallHelper(), QLinkedList< JSC::Identifier >::empty(), QList< QPostEvent >::empty(), QMap< int, QFrameInfo >::empty(), QHash< QExplicitlySharedDataPointer, QHash >::empty(), QLinkedList< JSC::Identifier >::endsWith(), QVector< QPoint >::endsWith(), QList< QPostEvent >::endsWith(), QProxyStylePrivate::ensureBaseStyle(), QNetworkDiskCache::expire(), QGestureManager::filterEventThroughContexts(), QContiguousCache< T >::first(), QLinkedList< JSC::Identifier >::first(), QVector< QPoint >::first(), QList< QPostEvent >::first(), QXcbWindowSurface::flush(), getFullPath(), QDockAreaLayout::getGrid(), if(), QDirectFBScreen::initDevice(), QAxBase::initialize(), QMacPasteboardMime::initialize(), QPainterPath::intersected(), QPainterPath::intersects(), QStateMachinePrivate::isAtomic(), QStateMachinePrivate::isCompound(), isEmptyHelper(), isNull(), QStyleSheetBorderData::isOpaque(), QIndexMapper::isValid(), QItemSelectionRange::isValid(), isValidUri(), isValidWildcardRestriction(), QPatternist::XsdSchemaHelper::isWildcardSubset(), QContiguousCache< T >::last(), QLinkedList< JSC::Identifier >::last(), QVector< QPoint >::last(), QList< QPostEvent >::last(), launchWebBrowser(), QDialogButtonBoxPrivate::layoutButtons(), QPainterPath::length(), QIconLoader::loadIcon(), macVersion(), QDeclarativeText::mousePressEvent(), QAccessibleGroupBox::navigate(), QCFString::operator QString(), QSqlRecord::operator!=(), QProcessEnvironment::operator!=(), QRegExp::operator!=(), QList< QPostEvent >::operator+=(), QStringList::operator<<(), QPatternist::GeneralComparison::optimizationPasses(), QDeclarativeStyledText::parse(), QXmlSimpleReaderPrivate::parseContent(), QPatternist::XsdSchemaParser::parseNotation(), QPainterPath::percentAtLength(), QVector< QPoint >::pop_back(), QVector< QPoint >::pop_front(), QGLEngineSelector::preferredPaintEngine(), QSQLiteResult::prepare(), QPrinter::printRange(), QEventDispatcherQWS::processEvents(), QXmlSimpleReaderPrivate::processReference(), qax_noSuchFunction(), qDBusGenerateMetaObjectXml(), qDBusInterfaceFromMetaObject(), QEventDispatcherGlibPrivate::QEventDispatcherGlibPrivate(), QRect::QRect(), QRuntimeGraphicsSystem::QRuntimeGraphicsSystem(), qt_bitmapToRegion(), qt_region_strictContains(), qt_try_modal(), QETWidget::raiseOnClick(), QDeclarativeBindingCompilerPrivate::registerString(), QHash< QExplicitlySharedDataPointer, QHash >::remove(), QLinkedList< JSC::Identifier >::removeFirst(), QList< QPostEvent >::removeFirst(), QLinkedList< JSC::Identifier >::removeLast(), QList< QPostEvent >::removeLast(), QKqueueFileSystemWatcherEngine::removePaths(), QPatternist::ReportContext::resolveURI(), QFileDialog::restoreState(), QSqlRelationalTableModel::selectStatement(), QLineControl::setCursorBlinkPeriod(), QDockAreaLayout::setGrid(), QFileSystemModel::setRootPath(), QApplicationPrivate::setScreenTransformation(), QApplication::setStyle(), QLabel::setText(), QMdiSubWindow::setWidget(), QSidebar::showContextMenu(), QPainterPath::simplified(), someId(), QCommonStyle::standardPixmap(), QLinkedList< JSC::Identifier >::startsWith(), QVector< QPoint >::startsWith(), QList< QPostEvent >::startsWith(), QApplication::style(), QPainterPath::subtracted(), QRegion::swap(), QPainterPath::swap(), QUrl::swap(), QByteArray::swap(), QHash< QExplicitlySharedDataPointer, QHash >::take(), QAccessibleDial::text(), QLineControl::timerEvent(), QDeclarativeError::toString(), QPainterPath::united(), QTimerInfoList::unregisterTimers(), QListView::updateGeometries(), QWorkspaceChild::updateMask(), QGtkStyleUpdateScheduler::updateTheme(), QTestAccessibility::verifyEvent(), QApplicationPrivate::x11_apply_settings(), and QPatternist::yyparse().

{
    return !str || !str[0];
}

isValidSlot()

static bool QTest::isValidSlot ( const QMetaMethod &  sl )

static

Definition at line 1067 of file qtestcase.cpp.

Referenced by qInvokeTestMethods(), qPrintDataTags(), qPrintTestSlots(), and qtest_qParseArgs().

{
    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;
}

iterationCount()

int QTest::iterationCount

(

)

Warning

This function is not part of the public interface.

Definition at line 238 of file qbenchmark.cpp.

Referenced by elapsed(), and QTest::QBenchmarkIterationController::isDone().

{
    return QBenchmarkTestMethodData::current->iterationCount;
}

keyClick() [1/2]

static void QTest::keyClick ( QWidget *  widget, char  key, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 179 of file qtestkeyboard.h.

    { keyEvent(Click, widget, key, modifier, delay); }

keyClick() [2/2]

static void QTest::keyClick ( QWidget *  widget, Qt::Key  key, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 185 of file qtestkeyboard.h.

    { keyEvent(Click, widget, key, modifier, delay); }

keyClicks()

void QTest::keyClicks ( QWidget *  widget, const QString &  sequence, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Simulates clicking a sequence of keys on a widget.

Optionally, a keyboard modifier can be specified as well as a delay (in milliseconds) of the test before each key click.

Example:

QTest::keyClicks(myWidget, "hello world");

The example above simulates clicking the sequence of keys representing "hello world" on myWidget without any keyboard modifiers and without delay of the test.

See also

QTest::keyClick()

Definition at line 168 of file qtestkeyboard.h.

Referenced by QTestEvent::~QTestEvent().

    {
        for (int i=0; i < sequence.length(); i++)
            keyEvent(Click, widget, sequence.at(i).toLatin1(), modifier, delay);
    }

keyEvent() [1/2]

static void QTest::keyEvent ( KeyAction  action, QWidget *  widget, char  ascii, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 161 of file qtestkeyboard.h.

Referenced by QCalendarPopup::event(), QMdiArea::eventFilter(), QBBInputContext::handleKeyboardEvent(), QVNCServer::hasClientCursor(), QmlJSDebugger::AbstractTool::inspector(), keyClick(), keyClicks(), keyPress(), keyRelease(), qt_dispatchKeyEvent(), qtKey2CocoaKey(), QVNCServer::setCursor(), QmlJSDebugger::AbstractViewInspector::slowDownFactor(), and QTestEvent::~QTestEvent().

    { sendKeyEvent(action, widget, asciiToKey(ascii), ascii, modifier, delay); }

keyEvent() [2/2]

static void QTest::keyEvent ( KeyAction  action, QWidget *  widget, Qt::Key  key, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 164 of file qtestkeyboard.h.

    { sendKeyEvent(action, widget, key, keyToAscii(key), modifier, delay); }

keyPress() [1/2]

static void QTest::keyPress ( QWidget *  widget, char  key, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 175 of file qtestkeyboard.h.

Referenced by QMdiArea::eventFilter().

    { keyEvent(Press, widget, key, modifier, delay); }

keyPress() [2/2]

static void QTest::keyPress ( QWidget *  widget, Qt::Key  key, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 181 of file qtestkeyboard.h.

    { keyEvent(Press, widget, key, modifier, delay); }

keyRelease() [1/2]

static void QTest::keyRelease ( QWidget *  widget, char  key, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 177 of file qtestkeyboard.h.

    { keyEvent(Release, widget, key, modifier, delay); }

keyRelease() [2/2]

static void QTest::keyRelease ( QWidget *  widget, Qt::Key  key, Qt::KeyboardModifiers  modifier = Qt::NoModifier, int  delay = -1  )

inlinestatic

Definition at line 183 of file qtestkeyboard.h.

    { keyEvent(Release, widget, key, modifier, delay); }

keyToAscii()

char QTest::keyToAscii

(

Qt::Key

key

)

Convert a Qt Key to an ascii char value.

Warning

This function is not part of the public interface.

If the Qt key is unknown a 0 is returned.

Note: this may happen more than you like since not all known Qt keys are converted already. So feel free to add all the keys you need.

Definition at line 245 of file qasciikey.cpp.

Referenced by keyEvent(), and toString().

{
    switch (key) {
    case Qt::Key_Backspace: return 0x8; //BS
    case Qt::Key_Tab: return 0x09; // HT
    case Qt::Key_Backtab: return 0x0b; // VT
    case Qt::Key_Enter:
    case Qt::Key_Return: return 0x0d; // CR
    case Qt::Key_Escape: return 0x1b; // ESC
    case Qt::Key_Space: return 0x20;        // 7 bit printable ASCII
    case Qt::Key_Exclam: return 0x21;
    case Qt::Key_QuoteDbl: return 0x22;
    case Qt::Key_NumberSign: return 0x23;
    case Qt::Key_Dollar: return 0x24;
    case Qt::Key_Percent: return 0x25;
    case Qt::Key_Ampersand: return 0x26;
    case Qt::Key_Apostrophe: return 0x27;
    case Qt::Key_ParenLeft: return 0x28;
    case Qt::Key_ParenRight: return 0x29;
    case Qt::Key_Asterisk: return 0x2a;
    case Qt::Key_Plus: return 0x2b;
    case Qt::Key_Comma: return 0x2c;
    case Qt::Key_Minus: return 0x2d;
    case Qt::Key_Period: return 0x2e;
    case Qt::Key_Slash: return 0x2f;
    case Qt::Key_0: return 0x30;
    case Qt::Key_1: return 0x31;
    case Qt::Key_2: return 0x32;
    case Qt::Key_3: return 0x33;
    case Qt::Key_4: return 0x34;
    case Qt::Key_5: return 0x35;
    case Qt::Key_6: return 0x36;
    case Qt::Key_7: return 0x37;
    case Qt::Key_8: return 0x38;
    case Qt::Key_9: return 0x39;
    case Qt::Key_Colon: return 0x3a;
    case Qt::Key_Semicolon: return 0x3b;
    case Qt::Key_Less: return 0x3c;
    case Qt::Key_Equal: return 0x3d;
    case Qt::Key_Greater: return 0x3e;
    case Qt::Key_Question: return 0x3f;
    case Qt::Key_At: return 0x40;
    case Qt::Key_A: return 0x61; // 0x41 == 'A', 0x61 == 'a'
    case Qt::Key_B: return 0x62;
    case Qt::Key_C: return 0x63;
    case Qt::Key_D: return 0x64;
    case Qt::Key_E: return 0x65;
    case Qt::Key_F: return 0x66;
    case Qt::Key_G: return 0x67;
    case Qt::Key_H: return 0x68;
    case Qt::Key_I: return 0x69;
    case Qt::Key_J: return 0x6a;
    case Qt::Key_K: return 0x6b;
    case Qt::Key_L: return 0x6c;
    case Qt::Key_M: return 0x6d;
    case Qt::Key_N: return 0x6e;
    case Qt::Key_O: return 0x6f;
    case Qt::Key_P: return 0x70;
    case Qt::Key_Q: return 0x71;
    case Qt::Key_R: return 0x72;
    case Qt::Key_S: return 0x73;
    case Qt::Key_T: return 0x74;
    case Qt::Key_U: return 0x75;
    case Qt::Key_V: return 0x76;
    case Qt::Key_W: return 0x77;
    case Qt::Key_X: return 0x78;
    case Qt::Key_Y: return 0x79;
    case Qt::Key_Z: return 0x7a;
    case Qt::Key_BracketLeft: return 0x5b;
    case Qt::Key_Backslash: return 0x5c;
    case Qt::Key_BracketRight: return 0x5d;
    case Qt::Key_AsciiCircum: return 0x5e;
    case Qt::Key_Underscore: return 0x5f;
    case Qt::Key_QuoteLeft: return 0x60;

    case Qt::Key_BraceLeft: return 0x7b;
    case Qt::Key_Bar: return 0x7c;
    case Qt::Key_BraceRight: return 0x7d;
    case Qt::Key_AsciiTilde: return 0x7e;

    case Qt::Key_Delete: return 0;
    case Qt::Key_Insert: return 0; // = 0x1006,
    case Qt::Key_Pause: return 0; // = 0x1008,
    case Qt::Key_Print: return 0; // = 0x1009,
    case Qt::Key_SysReq: return 0; // = 0x100a,

    case Qt::Key_Clear: return 0; // = 0x100b,

    case Qt::Key_Home: return 0; // = 0x1010,        // cursor movement
    case Qt::Key_End: return 0; // = 0x1011,
    case Qt::Key_Left: return 0; // = 0x1012,
    case Qt::Key_Up: return 0; // = 0x1013,
    case Qt::Key_Right: return 0; // = 0x1014,
    case Qt::Key_Down: return 0; // = 0x1015,
    case Qt::Key_PageUp: return 0; // = 0x1016,
    case Qt::Key_PageDown: return 0; // = 0x1017,
    case Qt::Key_Shift: return 0; // = 0x1020,        // modifiers
    case Qt::Key_Control: return 0; // = 0x1021,
    case Qt::Key_Meta: return 0; // = 0x1022,
    case Qt::Key_Alt: return 0; // = 0x1023,
    case Qt::Key_CapsLock: return 0; // = 0x1024,
    case Qt::Key_NumLock: return 0; // = 0x1025,
    case Qt::Key_ScrollLock: return 0; // = 0x1026,
    case Qt::Key_F1: return 0; // = 0x1030,        // function keys
    case Qt::Key_F2: return 0; // = 0x1031,
    case Qt::Key_F3: return 0; // = 0x1032,
    case Qt::Key_F4: return 0; // = 0x1033,
    case Qt::Key_F5: return 0; // = 0x1034,
    case Qt::Key_F6: return 0; // = 0x1035,
    case Qt::Key_F7: return 0; // = 0x1036,
    case Qt::Key_F8: return 0; // = 0x1037,
    case Qt::Key_F9: return 0; // = 0x1038,
    case Qt::Key_F10: return 0; // = 0x1039,
    case Qt::Key_F11: return 0; // = 0x103a,
    case Qt::Key_F12: return 0; // = 0x103b,
    case Qt::Key_F13: return 0; // = 0x103c,
    case Qt::Key_F14: return 0; // = 0x103d,
    case Qt::Key_F15: return 0; // = 0x103e,
    case Qt::Key_F16: return 0; // = 0x103f,
    case Qt::Key_F17: return 0; // = 0x1040,
    case Qt::Key_F18: return 0; // = 0x1041,
    case Qt::Key_F19: return 0; // = 0x1042,
    case Qt::Key_F20: return 0; // = 0x1043,
    case Qt::Key_F21: return 0; // = 0x1044,
    case Qt::Key_F22: return 0; // = 0x1045,
    case Qt::Key_F23: return 0; // = 0x1046,
    case Qt::Key_F24: return 0; // = 0x1047,
    case Qt::Key_F25: return 0; // = 0x1048,        // F25 .. F35 only on X11
    case Qt::Key_F26: return 0; // = 0x1049,
    case Qt::Key_F27: return 0; // = 0x104a,
    case Qt::Key_F28: return 0; // = 0x104b,
    case Qt::Key_F29: return 0; // = 0x104c,
    case Qt::Key_F30: return 0; // = 0x104d,
    case Qt::Key_F31: return 0; // = 0x104e,
    case Qt::Key_F32: return 0; // = 0x104f,
    case Qt::Key_F33: return 0; // = 0x1050,
    case Qt::Key_F34: return 0; // = 0x1051,
    case Qt::Key_F35: return 0; // = 0x1052,
    case Qt::Key_Super_L: return 0; // = 0x1053,        // extra keys
    case Qt::Key_Super_R: return 0; // = 0x1054,
    case Qt::Key_Menu: return 0; // = 0x1055,
    case Qt::Key_Hyper_L: return 0; // = 0x1056,
    case Qt::Key_Hyper_R: return 0; // = 0x1057,
    case Qt::Key_Help: return 0; // = 0x1058,
    case Qt::Key_Direction_L: return 0; // = 0x1059,
    case Qt::Key_Direction_R: return 0; // = 0x1060,

    // Latin 1 codes adapted from X: keysymdef.h,v 1.21 94/08/28 16:17:06
    case Qt::Key_nobreakspace: return char(0xa0);
    case Qt::Key_exclamdown: return char(0xa1);
    case Qt::Key_cent: return char(0xa2);
    case Qt::Key_sterling: return char(0xa3);
    case Qt::Key_currency: return char(0xa4);
    case Qt::Key_yen: return char(0xa5);
    case Qt::Key_brokenbar: return char(0xa6);
    case Qt::Key_section: return char(0xa7);
    case Qt::Key_diaeresis: return char(0xa8);
    case Qt::Key_copyright: return char(0xa9);
    case Qt::Key_ordfeminine: return char(0xaa);
    case Qt::Key_guillemotleft: return char(0xab); // left angle quotation mar
    case Qt::Key_notsign: return char(0xac);
    case Qt::Key_hyphen: return char(0xad);
    case Qt::Key_registered: return char(0xae);
    case Qt::Key_macron: return char(0xaf);
    case Qt::Key_degree: return char(0xb0);
    case Qt::Key_plusminus: return char(0xb1);
    case Qt::Key_twosuperior: return char(0xb2);
    case Qt::Key_threesuperior: return char(0xb3);
    case Qt::Key_acute: return char(0xb4);
    case Qt::Key_mu: return char(0xb5);
    case Qt::Key_paragraph: return char(0xb6);
    case Qt::Key_periodcentered: return char(0xb7);
    case Qt::Key_cedilla: return char(0xb8);
    case Qt::Key_onesuperior: return char(0xb9);
    case Qt::Key_masculine: return char(0xba);
    case Qt::Key_guillemotright: return char(0xbb); // right angle quotation mar
    case Qt::Key_onequarter: return char(0xbc);
    case Qt::Key_onehalf: return char(0xbd);
    case Qt::Key_threequarters: return char(0xbe);
    case Qt::Key_questiondown: return char(0xbf);
    case Qt::Key_Agrave: return char(0xc0);
    case Qt::Key_Aacute: return char(0xc1);
    case Qt::Key_Acircumflex: return char(0xc2);
    case Qt::Key_Atilde: return char(0xc3);
    case Qt::Key_Adiaeresis: return char(0xc4);
    case Qt::Key_Aring: return char(0xe5);
    case Qt::Key_AE: return char(0xe6);
    case Qt::Key_Ccedilla: return char(0xc7);
    case Qt::Key_Egrave: return char(0xc8);
    case Qt::Key_Eacute: return char(0xc9);
    case Qt::Key_Ecircumflex: return char(0xca);
    case Qt::Key_Ediaeresis: return char(0xcb);
    case Qt::Key_Igrave: return char(0xcc);
    case Qt::Key_Iacute: return char(0xcd);
    case Qt::Key_Icircumflex: return char(0xce);
    case Qt::Key_Idiaeresis: return char(0xcf);
    case Qt::Key_ETH: return char(0xd0);
    case Qt::Key_Ntilde: return char(0xd1);
    case Qt::Key_Ograve: return char(0xd2);
    case Qt::Key_Oacute: return char(0xd3);
    case Qt::Key_Ocircumflex: return char(0xd4);
    case Qt::Key_Otilde: return char(0xd5);
    case Qt::Key_Odiaeresis: return char(0xd6);
    case Qt::Key_multiply: return char(0xd7);
    case Qt::Key_Ooblique: return char(0xf8);
    case Qt::Key_Ugrave: return char(0xd9);
    case Qt::Key_Uacute: return char(0xda);
    case Qt::Key_Ucircumflex: return char(0xdb);
    case Qt::Key_Udiaeresis: return char(0xdc);
    case Qt::Key_Yacute: return char(0xdd);
    case Qt::Key_THORN: return char(0xde);
    case Qt::Key_ssharp: return char(0xdf);
    case Qt::Key_division: return char(0xf7);
    case Qt::Key_ydiaeresis: return char(0xff);

    // multimedia/internet keys - ignored by default - see QKeyEvent c'tor

    case Qt::Key_Back : return 0; // = 0x1061,
    case Qt::Key_Forward : return 0; // = 0x1062,
    case Qt::Key_Stop : return 0; // = 0x1063,
    case Qt::Key_Refresh : return 0; // = 0x1064,

    case Qt::Key_VolumeDown: return 0; // = 0x1070,
    case Qt::Key_VolumeMute : return 0; // = 0x1071,
    case Qt::Key_VolumeUp: return 0; // = 0x1072,
    case Qt::Key_BassBoost: return 0; // = 0x1073,
    case Qt::Key_BassUp: return 0; // = 0x1074,
    case Qt::Key_BassDown: return 0; // = 0x1075,
    case Qt::Key_TrebleUp: return 0; // = 0x1076,
    case Qt::Key_TrebleDown: return 0; // = 0x1077,

    case Qt::Key_MediaPlay : return 0; // = 0x1080,
    case Qt::Key_MediaStop : return 0; // = 0x1081,
    case Qt::Key_MediaPrevious : return 0; // = 0x1082,
    case Qt::Key_MediaNext : return 0; // = 0x1083,
    case Qt::Key_MediaRecord: return 0; // = 0x1084,

    case Qt::Key_HomePage : return 0; // = 0x1090,
    case Qt::Key_Favorites : return 0; // = 0x1091,
    case Qt::Key_Search : return 0; // = 0x1092,
    case Qt::Key_Standby: return 0; // = 0x1093,
    case Qt::Key_OpenUrl: return 0; // = 0x1094,

    case Qt::Key_LaunchMail : return 0; // = 0x10a0,
    case Qt::Key_LaunchMedia: return 0; // = 0x10a1,
    case Qt::Key_Launch0 : return 0; // = 0x10a2,
    case Qt::Key_Launch1 : return 0; // = 0x10a3,
    case Qt::Key_Launch2 : return 0; // = 0x10a4,
    case Qt::Key_Launch3 : return 0; // = 0x10a5,
    case Qt::Key_Launch4 : return 0; // = 0x10a6,
    case Qt::Key_Launch5 : return 0; // = 0x10a7,
    case Qt::Key_Launch6 : return 0; // = 0x10a8,
    case Qt::Key_Launch7 : return 0; // = 0x10a9,
    case Qt::Key_Launch8 : return 0; // = 0x10aa,
    case Qt::Key_Launch9 : return 0; // = 0x10ab,
    case Qt::Key_LaunchA : return 0; // = 0x10ac,
    case Qt::Key_LaunchB : return 0; // = 0x10ad,
    case Qt::Key_LaunchC : return 0; // = 0x10ae,
    case Qt::Key_LaunchD : return 0; // = 0x10af,
    case Qt::Key_LaunchE : return 0; // = 0x10b0,
    case Qt::Key_LaunchF : return 0; // = 0x10b1,

    default: QTEST_ASSERT(false); return 0;
    }
}

memberName()

static QByteArray QTest::memberName ( const QMetaMethod &  member )

static

Definition at line 67 of file qsignaldumper.cpp.

Referenced by QDBusConnectionPrivate::activateCall(), qSignalDumperCallback(), and QDBusConnectionPrivate::relaySignal().

{
    QByteArray ba = member.signature();
    return ba.left(ba.indexOf('('));
}

messageFormatString()

static const char* QTest::messageFormatString ( bool  noDescription, bool  noTag  )

static

Definition at line 194 of file qxmltestlogger.cpp.

Referenced by QXmlTestLogger::addMessage().

{
    if (noDescription) {
        if (noTag)
            return "<Message type=\"%s\" file=\"%s\" line=\"%d\" />\n";
        else
            return "<Message type=\"%s\" file=\"%s\" line=\"%d\">\n"
                "    <DataTag><![CDATA[%s%s%s%s]]></DataTag>\n"
                "</Message>\n";
    } else {
        if (noTag)
            return "<Message type=\"%s\" file=\"%s\" line=\"%d\">\n"
                "    <Description><![CDATA[%s%s%s%s]]></Description>\n"
                "</Message>\n";
        else
            return "<Message type=\"%s\" file=\"%s\" line=\"%d\">\n"
                "    <DataTag><![CDATA[%s%s%s]]></DataTag>\n"
                "    <Description><![CDATA[%s]]></Description>\n"
                "</Message>\n";
    }
}

messageHandler()

static void QTest::messageHandler ( QtMsgType  type, const char *  msg  )

static

Definition at line 121 of file qtestlog.cpp.

Referenced by QScriptDebuggerConsoleCommandJob::QScriptDebuggerConsoleCommandJob(), and QTestLog::startLogging().

    {
        static QBasicAtomicInt counter = Q_BASIC_ATOMIC_INITIALIZER(QTest::maxWarnings);

        if (!msg || !QTest::testLogger) {
            // if this goes wrong, something is seriously broken.
            qInstallMsgHandler(oldMessageHandler);
            QTEST_ASSERT(msg);
            QTEST_ASSERT(QTest::testLogger);
        }

        if (handleIgnoredMessage(type, msg))
            // the message is expected, so just swallow it.
            return;

        if (type != QtFatalMsg) {
            if (counter <= 0)
                return;

            if (!counter.deref()) {
                QTest::testLogger->addMessage(QAbstractTestLogger::QSystem,
                        "Maximum amount of warnings exceeded. Use -maxwarnings to override.");
                return;
            }
        }

        switch (type) {
        case QtDebugMsg:
            QTest::testLogger->addMessage(QAbstractTestLogger::QDebug, msg);
            break;
        case QtCriticalMsg:
            QTest::testLogger->addMessage(QAbstractTestLogger::QSystem, msg);
            break;
        case QtWarningMsg:
            QTest::testLogger->addMessage(QAbstractTestLogger::QWarning, msg);
            break;
        case QtFatalMsg:
            QTest::testLogger->addMessage(QAbstractTestLogger::QFatal, msg);
            /* Right now, we're inside the custom message handler and we're
             * being qt_message_output in qglobal.cpp. After we return from
             * this function, it will proceed with calling exit() and abort()
             * and hence crash. Therefore, we call these logging functions such
             * that we wrap up nicely, and in particular produce well-formed XML. */
            QTestResult::addFailure("Received a fatal error.", "Unknown file", 0);
            QTestLog::leaveTestFunction();
            QTestLog::stopLogging();
            break;
        }
    }

messageType2String()

static const char* QTest::messageType2String ( QAbstractTestLogger::MessageTypes  type )

static

Definition at line 131 of file qplaintestlogger.cpp.

Referenced by QPlainTestLogger::addMessage(), and QPlainTestLogger::enterTestFunction().

    {
#ifdef Q_OS_WIN
        static bool colored = (!qgetenv("QTEST_COLORED").isEmpty());
#else
        static bool colored = ::getenv("QTEST_COLORED");
#endif
        switch (type) {
        case QAbstractTestLogger::Skip:
            return COLORED_MSG(0, 37, "SKIP   "); //white
        case QAbstractTestLogger::Warn:
            return COLORED_MSG(0, 33, "WARNING"); // yellow
        case QAbstractTestLogger::QWarning:
            return COLORED_MSG(1, 33, "QWARN  ");
        case QAbstractTestLogger::QDebug:
            return COLORED_MSG(1, 33, "QDEBUG ");
        case QAbstractTestLogger::QSystem:
            return COLORED_MSG(1, 33, "QSYSTEM");
        case QAbstractTestLogger::QFatal:
            return COLORED_MSG(0, 31, "QFATAL "); // red
        case QAbstractTestLogger::Info:
            return "INFO   "; // no coloring
        }
        return "??????";
    }

mouseClick()

void QTest::mouseClick ( QWidget *  widget, Qt::MouseButton  button, Qt::KeyboardModifiers  modifier = 0, QPoint  pos = QPoint(), int  delay = -1  )

inline

Simulates clicking a mouse button with an optional modifier on a widget.

The position of the click is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before pressing and before releasing the button.

See also

QTest::mousePress(), QTest::mouseRelease()

Definition at line 135 of file qtestmouse.h.

    { mouseEvent(MouseClick, widget, button, stateKey, pos, delay); }

mouseDClick()

void QTest::mouseDClick ( QWidget *  widget, Qt::MouseButton  button, Qt::KeyboardModifiers  modifier = 0, QPoint  pos = QPoint(), int  delay = -1  )

inline

Simulates double clicking a mouse button with an optional modifier on a widget.

The position of the click is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before each press and release.

See also

QTest::mouseClick()

Definition at line 138 of file qtestmouse.h.

    { mouseEvent(MouseDClick, widget, button, stateKey, pos, delay); }

mouseEvent()

void QTest::mouseEvent ( MouseAction  action, QWidget *  widget, Qt::MouseButton  button, Qt::KeyboardModifiers  stateKey, QPoint  pos, int  delay = -1  )

static

Warning

This function is not part of the public interface.

Definition at line 71 of file qtestmouse.h.

Referenced by QStatusBar::event(), QGraphicsScene::event(), QWidget::event(), QMdiSubWindow::eventFilter(), mouseClick(), mouseDClick(), QGraphicsView::mouseDoubleClickEvent(), mouseMove(), QGraphicsViewPrivate::mouseMoveEventHandler(), mousePress(), QGraphicsView::mousePressEvent(), mouseRelease(), QGraphicsView::mouseReleaseEvent(), QGraphicsItemPrivate::remapItemPos(), QDeclarativePathView::sendMouseEvent(), QDeclarativeMouseArea::sendMouseEvent(), QDeclarativeFlickable::sendMouseEvent(), QDeclarativePinchArea::sendMouseEvent(), QDeclarativeTextInputPrivate::sendMouseEventToInputContext(), QGraphicsProxyWidgetPrivate::sendWidgetMouseEvent(), and QTestEvent::~QTestEvent().

    {
        QTEST_ASSERT(widget);
        extern int Q_TESTLIB_EXPORT defaultMouseDelay();

        if (delay == -1 || delay < defaultMouseDelay())
            delay = defaultMouseDelay();
        if(delay > 0)
            QTest::qWait(delay);

        if (pos.isNull())
            pos = widget->rect().center();

        if (action == MouseClick) {
            mouseEvent(MousePress, widget, button, stateKey, pos);
            mouseEvent(MouseRelease, widget, button, stateKey, pos);
            return;
        }

        QTEST_ASSERT(button == Qt::NoButton || button & Qt::MouseButtonMask);
        QTEST_ASSERT(stateKey == 0 || stateKey & Qt::KeyboardModifierMask);

        stateKey &= static_cast<unsigned int>(Qt::KeyboardModifierMask);

        QMouseEvent me(QEvent::User, QPoint(), Qt::LeftButton, button, stateKey);
        switch (action)
        {
            case MousePress:
                me = QMouseEvent(QEvent::MouseButtonPress, pos, widget->mapToGlobal(pos), button, button, stateKey);
                break;
            case MouseRelease:
                me = QMouseEvent(QEvent::MouseButtonRelease, pos, widget->mapToGlobal(pos), button, 0, stateKey);
                break;
            case MouseDClick:
                me = QMouseEvent(QEvent::MouseButtonDblClick, pos, widget->mapToGlobal(pos), button, button, stateKey);
                break;
            case MouseMove:
                QCursor::setPos(widget->mapToGlobal(pos));
#ifdef QT_MAC_USE_COCOA
                QTest::qWait(20);
#else
                qApp->processEvents();
#endif
                return;
            default:
                QTEST_ASSERT(false);
        }
        QSpontaneKeyEvent::setSpontaneous(&me);
        if (!qApp->notify(widget, &me)) {
            static const char *mouseActionNames[] =
                { "MousePress", "MouseRelease", "MouseClick", "MouseDClick", "MouseMove" };
            QString warning = QString::fromLatin1("Mouse event \"%1\" not accepted by receiving widget");
            QTest::qWarn(warning.arg(QString::fromLatin1(mouseActionNames[static_cast<int>(action)])).toAscii().data());
        }

    }

mouseMove()

void QTest::mouseMove ( QWidget *  widget, QPoint  pos = QPoint(), int  delay = -1  )

inline

Moves the mouse pointer to a widget.

If pos is not specified, the mouse pointer moves to the center of the widget. If a delay (in milliseconds) is given, the test will wait before moving the mouse pointer.

Definition at line 141 of file qtestmouse.h.

    { mouseEvent(MouseMove, widget, Qt::NoButton, 0, pos, delay); }

mousePress()

void QTest::mousePress ( QWidget *  widget, Qt::MouseButton  button, Qt::KeyboardModifiers  modifier = 0, QPoint  pos = QPoint(), int  delay = -1  )

inline

Simulates pressing a mouse button with an optional modifier on a widget.

The position is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before the press.

See also

QTest::mouseRelease(), QTest::mouseClick()

Definition at line 129 of file qtestmouse.h.

    { mouseEvent(MousePress, widget, button, stateKey, pos, delay); }

mouseRelease()

void QTest::mouseRelease ( QWidget *  widget, Qt::MouseButton  button, Qt::KeyboardModifiers  modifier = 0, QPoint  pos = QPoint(), int  delay = -1  )

inline

Simulates releasing a mouse button with an optional modifier on a widget.

The position of the release is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before releasing the button.

See also

QTest::mousePress(), QTest::mouseClick()

Definition at line 132 of file qtestmouse.h.

    { mouseEvent(MouseRelease, widget, button, stateKey, pos, delay); }

newRow()

QTestData & QTest::newRow

(

const char *

dataTag

)

Appends a new row to the current test data.

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:

void myTestFunction_data()
{
    QTest::addColumn<QString>("aString");
    QTest::newRow("just hello") << QString("hello");
    QTest::newRow("a null string") << QString();
}

Note: This macro can only be used in a test's data function that is invoked by the test framework.

See Chapter 2: Data Driven Testing a more extensive example.

See also

addColumn(), QFETCH()

Definition at line 2183 of file qtestcase.cpp.

Referenced by addColumn(), QListModel::ensureSorted(), QTreeModel::ensureSorted(), QTableModel::ensureSorted(), QTextControlPrivate::gotoNextTableCell(), QTextControlPrivate::gotoPreviousTableCell(), QAbstractItemView::keyboardSearch(), QTableView::moveCursor(), and QTableModel::updateRowIndexes().

{
    QTestTable *tbl = QTestTable::currentTestTable();
    QTEST_ASSERT_X(tbl, "QTest::addColumn()", "Cannot add testdata outside of a _data slot.");

    return *tbl->newData(dataTag);
}

outputMessage()

static void QTest::outputMessage ( const char *  str )

static

Definition at line 157 of file qplaintestlogger.cpp.

Referenced by printBenchmarkResult(), printMessage(), QPlainTestLogger::startLogging(), and QPlainTestLogger::stopLogging().

    {
#if defined(Q_OS_WINCE)
        QString strUtf16 = QString::fromLatin1(str);
        const int maxOutputLength = 255;
        do {
            QString tmp = strUtf16.left(maxOutputLength);
            OutputDebugString((wchar_t*)tmp.utf16());
            strUtf16.remove(0, maxOutputLength);
        } while (!strUtf16.isEmpty());
        if (QTestLog::outputFileName())
#elif defined(Q_OS_WIN)
        EnterCriticalSection(&outputCriticalSection);
        // OutputDebugString is not threadsafe
        OutputDebugStringA(str);
        LeaveCriticalSection(&outputCriticalSection);
#elif defined(Q_OS_SYMBIAN)
        // RDebug::Print has a cap of 256 characters so break it up
        TPtrC8 ptr(reinterpret_cast<const TUint8*>(str));
        _LIT(format, "[QTestLib] %S");
        const int maxBlockSize = 256 - ((const TDesC &)format).Length();
        HBufC* hbuffer = HBufC::New(maxBlockSize);
        if(hbuffer) {
            for (int i = 0; i < ptr.Length(); i += maxBlockSize) {
                int size = Min(maxBlockSize, ptr.Length() - i);
                hbuffer->Des().Copy(ptr.Mid(i, size));
                RDebug::Print(format, hbuffer);
            }
            delete hbuffer;
        }
        else {
            // fast, no allocations, but truncates silently
            RDebug::RawPrint(format);
            TPtrC8 ptr(reinterpret_cast<const TUint8*>(str));
            RDebug::RawPrint(ptr);
            RDebug::RawPrint(_L8("\n"));
        }
#endif
        QAbstractTestLogger::outputString(str);
    }

printBenchmarkResult()

static void QTest::printBenchmarkResult ( const QBenchmarkResult &  result )

static

Definition at line 318 of file qplaintestlogger.cpp.

Referenced by QPlainTestLogger::addBenchmarkResult().

    {
        const char *bmtag = QTest::benchmarkResult2String();

        char buf1[1024];
        QTest::qt_snprintf(
            buf1, sizeof(buf1), "%s: %s::%s",
            bmtag,
            QTestResult::currentTestObjectName(),
            result.context.slotName.toAscii().data());

        char bufTag[1024];
        bufTag[0] = 0;
        QByteArray tag = result.context.tag.toAscii();
        if (tag.isEmpty() == false) {
            QTest::qt_snprintf(bufTag, sizeof(bufTag), ":\"%s\"", tag.data());
        }


        char fillFormat[8];
        int fillLength = 5;
        QTest::qt_snprintf(
            fillFormat, sizeof(fillFormat), ":\n%%%ds", fillLength);
        char fill[1024];
        QTest::qt_snprintf(fill, sizeof(fill), fillFormat, "");

        const char * unitText = QTest::benchmarkMetricUnit(result.metric);

        qreal valuePerIteration = qreal(result.value) / qreal(result.iterations);
        char resultBuffer[100] = "";
        formatResult(resultBuffer, 100, valuePerIteration, countSignificantDigits(result.value));

        char buf2[1024];
        QTest::qt_snprintf(
            buf2, sizeof(buf2), "%s %s",
            resultBuffer,
            unitText);

        char buf2_[1024];
        QByteArray iterationText = " per iteration";
        Q_ASSERT(result.iterations > 0);
        QTest::qt_snprintf(
            buf2_,
            sizeof(buf2_), "%s",
            iterationText.data());

        char buf3[1024];
        Q_ASSERT(result.iterations > 0);
        formatResult(resultBuffer, 100, result.value, countSignificantDigits(result.value));
        QTest::qt_snprintf(
            buf3, sizeof(buf3), " (total: %s, iterations: %d)",
            resultBuffer,
            result.iterations);

        char buf[1024];

        if (result.setByMacro) {
            QTest::qt_snprintf(
                buf, sizeof(buf), "%s%s%s%s%s%s\n", buf1, bufTag, fill, buf2, buf2_, buf3);
        } else {
            QTest::qt_snprintf(buf, sizeof(buf), "%s%s%s%s\n", buf1, bufTag, fill, buf2);
        }

        memcpy(buf, bmtag, strlen(bmtag));
        outputMessage(buf);
    }

printMessage()

static void QTest::printMessage ( const char *  type, const char *  msg, const char *  file = 0, int  line = 0  )

static

Definition at line 198 of file qplaintestlogger.cpp.

Referenced by QPlainTestLogger::addIncident(), QPlainTestLogger::addMessage(), and QPlainTestLogger::enterTestFunction().

    {
        QTEST_ASSERT(type);
        QTEST_ASSERT(msg);

        QTestCharBuffer buf;

        const char *fn = QTestResult::currentTestFunction() ? QTestResult::currentTestFunction()
            : "UnknownTestFunc";
        const char *tag = QTestResult::currentDataTag() ? QTestResult::currentDataTag() : "";
        const char *gtag = QTestResult::currentGlobalDataTag()
                         ? QTestResult::currentGlobalDataTag()
                         : "";
        const char *filler = (tag[0] && gtag[0]) ? ":" : "";
        if (file) {
            QTest::qt_asprintf(&buf, "%s: %s::%s(%s%s%s)%s%s\n"
#ifdef Q_OS_WIN
                          "%s(%d) : failure location\n"
#else
                          "   Loc: [%s(%d)]\n"
#endif
                          , type, QTestResult::currentTestObjectName(), fn, gtag, filler, tag,
                          msg[0] ? " " : "", msg, file, line);
        } else {
            QTest::qt_asprintf(&buf, "%s: %s::%s(%s%s%s)%s%s\n",
                    type, QTestResult::currentTestObjectName(), fn, gtag, filler, tag,
                    msg[0] ? " " : "", msg);
        }
        // In colored mode, printf above stripped our nonprintable control characters.
        // Put them back.
        memcpy(buf.data(), type, strlen(type));
        outputMessage(buf.data());
    }

qCompare() [1/16]

template<>

bool QTest::qCompare ( QIcon const &  t1, QIcon const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 78 of file qtest_gui.h.

{
    QTEST_ASSERT(sizeof(QIcon) == sizeof(void *));
    return qCompare<void *>(*reinterpret_cast<void * const *>(&t1),
                   *reinterpret_cast<void * const *>(&t2), actual, expected, file, line);
}

qCompare() [2/16]

template<>

bool QTest::qCompare ( QPixmap const &  t1, QPixmap const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 87 of file qtest_gui.h.

{
    return qCompare(t1.toImage(), t2.toImage(), actual, expected, file, line);
}

qCompare() [3/16]

template<typename T >

bool QTest::qCompare ( T const &  t1, T const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 175 of file qtestcase.h.

    {
        return (t1 == t2)
            ? compare_helper(true, "COMPARE()", file, line)
            : compare_helper(false, "Compared values are not the same",
                             toString<T>(t1), toString<T>(t2), actual, expected, file, line);
    }

qCompare() [4/16]

template<>

bool QTest::qCompare ( QString const &  t1, QLatin1String const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 177 of file qtest.h.

Referenced by compare_ptr_helper(), qCompare(), qCompare< char >(), and qTest().

{
    return qCompare<QString>(t1, QString(t2), actual, expected, file, line);
}

qCompare() [5/16]

template<>

bool QTest::qCompare ( QLatin1String const &  t1, QString const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 185 of file qtest.h.

{
    return qCompare<QString>(QString(t1), t2, actual, expected, file, line);
}

qCompare() [6/16]

template<>

bool QTest::qCompare ( QStringList const &  t1, QStringList const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 192 of file qtest.h.

{
    char msg[1024];
    msg[0] = '\0';
    bool isOk = true;
    if (t1.count() != t2.count()) {
        qt_snprintf(msg, 1024, "Compared QStringLists have different sizes.\n"
                    "   Actual (%s) size  : '%d'\n"
                    "   Expected (%s) size: '%d'", actual, t1.count(), expected, t2.count());
        isOk = false;
    }
    const int min = qMin(t1.count(), t2.count());
    for (int i = 0; isOk && i < min; ++i) {
        if (t1.at(i) != t2.at(i)) {
            qt_snprintf(msg, 1024, "Compared QStringLists differ at index %d.\n"
                        "   Actual (%s) : '%s'\n"
                        "   Expected (%s) : '%s'", i, actual, t1.at(i).toLatin1().constData(),
                        expected, t2.at(i).toLatin1().constData());
            isOk = false;
        }
    }
    return compare_helper(isOk, msg, file, line);
}

qCompare() [7/16]

template<typename T >

bool QTest::qCompare ( QFlags< T > const &  t1, T const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 218 of file qtest.h.

{
    return qCompare(int(t1), int(t2), actual, expected, file, line);
}

qCompare() [8/16]

template<typename T1 , typename T2 >

bool QTest::qCompare	(	T1 const &	,
		T2 const &	,
		const char *	,
		const char *	,
		const char *	,
		int
	)

Warning

This function is not part of the public interface.

qCompare() [9/16]

template<typename T >

bool QTest::qCompare ( QFlags< T > const &  t1, int const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 225 of file qtest.h.

{
    return qCompare(int(t1), t2, actual, expected, file, line);
}

qCompare() [10/16]

template<typename T >

bool QTest::qCompare ( const T *  t1, const T *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 258 of file qtestcase.h.

    {
        return compare_ptr_helper(t1, t2, actual, expected, file, line);
    }

qCompare() [11/16]

template<typename T >

bool QTest::qCompare ( T *  t1, T *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 264 of file qtestcase.h.

    {
        return compare_ptr_helper(t1, t2, actual, expected, file, line);
    }

qCompare() [12/16]

template<typename T1 , typename T2 >

bool QTest::qCompare ( const T1 *  t1, const T2 *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 271 of file qtestcase.h.

    {
        return compare_ptr_helper(t1, static_cast<const T1 *>(t2), actual, expected, file, line);
    }

qCompare() [13/16]

template<typename T1 , typename T2 >

bool QTest::qCompare ( T1 *  t1, T2 *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 277 of file qtestcase.h.

    {
        return compare_ptr_helper(const_cast<const T1 *>(t1),
                static_cast<const T1 *>(const_cast<const T2 *>(t2)), actual, expected, file, line);
    }

qCompare() [14/16]

template<>

bool QTest::qCompare ( char *  t1, const char *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 337 of file qtestcase.h.

    {
        return compare_string_helper(t1, t2, actual, expected, file, line);
    }

qCompare() [15/16]

template<>

bool QTest::qCompare ( const char *  t1, char *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 345 of file qtestcase.h.

    {
        return compare_string_helper(t1, t2, actual, expected, file, line);
    }

qCompare() [16/16]

template<>

bool QTest::qCompare ( bool const &  t1, int const &  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 355 of file qtestcase.h.

    {
        return qCompare<int>(int(t1), t2, actual, expected, file, line);
    }

qCompare< char >() [1/2]

template<>

bool QTest::qCompare< char > ( const char *  t1, const char *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Definition at line 284 of file qtestcase.h.

    {
        return compare_string_helper(t1, t2, actual, expected, file, line);
    }

qCompare< char >() [2/2]

template<>

bool QTest::qCompare< char > ( char *  t1, char *  t2, const char *  actual, const char *  expected, const char *  file, int  line  )

inline

Definition at line 290 of file qtestcase.h.

    {
        return compare_string_helper(t1, t2, actual, expected, file, line);
    }

qCompare< double >()

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
	)

Warning

This function is not part of the public interface.

Definition at line 2320 of file qtestcase.cpp.

Referenced by qCompare().

{
    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);
}

qCompare< float >()

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
	)

Warning

This function is not part of the public interface.

Definition at line 2307 of file qtestcase.cpp.

Referenced by compare_ptr_helper(), qCompare(), and qCompare< char >().

{
    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);
}

qData()

void * QTest::qData	(	const char *	tagName,
		int	typeId
	)

Warning

This function is not part of the public interface.

Definition at line 2130 of file qtestcase.cpp.

Referenced by toString().

{
    return fetchData(QTestResult::currentTestData(), tagName, typeId);
}

qElementData()

void * QTest::qElementData	(	const char *	tagName,
		int	metaTypeId
	)

Warning

This function is not part of the public interface.

Definition at line 2144 of file qtestcase.cpp.

Referenced by qTest(), and toString().

{
    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));
}

qExec() [1/2]

int QTest::qExec	(	QObject *	testObject,
		int	argc = 0,
		char **	argv = 0
	)

Executes tests declared in testObject.

In addition, the private slots initTestCase(), cleanupTestCase(), init() and cleanup() are executed if they exist. See Creating a Test for more details.

Optionally, the command line arguments argc and argv can be provided. For a list of recognized arguments, read QTestLib Command Line Arguments.

For stand-alone tests, the convenience macro 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 QTEST_MAIN() macro is used.

The following example will run all tests in MyFirstTestObject and MySecondTestObject:

MyFirstTestObject test1;
QTest::qExec(&test1);

MySecondTestObject test2;
QTest::qExec(&test2);

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 main(), it is likely of interest to use QTest::qExec(QObject *, const QStringList &) since it is Unicode safe.

See also

QTEST_MAIN()

Definition at line 1913 of file qtestcase.cpp.

Referenced by qExec(), and toString().

{
    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());
    if (argc > 0)
        QTestResult::setCurrentAppName(argv[0]);

    qtest_qParseArgs(argc, argv, false);
    if (QTest::randomOrder) {
        seedRandom();
    }
#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)
        QScopedPointer<FatalSignalHandler> handler;
        if (!noCrashHandler)
            handler.reset(new FatalSignalHandler);
#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
         currentTestObject = 0;

         // Rethrow exception to make debugging easier.
         throw;
         return 1;
     }
#  endif

    currentTestObject = 0;
#ifdef QT_MAC_USE_COCOA
     if (macNeedsActivate) {
         IOPMAssertionRelease(powerID);
     }
#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
}

qExec() [2/2]

int QTest::qExec	(	QObject *	testObject,
		const QStringList &	arguments
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.4

Behaves identically to qExec(QObject *, int, char**) but takes a QStringList of arguments instead of a char** list.

Definition at line 2048 of file qtestcase.cpp.

{
    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());
}

qExpectFail()

bool QTest::qExpectFail	(	const char *	dataIndex,
		const char *	comment,
		QTest::TestFailMode	mode,
		const char *	file,
		int	line
	)

Warning

This function is not part of the public interface.

Definition at line 2094 of file qtestcase.cpp.

Referenced by toString().

{
    return QTestResult::expectFail(dataIndex, qstrdup(comment), mode, file, line);
}

qFail()

void QTest::qFail	(	const char *	statementStr,
		const char *	file,
		int	line
	)

Warning

This function is not part of the public interface.

Definition at line 2067 of file qtestcase.cpp.

Referenced by toString().

{
    QTestResult::addFailure(statementStr, file, line);
}

qGlobalData()

void * QTest::qGlobalData	(	const char *	tagName,
		int	typeId
	)

Warning

This function is not part of the public interface.

Definition at line 2137 of file qtestcase.cpp.

Referenced by toString().

{
    return fetchData(QTestResult::currentGlobalTestData(), tagName, typeId);
}

qInvokeTestMethod()

static bool QTest::qInvokeTestMethod ( const char *  slotName, const char *  data = 0  )

static

Call init(), slot_data(), slot(), slot(), slot().

Warning

This function is not part of the public interface.

.., 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.

Definition at line 1540 of file qtestcase.cpp.

Referenced by qInvokeTestMethods().

{
    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);
            invokeMethod(QTest::currentTestObject, member);

            // 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);

            // Data tag requested but none available?
            if (data && !dataCount) {
                // Let empty data tag through.
                if (!*data)
                    data = 0;
                else {
                    printf("Unknown testdata for function %s: '%s'\n", slotName, data);
                    printf("Function has no testdata.\n");
                    return false;
                }
            }

            /* For each entry in the data table, do: */
            do {
                if (!data || !qstrcmp(data, table.testData(curDataIndex)->dataTag())) {
                    foundFunction = true;
                    QTestDataSetter s(curDataIndex >= dataCount ? 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;
}

qInvokeTestMethodDataEntry()

static void QTest::qInvokeTestMethodDataEntry ( char *  slot )

static

Definition at line 1463 of file qtestcase.cpp.

Referenced by qInvokeTestMethod().

{
    /* 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);
            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);
            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));
}

qInvokeTestMethods()

static void QTest::qInvokeTestMethods ( QObject *  testObject )

static

Definition at line 1724 of file qtestcase.cpp.

Referenced by qExec().

{
    const QMetaObject *metaObject = testObject->metaObject();
    QTEST_ASSERT(metaObject);
    if (QTest::randomOrder) {
        QTestLog::startLogging(QTest::seed);
    } else {
        QTestLog::startLogging();
    }
    QTestResult::setCurrentTestFunction("initTestCase");
    QTestResult::setCurrentTestLocation(QTestResult::DataFunc);
    QTestTable::globalTestTable();
    invokeMethod(testObject, "initTestCase_data()");

    if (!QTestResult::skipCurrentTest() && !QTest::currentTestFailed()) {
        QTestResult::setCurrentTestLocation(QTestResult::InitFunc);
        invokeMethod(testObject, "initTestCase()");

        // finishedCurrentTestFunction() resets QTestResult::testFailed(), so use a local copy.
        const bool previousFailed = QTestResult::testFailed();
        QTestResult::finishedCurrentTestFunction();

        if(!QTestResult::skipCurrentTest() && !previousFailed) {

            if (QTest::testFuncs) {
                if (QTest::randomOrder)
                    randomizeList(QTest::testFuncs, QTest::testFuncCount);
                for (int i = 0; i != QTest::testFuncCount; i++) {
                    if (!qInvokeTestMethod(metaObject->method(QTest::testFuncs[i].function()).signature(),
                                                              QTest::testFuncs[i].data())) {
                        break;
                    }
                }
                testFuncCleaner.cleanup();
            } else {
                int methodCount = metaObject->methodCount();
                QMetaMethod *testMethods = new QMetaMethod[methodCount];
                for (int i = 0; i != methodCount; i++)
                    testMethods[i] = metaObject->method(i);
                if (QTest::randomOrder)
                    randomizeList(testMethods, methodCount);
                for (int i = 0; i != methodCount; i++) {
                    if (!isValidSlot(testMethods[i]))
                        continue;
                    if (!qInvokeTestMethod(testMethods[i].signature()))
                        break;
                }
                delete[] testMethods;
                testMethods = 0;
            }
        }

        QTestResult::setSkipCurrentTest(false);
        QTestResult::setCurrentTestFunction("cleanupTestCase");
        invokeMethod(testObject, "cleanupTestCase()");
    }
    QTestResult::finishedCurrentTestFunction();
    QTestResult::setCurrentTestFunction(0);
    QTestTable::clearGlobalTestTable();

    QTestLog::stopLogging();
}

qMedian()

QBenchmarkResult QTest::qMedian

(

const QList< QBenchmarkResult > &

container

)

Definition at line 1433 of file qtestcase.cpp.

Referenced by qInvokeTestMethodDataEntry().

{
    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);
}

qPrintDataTags()

static void QTest::qPrintDataTags ( )

static

Definition at line 1100 of file qtestcase.cpp.

Referenced by qtest_qParseArgs().

{
    // Get global data tags:
    QTestTable::globalTestTable();
    invokeMethod(QTest::currentTestObject, "initTestCase_data()");
    const QTestTable *gTable = QTestTable::globalTestTable();

    const QMetaObject *currTestMetaObj = QTest::currentTestObject->metaObject();

    // Process test functions:
    for (int i = 0; i < currTestMetaObj->methodCount(); ++i) {
        QMetaMethod tf = currTestMetaObj->method(i);
        if (isValidSlot(tf)) {
            // Retrieve local tags:
            QStringList localTags;
            QTestTable table;
            char member[512];
            char *slot = qstrdup(tf.signature());
            slot[strlen(slot) - 2] = '\0';
            QTest::qt_snprintf(member, 512, "%s_data()", slot);
            invokeMethod(QTest::currentTestObject, member);
            for (int j = 0; j < table.dataCount(); ++j)
                localTags << QLatin1String(table.testData(j)->dataTag());

            // Print all tag combinations:
            if (gTable->dataCount() == 0) {
                if (localTags.count() == 0) {
                    // No tags at all, so just print the test function:
                    printf("%s %s\n", currTestMetaObj->className(), slot);
                } else {
                    // Only local tags, so print each of them:
                    for (int k = 0; k < localTags.size(); ++k)
                        printf(
                            "%s %s %s\n",
                            currTestMetaObj->className(), slot, localTags.at(k).toLatin1().data());
                }
            } else {
                for (int j = 0; j < gTable->dataCount(); ++j) {
                    if (localTags.count() == 0) {
                        // Only global tags, so print the current one:
                        printf(
                            "%s %s __global__ %s\n",
                            currTestMetaObj->className(), slot, gTable->testData(j)->dataTag());
                    } else {
                        // Local and global tags, so print each of the local ones and
                        // the current global one:
                        for (int k = 0; k < localTags.size(); ++k)
                            printf(
                                "%s %s %s __global__ %s\n", currTestMetaObj->className(), slot,
                                localTags.at(k).toLatin1().data(), gTable->testData(j)->dataTag());
                    }
                }
            }

            delete[] slot;
        }
    }
}

qPrintMessage()

static void QTest::qPrintMessage ( const QByteArray &  ba )

inlinestatic

Definition at line 57 of file qsignaldumper.cpp.

Referenced by qSignalDumperCallback(), and qSignalDumperCallbackSlot().

{
    QTestLog::info(ba.constData(), 0, 0);
}

qPrintTestSlots()

static void QTest::qPrintTestSlots ( )

static

Definition at line 1091 of file qtestcase.cpp.

Referenced by qtest_qParseArgs().

{
    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());
    }
}

qSignalDumperCallback()

static void QTest::qSignalDumperCallback ( QObject *  caller, int  method_index, void **  argv  )

static

Definition at line 73 of file qsignaldumper.cpp.

Referenced by QSignalDumper::startDump().

{
    Q_ASSERT(caller); Q_ASSERT(argv); Q_UNUSED(argv);
    const QMetaObject *mo = caller->metaObject();
    Q_ASSERT(mo);
    QMetaMethod member = mo->method(method_index);
    Q_ASSERT(member.signature());

    if (QTest::ignoreClasses() && QTest::ignoreClasses()->contains(mo->className())) {
        ++QTest::ignoreLevel;
        return;
    }

    QByteArray str;
    str.fill(' ', QTest::iLevel++ * QTest::IndentSpacesCount);
    str += "Signal: ";
    str += mo->className();
    str += '(';

    QString objname = caller->objectName();
    str += objname.toLocal8Bit();
    if (!objname.isEmpty())
        str += ' ';
    str += QByteArray::number(quintptr(caller), 16);

    str += ") ";
    str += QTest::memberName(member);
    str += " (";

    QList<QByteArray> args = member.parameterTypes();
    for (int i = 0; i < args.count(); ++i) {
        const QByteArray &arg = args.at(i);
        int typeId = QMetaType::type(args.at(i).constData());
        if (arg.endsWith('*') || arg.endsWith('&')) {
            str += '(';
            str += arg;
            str += ')';
            if (arg.endsWith('&'))
                str += '@';

            quintptr addr = quintptr(*reinterpret_cast<void **>(argv[i + 1]));
            str.append(QByteArray::number(addr, 16));
        } else if (typeId != QMetaType::Void) {
            str.append(arg)
                .append('(')
                .append(QVariant(typeId, argv[i + 1]).toString().toLocal8Bit())
                .append(')');
        }
        str.append(", ");
    }
    if (str.endsWith(", "))
        str.chop(2);
    str.append(')');
    qPrintMessage(str);
}

qSignalDumperCallbackEndSignal()

static void QTest::qSignalDumperCallbackEndSignal ( QObject *  caller, int    )

static

Definition at line 159 of file qsignaldumper.cpp.

Referenced by QSignalDumper::startDump().

{
    Q_ASSERT(caller); Q_ASSERT(caller->metaObject());
    if (QTest::ignoreClasses()
            && QTest::ignoreClasses()->contains(caller->metaObject()->className())) {
        --QTest::ignoreLevel;
        Q_ASSERT(QTest::ignoreLevel >= 0);
        return;
    }
    --QTest::iLevel;
    Q_ASSERT(QTest::iLevel >= 0);
}

qSignalDumperCallbackSlot()

static void QTest::qSignalDumperCallbackSlot ( QObject *  caller, int  method_index, void **  argv  )

static

Definition at line 129 of file qsignaldumper.cpp.

Referenced by QSignalDumper::startDump().

{
    Q_ASSERT(caller); Q_ASSERT(argv); Q_UNUSED(argv);
    const QMetaObject *mo = caller->metaObject();
    Q_ASSERT(mo);
    QMetaMethod member = mo->method(method_index);
    if (!member.signature())
        return;

    if (QTest::ignoreLevel ||
            (QTest::ignoreClasses() && QTest::ignoreClasses()->contains(mo->className())))
        return;

    QByteArray str;
    str.fill(' ', QTest::iLevel * QTest::IndentSpacesCount);
    str += "Slot: ";
    str += mo->className();
    str += '(';

    QString objname = caller->objectName();
    str += objname.toLocal8Bit();
    if (!objname.isEmpty())
        str += ' ';
    str += QByteArray::number(quintptr(caller), 16);

    str += ") ";
    str += member.signature();
    qPrintMessage(str);
}

qSkip()

void QTest::qSkip	(	const char *	message,
		QTest::SkipMode	mode,
		const char *	file,
		int	line
	)

Warning

This function is not part of the public interface.

Definition at line 2083 of file qtestcase.cpp.

Referenced by toString().

{
    QTestResult::addSkip(message, mode, file, line);
    if (mode == QTest::SkipAll)
        QTestResult::setSkipCurrentTest(true);
}

qSleep()

void QTest::qSleep

(

int

ms

)

Sleeps for 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 qWait() to do non-blocking sleeping.

ms must be greater than 0.

Note: The qSleep() function calls either nanosleep() on unix or Sleep() on windows, so the accuracy of time spent in qSleep() depends on the operating system.

Example:

QTest::qSleep(250);

See also

qWait()

Definition at line 2269 of file qtestcase.cpp.

Referenced by qExec(), qWait(), and toString().

{
    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
}

qt_asprintf()

int QTest::qt_asprintf	(	QTestCharBuffer *	str,
		const char *	format,
			...
	)

Warning

This function is not part of the public interface.

Definition at line 129 of file qabstracttestlogger.cpp.

Referenced by QXmlTestLogger::addBenchmarkResult(), QXmlTestLogger::addIncident(), QXmlTestLogger::addMessage(), QTestLogger::addTag(), QXmlTestLogger::enterTestFunction(), QTestXunitStreamer::formatAfterAttributes(), QTestXunitStreamer::formatAttributes(), QTestLightXmlStreamer::formatBeforeAttributes(), QTestXunitStreamer::formatEnd(), QTestXmlStreamer::formatEnd(), QTestLightXmlStreamer::formatEnd(), QTestXunitStreamer::formatStart(), QTestXmlStreamer::formatStart(), QTestLightXmlStreamer::formatStart(), QTestLightXmlStreamer::output(), QTestXmlStreamer::output(), printMessage(), and QXmlTestLogger::startLogging().

{
    static const int MAXSIZE = 1024*1024*2;

    Q_ASSERT(str);

    int size = str->size();

    va_list ap;
    int res = 0;

    for (;;) {
        va_start(ap, format);
        res = qvsnprintf(str->data(), size, format, ap);
        va_end(ap);
        str->data()[size - 1] = '\0';
        if (res >= 0 && res < size) {
            // We succeeded
            break;
        }
        // buffer wasn't big enough, try again.
        // Note, we're assuming that a result of -1 is always due to running out of space.
        size *= 2;
        if (size > MAXSIZE) {
            break;
        }
        if (!str->reset(size))
            break; // out of memory - take what we have
    }

    filter_unprintable(str->data());

    return res;
}

qt_snprintf()

int QTest::qt_snprintf	(	char *	str,
		int	size,
		const char *	format,
			...
	)

Warning

This function is not part of the public interface.

Definition at line 961 of file qtestcase.cpp.

Referenced by QTestLogger::addBenchmarkResult(), QTestLogger::addIncident(), QTestLogger::addMessage(), QTestResult::compare(), QTestLogger::enterTestFunction(), QTestFileLogger::init(), printBenchmarkResult(), QTestLog::printUnhandledIgnoreMessages(), qCompare(), qInvokeTestMethod(), qPrintDataTags(), qtest_qParseArgs(), QPlainTestLogger::startLogging(), QPlainTestLogger::stopLogging(), QTestLogger::stopLogging(), toString(), and QTestResult::verify().

{
    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;
}

qTest()

template<class T >

bool QTest::qTest ( const T &  actual, const char *  elementName, const char *  actualStr, const char *  expected, const char *  file, int  line  )

inline

Warning

This function is not part of the public interface.

Definition at line 363 of file qtestcase.h.

    {
        return qCompare(actual, *static_cast<const T *>(QTest::qElementData(elementName,
                       qMetaTypeId<T>())), actualStr, expected, file, line);
    }

qtest_qParseArgs()

Q_TESTLIB_EXPORT void QTest::qtest_qParseArgs	(	int	argc,
		char *	argv[],
		bool	qml
	)

Definition at line 1170 of file qtestcase.cpp.

Referenced by qExec().

{
    const char *testOptions =
         " options:\n"
         " -functions : Returns a list of current testfunctions\n"
         " -datatags  : Returns a list of current data tags.\n"
         "              A global data tag is preceded by ' __global__ '.\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 results\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"
         " -random    : Run testcases within each test in random order\n"
         " -seed n    : Positive integer to be used as seed for -random. If not specified,\n"
         "              the current time will be used as seed.\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"
#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
         " -nocrashhandler   : Disables the crash handler\n"
#endif
         "\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"
         "\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) {
            if (qml) {
                QTest::printAvailableFunctions = true;
            } else {
                qPrintTestSlots();
                exit(0);
            }
        } else if (strcmp(argv[i], "-datatags") == 0) {
            QTest::printAvailableTags = true;
            if (!qml) {
                qPrintDataTags();
                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]));
            }
#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
        } else if (strcmp(argv[i], "-nocrashhandler") == 0) {
            QTest::noCrashHandler = true;
#endif
        } 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], "-random") == 0) {
            QTest::randomOrder = true;
        } else if (strcmp(argv[i], "-seed") == 0) {
            bool argumentOk = false;
            if (i + 1 < argc) {
                char * endpt = 0;
                long longSeed = strtol(argv[++i], &endpt, 10);
                argumentOk = (*endpt == '\0' && longSeed >= 0);
                QTest::seed = longSeed;
            }
            if (!argumentOk) {
                printf("-seed needs an extra positive integer parameter to specify the seed\n");
                exit(1);
            } else {
                QTest::seedSet = true;
            }
        } 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;
        } else if (strcmp(argv[i], "-chart") == 0) {
            fprintf(stderr, "Warning: `-chart' option is not available\n");
        } else if (strcmp(argv[i], "-qws") == 0) {
            // do nothing
        } else if (strcmp(argv[i], "-graphicssystem") == 0) {
            // do nothing
            if (i + 1 >= argc) {
                printf("-graphicssystem needs an extra parameter specifying the graphics system\n");
                exit(1);
            } else {
                ++i;
            }
        } else if (argv[i][0] == '-') {
            printf("Unknown option: '%s'\n\n%s", argv[i], testOptions);
            exit(1);
        } else if (qml) {
            // We can't check the availability of test functions until
            // we load the QML files.  So just store the data for now.
            int colon = -1;
            int offset;
            for(offset = 0; *(argv[i]+offset); ++offset) {
                if (*(argv[i]+offset) == ':') {
                    if (*(argv[i]+offset+1) == ':') {
                        // "::" is used as a test name separator.
                        // e.g. "ClickTests::test_click:row1".
                        ++offset;
                    } else {
                        colon = offset;
                        break;
                    }
                }
            }
            if (colon == -1) {
                QTest::testFunctions += QString::fromLatin1(argv[i]);
                QTest::testTags += QString();
            } else {
                QTest::testFunctions +=
                    QString::fromLatin1(argv[i], colon);
                QTest::testTags +=
                    QString::fromLatin1(argv[i] + colon + 1);
            }
        } else {
            if (!QTest::testFuncs) {
                QTest::testFuncs = new QTest::TestFunction[512];
            }

            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);
            }
            testFuncs[testFuncCount].set(idx, data);
            testFuncCount++;
            QTEST_ASSERT(QTest::testFuncCount < 512);
        }
    }

    if (QTest::seedSet && !QTest::randomOrder) {
        printf("-seed requires -random\n");
        exit(1);
    }
}

qTestRandomSeed()

int QTest::qTestRandomSeed

(

)

Definition at line 1044 of file qtestcase.cpp.

{
    Q_ASSERT(QTest::seedSet);
    return QTest::seed;
}

qToInt()

static int QTest::qToInt ( char *  str )

static

Definition at line 1159 of file qtestcase.cpp.

Referenced by qtest_qParseArgs().

{
    char *pEnd;
    int l = (int)strtol(str, &pEnd, 10);
    if (*pEnd != 0) {
        printf("Invalid numeric parameter: '%s'\n", str);
        exit(1);
    }
    return l;
}

qVerify()

bool QTest::qVerify	(	bool	statement,
		const char *	statementStr,
		const char *	description,
		const char *	file,
		int	line
	)

Warning

This function is not part of the public interface.

Definition at line 2074 of file qtestcase.cpp.

Referenced by toString().

{
    return QTestResult::verify(statement, statementStr, description, file, line);
}

qWait()

void QTest::qWait ( int  ms )

inlinestatic

Waits for ms milliseconds.

While waiting, events will be processed and your test will stay responsive to user interface events or network communication.

Example:

int i = 0;
while (myNetworkServerNotResponding() && i++ < 50)
    QTest::qWait(250);

The code above will wait until the network server is responding for a maximum of about 12.5 seconds.

See also

QTest::qSleep()

Definition at line 62 of file qtestsystem.h.

Referenced by mouseEvent(), qWaitForWindowShown(), QTestDelayEvent::simulate(), and simulateEvent().

    {
        Q_ASSERT(QCoreApplication::instance());

        QElapsedTimer timer;
        timer.start();
        do {
            QCoreApplication::processEvents(QEventLoop::AllEvents, ms);
            QTest::qSleep(10);
        } while (timer.elapsed() < ms);
    }

qWaitForWindowShown()

bool QTest::qWaitForWindowShown ( QWidget *  window )

inlinestatic

Since

4.6

Waits until the 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:

QWidget widget;
widget.show();
QTest::qWaitForWindowShown(&widget);

Definition at line 74 of file qtestsystem.h.

    {
#if defined(Q_WS_X11)
        qt_x11_wait_for_window_manager(window);
        QCoreApplication::processEvents();
#elif defined(Q_WS_QWS)
        Q_UNUSED(window);
        qWait(100);
#else
        Q_UNUSED(window);
        qWait(50);
#endif
        return true;
    }

qWarn()

void QTest::qWarn

(

const char *

message

)

Warning

This function is not part of the public interface.

Definition at line 2102 of file qtestcase.cpp.

Referenced by mouseEvent(), simulateEvent(), and toString().

{
    QTestLog::warn(message);
}

randomizeList()

template<typename T >

static void QTest::randomizeList ( T *  array, int  size  )

static

Definition at line 1059 of file qtestcase.cpp.

Referenced by qInvokeTestMethods().

{
    for (int i = 0; i != size; i++) {
        int pos = qrand() % size;
        swap(array, pos, i);
    }
}

seedRandom()

void QTest::seedRandom

(

)

Definition at line 1030 of file qtestcase.cpp.

Referenced by qExec().

{
    static bool randomSeeded = false;
    if (!randomSeeded) {
        if (!QTest::seedSet) {
            QElapsedTimer timer;
            timer.start();
            QTest::seed = timer.msecsSinceReference();
        }
        qsrand(QTest::seed);
        randomSeeded = true;
    }
}

sendKeyEvent() [1/2]

static void QTest::sendKeyEvent ( KeyAction  action, QWidget *  widget, Qt::Key  code, QString  text, Qt::KeyboardModifiers  modifier, int  delay = -1  )

static

Definition at line 87 of file qtestkeyboard.h.

Referenced by keyEvent(), and sendKeyEvent().

    {
        QTEST_ASSERT(qApp);

        if (!widget)
            widget = QWidget::keyboardGrabber();
        if (!widget) {
            if (QWidget *apw = QApplication::activePopupWidget())
                widget = apw->focusWidget() ? apw->focusWidget() : apw;
            else
                widget = QApplication::focusWidget();
        }
        if (!widget)
            widget = QApplication::activeWindow();

        QTEST_ASSERT(widget);

        if (action == Click) {
            QPointer<QWidget> ptr(widget);
            sendKeyEvent(Press, widget, code, text, modifier, delay);
            if (!ptr) {
                // if we send key-events to embedded widgets, they might be destroyed
                // when the user presses Return
                return;
            }
            sendKeyEvent(Release, widget, code, text, modifier, delay);
            return;
        }

        bool repeat = false;

        if (action == Press) {
            if (modifier & Qt::ShiftModifier)
                simulateEvent(widget, true, Qt::Key_Shift, 0, QString(), false, delay);

            if (modifier & Qt::ControlModifier)
                simulateEvent(widget, true, Qt::Key_Control, modifier & Qt::ShiftModifier, QString(), false, delay);

            if (modifier & Qt::AltModifier)
                simulateEvent(widget, true, Qt::Key_Alt,
                              modifier & (Qt::ShiftModifier | Qt::ControlModifier), QString(), false, delay);
            if (modifier & Qt::MetaModifier)
                simulateEvent(widget, true, Qt::Key_Meta, modifier & (Qt::ShiftModifier
                                                                      | Qt::ControlModifier | Qt::AltModifier), QString(), false, delay);
            simulateEvent(widget, true, code, modifier, text, repeat, delay);
        } else if (action == Release) {
            simulateEvent(widget, false, code, modifier, text, repeat, delay);

            if (modifier & Qt::MetaModifier)
                simulateEvent(widget, false, Qt::Key_Meta, modifier, QString(), false, delay);
            if (modifier & Qt::AltModifier)
                simulateEvent(widget, false, Qt::Key_Alt, modifier &
                              (Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier), QString(), false, delay);

            if (modifier & Qt::ControlModifier)
                simulateEvent(widget, false, Qt::Key_Control,
                              modifier & (Qt::ShiftModifier | Qt::ControlModifier), QString(), false, delay);

            if (modifier & Qt::ShiftModifier)
                simulateEvent(widget, false, Qt::Key_Shift, modifier & Qt::ShiftModifier, QString(), false, delay);
        }
    }

sendKeyEvent() [2/2]

static void QTest::sendKeyEvent ( KeyAction  action, QWidget *  widget, Qt::Key  code, char  ascii, Qt::KeyboardModifiers  modifier, int  delay = -1  )

static

Definition at line 152 of file qtestkeyboard.h.

    {
        QString text;
        if (ascii)
            text = QString(QChar::fromLatin1(ascii));
        sendKeyEvent(action, widget, code, text, modifier, delay);
    }

setBenchmarkResult()

void QTest::setBenchmarkResult	(	qreal	result,
		QTest::QBenchmarkMetric	metric
	)

Sets the benchmark result for this test function to result.

Use this function if you want to report benchmark results without using the QBENCHMARK macro. Use metric to specify how QTestLib should interpret the results.

The context for the result will be the test function name and any data tag from the _data function. This function can only be called once in each test function, subsequent calls will replace the earlier reported results.

Note that the -iterations command line argument has no effect on test functions without the QBENCHMARK macro.

Since

4.7

Definition at line 291 of file qbenchmark.cpp.

{
    QBenchmarkTestMethodData::current->setResult(result, metric, false);
}

setIterationCount()

void QTest::setIterationCount

(

int

count

)

Warning

This function is not part of the public interface.

Definition at line 252 of file qbenchmark.cpp.

{
    QBenchmarkTestMethodData::current->iterationCount = count;
    QBenchmarkTestMethodData::current->resultAccepted = true;
}

setIterationCountHint()

void QTest::setIterationCountHint

(

int

count

)

Warning

This function is not part of the public interface.

Definition at line 245 of file qbenchmark.cpp.

{
    QBenchmarkTestMethodData::current->adjustIterationCount(count);
}

simulateEvent()

void QTest::simulateEvent ( QWidget *  widget, bool  press, int  code, Qt::KeyboardModifiers  modifier, QString  text, bool  repeat, int  delay = -1  )

static

Warning

This function is not part of the public interface.

Definition at line 70 of file qtestkeyboard.h.

Referenced by sendKeyEvent().

    {
        QTEST_ASSERT(widget);
        extern int Q_TESTLIB_EXPORT defaultKeyDelay();

        if (delay == -1 || delay < defaultKeyDelay())
            delay = defaultKeyDelay();
        if(delay > 0)
            QTest::qWait(delay);

        QKeyEvent a(press ? QEvent::KeyPress : QEvent::KeyRelease, code, modifier, text, repeat);
        QSpontaneKeyEvent::setSpontaneous(&a);
        if (!qApp->notify(widget, &a))
            QTest::qWarn("Keyboard event not accepted by receiving widget");
    }

swap()

template<typename T >

void QTest::swap	(	T *	array,
		int	pos,
		int	otherPos
	)

Definition at line 1051 of file qtestcase.cpp.

Referenced by randomizeList().

{
    T tmp = array[pos];
    array[pos] = array[otherPos];
    array[otherPos] = tmp;
}

testObject()

QObject * QTest::testObject

(

)

Warning

This function is not part of the public interface.

Definition at line 2283 of file qtestcase.cpp.

Referenced by qExec(), and toString().

{
    return currentTestObject;
}

toHexRepresentation()

Q_TESTLIB_EXPORT char * QTest::toHexRepresentation	(	const char *	ba,
		int	length
	)

Returns a pointer to a string that is the string 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.

length is the length of the string ba.

Definition at line 1667 of file qtestcase.cpp.

Referenced by toString().

{
    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;
}

toString() [1/18]

template<>

char * QTest::toString ( const QLatin1String &  str )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given string.

Definition at line 73 of file qtest.h.

Referenced by compare_ptr_helper(), compare_string_helper(), qCompare< double >(), qCompare< float >(), qSignalDumperCallback(), and toString().

{
    return qstrdup(str.latin1());
}

toString() [2/18]

template<>

char * QTest::toString ( const QString &  str )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given string.

Definition at line 78 of file qtest.h.

{
    return qstrdup(str.toLatin1().constData());
}

toString() [3/18]

template<>

char * QTest::toString ( const QByteArray &  ba )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the byte array ba.

See also

QTest::toHexRepresentation()

Definition at line 83 of file qtest.h.

{
    return QTest::toHexRepresentation(ba.constData(), ba.length());
}

toString() [4/18]

template<>

char * QTest::toString ( const QTime &  time )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given time.

Definition at line 88 of file qtest.h.

{
    return time.isValid()
        ? qstrdup(time.toString(QLatin1String("hh:mm:ss.zzz")).toLatin1().constData())
        : qstrdup("Invalid QTime");
}

toString() [5/18]

template<>

char * QTest::toString ( const QDate &  date )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given date.

Definition at line 95 of file qtest.h.

{
    return date.isValid()
        ? qstrdup(date.toString(QLatin1String("yyyy/MM/dd")).toLatin1().constData())
        : qstrdup("Invalid QDate");
}

toString() [6/18]

template<>

char * QTest::toString ( const QDateTime &  dateTime )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the date and time specified by dateTime.

Definition at line 102 of file qtest.h.

{
    return dateTime.isValid()
        ? qstrdup((dateTime.toString(QLatin1String("yyyy/MM/dd hh:mm:ss.zzz")) +
                  (dateTime.timeSpec() == Qt::LocalTime ? QLatin1String("[local time]") : QLatin1String("[UTC]"))).toLatin1().constData())
        : qstrdup("Invalid QDateTime");
}

toString() [7/18]

template<>

char * QTest::toString ( const QChar &  c )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given character.

Definition at line 110 of file qtest.h.

{
    return qstrdup(QString::fromLatin1("QChar: '%1' (0x%2)").arg(c).arg(QString::number(static_cast<int>(c.unicode()), 16)).toLatin1().constData());
}

toString() [8/18]

template<>

char * QTest::toString ( const QPoint &  p )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given point.

Definition at line 115 of file qtest.h.

{
    return qstrdup(QString::fromLatin1("QPoint(%1,%2)").arg(p.x()).arg(p.y()).toLatin1().constData());
}

toString() [9/18]

template<>

char * QTest::toString ( const QSize &  s )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given size.

Definition at line 120 of file qtest.h.

{
    return qstrdup(QString::fromLatin1("QSize(%1x%2)").arg(s.width()).arg(s.height()).toLatin1().constData());
}

toString() [10/18]

template<typename T >

char * QTest::toString ( const T &  value )

inline

Returns a textual representation of value.

This function is used by 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.

Note: The caller of toString() must delete the returned data using delete[]. Your implementation should return a string created with new[] or qstrdup().

Example:

namespace QTest {
    template<>
    char *toString(const MyPoint &point)
    {
        QByteArray ba = "MyPoint(";
        ba += QByteArray::number(point.x()) + ", " + QByteArray::number(point.y());
        ba += ")";
        return qstrdup(ba.data());
    }
}

The example above defines a toString() specialization for a class called MyPoint. Whenever a comparison of two instances of MyPoint fails, QCOMPARE() will call this function to output the contents of MyPoint to the test log.

See also

QCOMPARE()

Definition at line 123 of file qtestcase.h.

    {
        return 0;
    }

toString() [11/18]

template<>

char * QTest::toString ( const QRect &  s )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given rectangle.

Definition at line 125 of file qtest.h.

{
    return qstrdup(QString::fromLatin1("QRect(%1,%2 %5x%6) (bottomright %3,%4)").arg(s.left()).arg(s.top()).arg(s.right()).arg(s.bottom()).arg(s.width()).arg(s.height()).toLatin1().constData());
}

toString() [12/18]

template<>

char * QTest::toString ( const QPointF &  p )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given point.

Definition at line 130 of file qtest.h.

{
    return qstrdup(QString::fromLatin1("QPointF(%1,%2)").arg(p.x()).arg(p.y()).toLatin1().constData());
}

toString() [13/18]

char * QTest::toString

(

const char *

str

)

Warning

This function is not part of the public interface.

Definition at line 2357 of file qtestcase.cpp.

{
    if (!str)
        return 0;
    char *msg = new char[strlen(str) + 1];
    return qstrcpy(msg, str);
}

toString() [14/18]

char * QTest::toString

(

const void *

p

)

Warning

This function is not part of the public interface.

Definition at line 2367 of file qtestcase.cpp.

{
    char *msg = new char[128];
    qt_snprintf(msg, 128, "%p", p);
    return msg;
}

toString() [15/18]

template<>

char * QTest::toString ( const QSizeF &  s )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given size.

Definition at line 135 of file qtest.h.

{
    return qstrdup(QString::fromLatin1("QSizeF(%1x%2)").arg(s.width()).arg(s.height()).toLatin1().constData());
}

toString() [16/18]

template<>

char * QTest::toString ( const QRectF &  s )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given rectangle.

Definition at line 140 of file qtest.h.

{
    return qstrdup(QString::fromLatin1("QRectF(%1,%2 %5x%6) (bottomright %3,%4)").arg(s.left()).arg(s.top()).arg(s.right()).arg(s.bottom()).arg(s.width()).arg(s.height()).toLatin1().constData());
}

toString() [17/18]

template<>

char * QTest::toString ( const QUrl &  url )

inline

Since

4.4 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Returns a textual representation of the given url.

Definition at line 145 of file qtest.h.

{
    return qstrdup(uri.toEncoded().constData());
}

toString() [18/18]

template<>

char * QTest::toString ( const QVariant &  v )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns a textual representation of the given variant.

Definition at line 150 of file qtest.h.

{
    QByteArray vstring("QVariant(");
    if (v.isValid()) {
        QByteArray type(v.typeName());
        if (type.isEmpty()) {
            type = QByteArray::number(v.userType());
        }
        vstring.append(type);
        if (!v.isNull()) {
            vstring.append(',');
            if (v.canConvert(QVariant::String)) {
                vstring.append(qvariant_cast<QString>(v).toLatin1());
            }
            else {
                vstring.append("<value not representable as string>");
            }
        }
    }
    vstring.append(')');

    return qstrdup(vstring.constData());
}

touchEvent()

QTouchEventSequence QTest::touchEvent ( QWidget *  widget = 0, QTouchEvent::DeviceType  deviceType = QTouchEvent::TouchScreen  )

inline

Creates and returns a QTouchEventSequence for the device deviceType to simulate events for widget.

When adding touch events to the sequence, 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).

Definition at line 141 of file qtesttouch.h.

Referenced by QWidget::event(), QApplication::notify(), QApplicationPrivate::translateRawTouchEvent(), and QGraphicsView::viewportEvent().

    {
        return QTouchEventSequence(widget, deviceType);
    }

xmlIncidentType2String()

static const char* QTest::xmlIncidentType2String ( QAbstractTestLogger::IncidentTypes  type )

static

Definition at line 77 of file qxmltestlogger.cpp.

Referenced by QXmlTestLogger::addIncident().

    {
        switch (type) {
        case QAbstractTestLogger::Pass:
            return "pass";
        case QAbstractTestLogger::XFail:
            return "xfail";
        case QAbstractTestLogger::Fail:
            return "fail";
        case QAbstractTestLogger::XPass:
            return "xpass";
        }
        return "??????";
    }

xmlMessageType2String()

static const char* QTest::xmlMessageType2String ( QAbstractTestLogger::MessageTypes  type )

static

Definition at line 56 of file qxmltestlogger.cpp.

Referenced by QXmlTestLogger::addMessage().

    {
        switch (type) {
        case QAbstractTestLogger::Warn:
            return "warn";
        case QAbstractTestLogger::QSystem:
            return "system";
        case QAbstractTestLogger::QDebug:
            return "qdebug";
        case QAbstractTestLogger::QWarning:
            return "qwarn";
        case QAbstractTestLogger::QFatal:
            return "qfatal";
        case QAbstractTestLogger::Skip:
            return "skip";
        case QAbstractTestLogger::Info:
            return "info";
        }
        return "??????";
    }

Variable Documentation

currentAppName

const char* QTest::currentAppName = 0

static

Definition at line 72 of file qtestresult.cpp.

Referenced by QTestResult::currentAppName(), QTestResult::setCurrentAppName(), and toString().

currentGlobalTestData

QTestData* QTest::currentGlobalTestData = 0

static

Definition at line 57 of file qtestresult.cpp.

Referenced by QTestResult::currentGlobalDataTag(), QTestResult::currentGlobalTestData(), QTestResult::reset(), and QTestResult::setCurrentGlobalTestData().

currentTestData

QTestData* QTest::currentTestData = 0

static

Definition at line 56 of file qtestresult.cpp.

Referenced by QTestResult::currentDataTag(), QTestResult::currentTestData(), isExpectFailData(), QTestResult::reset(), and QTestResult::setCurrentTestData().

currentTestFunc

const char* QTest::currentTestFunc = 0

static

Definition at line 58 of file qtestresult.cpp.

Referenced by QTestResult::currentTestFunction(), QTestResult::finishedCurrentTestFunction(), QTestResult::reset(), and QTestResult::setCurrentTestFunction().

currentTestObject

QObject* QTest::currentTestObject = 0

static

Definition at line 903 of file qtestcase.cpp.

Referenced by qExec(), qInvokeTestMethod(), qInvokeTestMethodDataEntry(), qPrintDataTags(), qPrintTestSlots(), qtest_qParseArgs(), and testObject().

currentTestObjectName

const char* QTest::currentTestObjectName = 0

static

Definition at line 59 of file qtestresult.cpp.

Referenced by QTestResult::currentTestObjectName(), QTestResult::reset(), and QTestResult::setCurrentTestObject().

dataFailed

bool QTest::dataFailed = false

static

Definition at line 61 of file qtestresult.cpp.

Referenced by QTestResult::addFailure(), QTestResult::currentTestFailed(), QTestResult::finishedCurrentTestFunction(), QTestResult::reset(), and QTestResult::setCurrentTestData().

eventDelay

int QTest::eventDelay = -1

static

Definition at line 940 of file qtestcase.cpp.

Referenced by defaultEventDelay(), and qtest_qParseArgs().

expectFailComment

const char* QTest::expectFailComment = 0

static

Definition at line 69 of file qtestresult.cpp.

Referenced by checkStatement(), clearExpectFail(), QTestResult::expectFail(), and QTestResult::reset().

expectFailMode

int QTest::expectFailMode = 0

static

Definition at line 70 of file qtestresult.cpp.

Referenced by checkStatement(), clearExpectFail(), QTestResult::expectFail(), and QTestResult::reset().

failed

bool QTest::failed = false

static

Definition at line 60 of file qtestresult.cpp.

Referenced by QTestResult::addFailure(), QTestResult::allDataPassed(), checkStatement(), QTestResult::finishedCurrentTestFunction(), QTestXmlStreamer::formatEnd(), QTestResult::reset(), QTestResult::setCurrentTestFunction(), and QTestResult::testFailed().

fails

int QTest::fails = 0

static

Definition at line 65 of file qtestresult.cpp.

Referenced by QTestResult::addFailure(), checkStatement(), QTestResult::failCount(), and QTestResult::reset().

flushMode

QTestLog::FlushMode QTest::flushMode = QTestLog::NoFlush

static

Definition at line 88 of file qtestlog.cpp.

Referenced by initLogger(), and QTestLog::setFlushMode().

ignoreLevel

int QTest::ignoreLevel = 0

static

Definition at line 64 of file qsignaldumper.cpp.

Referenced by qSignalDumperCallback(), qSignalDumperCallbackEndSignal(), and qSignalDumperCallbackSlot().

ignoreResultList

IgnoreResultList* QTest::ignoreResultList = 0

static

Definition at line 85 of file qtestlog.cpp.

Referenced by QTestLog::addIgnoreMessage(), handleIgnoredMessage(), QTestLog::leaveTestFunction(), QTestLog::printUnhandledIgnoreMessages(), and QTestLog::unhandledIgnoreMessages().

iLevel

int QTest::iLevel = 0

static

Definition at line 63 of file qsignaldumper.cpp.

Referenced by qSignalDumperCallback(), qSignalDumperCallbackEndSignal(), and qSignalDumperCallbackSlot().

keyDelay

int QTest::keyDelay = -1

static

Definition at line 938 of file qtestcase.cpp.

Referenced by defaultKeyDelay(), and qtest_qParseArgs().

keyVerbose

int QTest::keyVerbose = -1

static

Definition at line 942 of file qtestcase.cpp.

Referenced by qtest_qParseArgs().

location

QTestResult::TestLocation QTest::location = QTestResult::NoWhere

static

Definition at line 63 of file qtestresult.cpp.

Referenced by QUnixPrintWidgetPrivate::_q_printerChanged(), QPatternist::XsdSchemaResolver::addAlternativeType(), QPatternist::XsdSchemaResolver::addAttributeType(), QPatternist::XsdSchemaResolver::addComplexBaseType(), QPatternist::XsdSchemaResolver::addElementType(), QPatternist::XsdSchemaResolver::addKeyReference(), QPatternist::XsdSchemaResolver::addSimpleListType(), QPatternist::XsdSchemaResolver::addSimpleRestrictionBase(), QPatternist::XsdSchemaResolver::addSimpleUnionTypes(), QPatternist::XsdSchemaResolver::addSubstitutionGroupAffiliation(), QGLShaderProgram::bindAttributeLocation(), QPatternist::CastingPlatform< UntypedAtomicConverter, true >::CastingPlatform(), QPatternist::XsdSchemaChecker::checkBasicCircularInheritances(), QPatternist::XsdSchemaChecker::checkBasicComplexTypeConstraints(), QPatternist::XsdSchemaChecker::checkBasicSimpleTypeConstraints(), QPatternist::XsdSchemaChecker::checkCircularInheritances(), QPatternist::XsdSchemaChecker::checkComplexTypeConstraints(), QPatternist::XsdSchemaChecker::checkInheritanceRestrictions(), QPatternist::XsdSchemaChecker::checkSimpleDerivationRestrictions(), QPatternist::XsdSchemaChecker::checkSimpleTypeConstraints(), QPatternist::GenericPredicate::create(), QPatternist::XsdSchemaParser::currentSourceLocation(), QTestResult::currentTestLocation(), QGL2PaintEngineExPrivate::drawPixmapFragments(), extract_location(), QGLEngineSharedShaders::findProgramInCache(), QTestResult::finishedCurrentTestFunction(), QTestXmlStreamer::formatStart(), getLocations(), QPatternist::ColoringMessageHandler::handleMessage(), QPatternist::AccelTreeResourceLoader::load(), QPatternist::XsdValidatingInstanceReader::loadSchema(), QPatternist::CastingPlatform< UntypedAtomicConverter, true >::locateCaster(), QLibraryInfo::location(), QScriptNewBreakpointWidget::onOkClicked(), QEventDispatcherMacPrivate::postedEventsSourcePerformCallback(), qt_mac_constructQIconFromIconRef(), QGLMaskTextureCache::quadtreeClear(), QGLMaskTextureCache::quadtreeInsert(), QGLMaskTextureCache::quadtreeLocation(), QTestResult::reset(), QDeclarativeTypeData::resolveTypes(), QGLShaderProgram::setAttributeValue(), QTestResult::setCurrentTestFunction(), QTestResult::setCurrentTestLocation(), QPatternist::XsdReference::setSourceLocation(), QPatternist::XsdAttributeReference::setSourceLocation(), QPatternist::XsdSchemaChecker::sourceLocation(), QPatternist::XsdSchemaResolver::sourceLocation(), QPatternist::StaticContext::StaticContext(), QOpenGLPaintEnginePrivate::updateFragmentProgramData(), writeIncludeFile(), and QMenuPrivate::QMenuScroller::~QMenuScroller().

logMode

QTestLog::LogMode QTest::logMode = QTestLog::Plain

static

Definition at line 87 of file qtestlog.cpp.

Referenced by initLogger(), QTestLog::logMode(), and QTestLog::setLogMode().

maxWarnings

int QTest::maxWarnings = 2002

static

Definition at line 90 of file qtestlog.cpp.

Referenced by messageHandler(), and QTestLog::setMaxWarnings().

mouseDelay

int QTest::mouseDelay = -1

static

Definition at line 939 of file qtestcase.cpp.

Referenced by defaultMouseDelay(), and qtest_qParseArgs().

noCrashHandler

bool QTest::noCrashHandler = false

static

Definition at line 946 of file qtestcase.cpp.

Referenced by qExec(), and qtest_qParseArgs().

oldMessageHandler

QtMsgHandler QTest::oldMessageHandler

static

Definition at line 95 of file qtestlog.cpp.

Referenced by QTestLog::startLogging(), and QTestLog::stopLogging().

outFile

const char* QTest::outFile = 0

static

Definition at line 93 of file qtestlog.cpp.

Referenced by QMacPrintEngine::begin(), QTestLog::outputFileName(), and QTestLog::redirectOutput().

passes

int QTest::passes = 0

static

Definition at line 66 of file qtestresult.cpp.

Referenced by QTestResult::finishedCurrentTestFunction(), QTestResult::passCount(), and QTestResult::reset().

printAvailableFunctions

Q_TESTLIB_EXPORT bool QTest::printAvailableFunctions = false

Definition at line 1086 of file qtestcase.cpp.

Referenced by qtest_qParseArgs().

printAvailableTags

Q_TESTLIB_EXPORT bool QTest::printAvailableTags = false

Definition at line 1087 of file qtestcase.cpp.

Referenced by QTestLog::addPass(), QTestLog::enterTestFunction(), initLogger(), QTestLog::leaveTestFunction(), and qtest_qParseArgs().

randomOrder

bool QTest::randomOrder = false

static

Definition at line 941 of file qtestcase.cpp.

Referenced by qExec(), qInvokeTestMethods(), and qtest_qParseArgs().

seed

unsigned int QTest::seed = 0

static

Definition at line 943 of file qtestcase.cpp.

Referenced by qIntCast(), qInvokeTestMethods(), qtest_qParseArgs(), qTestRandomSeed(), QPlainTestLogger::registerRandomSeed(), QXmlTestLogger::registerRandomSeed(), QTestLogger::registerRandomSeed(), seedRandom(), and QAbstractTestLogger::~QAbstractTestLogger().

seedSet

bool QTest::seedSet = false

static

Definition at line 944 of file qtestcase.cpp.

Referenced by qtest_qParseArgs(), qTestRandomSeed(), and seedRandom().

skipCurrentTest

bool QTest::skipCurrentTest = false

static

Definition at line 62 of file qtestresult.cpp.

Referenced by QTestResult::finishedCurrentTestFunction(), QTestResult::setSkipCurrentTest(), and QTestResult::skipCurrentTest().

skips

int QTest::skips = 0

static

Definition at line 67 of file qtestresult.cpp.

Referenced by QTestResult::addSkip(), QTestResult::reset(), and QTestResult::skipCount().

stream [1/3]

FILE* QTest::stream = 0

static

Definition at line 56 of file qtestfilelogger.cpp.

stream [2/3]

FILE* QTest::stream = 0

static

Definition at line 60 of file qabstracttestlogger.cpp.

Referenced by QFontDatabasePrivate::addFont(), QCopChannel::answer(), QTextStream::bin(), QTextStream::bom(), QTextStream::center(), QMacPasteboardMimeVCard::convertFromMime(), QTextStream::dec(), deflate(), QSvgPaintEngine::drawImage(), QSvgPaintEngine::drawPolygon(), QAbstractItemModel::dropMimeData(), QAbstractTableModel::dropMimeData(), QAbstractListModel::dropMimeData(), QStandardItemModel::dropMimeData(), QTextStream::fixed(), QTestFileLogger::flush(), QTextStream::flush(), QTextStream::forcepoint(), QTextStream::forcesign(), QTextStream::hex(), inflate(), QTestFileLogger::init(), QCss::Parser::init(), QTestBasicStreamer::isTtyOutput(), QAbstractTestLogger::isTtyOutput(), QStandardItemModelPrivate::itemFromIndex(), launchWebBrowser(), QTextStream::left(), QScriptDebuggerConsolePrivate::loadScriptedCommands(), QTextStream::lowercasebase(), QTextStream::lowercasedigits(), QDebug::maybeSpace(), QDeclarativeDebugTrace::messageReceived(), QAbstractItemModel::mimeData(), QStandardItemModel::mimeData(), QTextStream::noforcepoint(), QTextStream::noforcesign(), QTextStream::noshowbase(), QDebug::nospace(), QTextStream::oct(), QDebug::operator<<(), operator<<(), QLine::operator<<(), QLineF::operator<<(), QDebug::operator=(), QmlJSDebugger::operator>>(), operator>>(), QLine::operator>>(), QLineF::operator>>(), QTestBasicStreamer::outputString(), QAbstractTestLogger::outputString(), QDeclarativeDirParser::parse(), QDeclarativeScriptParser::parse(), qax_generateDocumentation(), QDebug::QDebug(), QPolygon::QPolygon(), QXmlInputSource::QXmlInputSource(), QTextStream::reset(), QWidget::restoreGeometry(), QSplitter::restoreState(), QFileDialog::restoreState(), QMainWindowLayoutState::restoreState(), QHeaderView::restoreState(), QMainWindow::restoreState(), QTextStream::right(), QWidget::saveGeometry(), QSplitter::saveState(), QFileDialog::saveState(), QHeaderView::saveState(), QMainWindow::saveState(), QTextStream::scientific(), QTextStream::showbase(), QAbstractItemModel::sibling(), QDebug::space(), QAbstractTestLogger::startLogging(), QTestBasicStreamer::startStreaming(), QAbstractTestLogger::stopLogging(), QTestBasicStreamer::stopStreaming(), QSettingsPrivate::stringToVariant(), QWSInputContext::translateIMEvent(), QSvgPaintEngine::updateState(), QTextStream::uppercasebase(), QTextStream::uppercasedigits(), QTextStream::ws(), QDebug::~QDebug(), and QTestFileLogger::~QTestFileLogger().

stream [3/3]

FILE* QTest::stream = 0

static

Definition at line 60 of file qtestbasicstreamer.cpp.

testFuncCleaner

struct QTest::TestFuncCleanup QTest::testFuncCleaner

static

Referenced by qInvokeTestMethods(), and QTest::TestFuncCleanup::~TestFuncCleanup().

testFuncCount

int QTest::testFuncCount = 0

static

Definition at line 923 of file qtestcase.cpp.

Referenced by qInvokeTestMethods(), and qtest_qParseArgs().

testFuncs

TestFunction* QTest::testFuncs = 0

static

Contains the list of test functions that was supplied on the command line, if any. Hence, if not empty, those functions should be run instead of all appearing in the test case.

Definition at line 922 of file qtestcase.cpp.

Referenced by QTest::TestFuncCleanup::cleanup(), qInvokeTestMethods(), and qtest_qParseArgs().

testFunctions

Q_TESTLIB_EXPORT QStringList QTest::testFunctions

Definition at line 1088 of file qtestcase.cpp.

Referenced by qtest_qParseArgs().

testLogger

QAbstractTestLogger* QTest::testLogger = 0

static

Definition at line 92 of file qtestlog.cpp.

Referenced by QTestLog::addBenchmarkResult(), QTestLog::addFail(), QTestLog::addPass(), QTestLog::addSkip(), QTestLog::addXFail(), QTestLog::addXPass(), QTestLog::enterTestFunction(), QTestLog::info(), initLogger(), QTestLog::leaveTestFunction(), messageHandler(), QTestLog::printUnhandledIgnoreMessages(), QTestLog::startLogging(), QTestLog::stopLogging(), and QTestLog::warn().

testTags

Q_TESTLIB_EXPORT QStringList QTest::testTags

Definition at line 1089 of file qtestcase.cpp.

Referenced by qtest_qParseArgs().

verbosity

int QTest::verbosity = 0

static

Definition at line 89 of file qtestlog.cpp.

Referenced by QTestLog::setVerboseLevel(), and QTestLog::verboseLevel().