1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtTest module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #ifndef QTESTCASE_H

    43 #define QTESTCASE_H

    44 

    45 #include <QtTest/qtest_global.h>

    46 

    47 #include <QtCore/qnamespace.h>

    48 #include <QtCore/qmetatype.h>

    49 

    50 QT_BEGIN_HEADER

    51 

    52 QT_BEGIN_NAMESPACE

    53 

    54 QT_MODULE(Test)

    55 

    56 #define QVERIFY(statement) \

    57 do {\

    58     if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\

    59         return;\

    60 } while (0)

    61 

    62 #define QFAIL(message) \

    63 do {\

    64     QTest::qFail(message, __FILE__, __LINE__);\

    65     return;\

    66 } while (0)

    67 

    68 #define QVERIFY2(statement, description) \

    69 do {\

    70     if (statement) {\

    71         if (!QTest::qVerify(true, #statement, (description), __FILE__, __LINE__))\

    72             return;\

    73     } else {\

    74         if (!QTest::qVerify(false, #statement, (description), __FILE__, __LINE__))\

    75             return;\

    76     }\

    77 } while (0)

    78 

    79 #define QCOMPARE(actual, expected) \

    80 do {\

    81     if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__))\

    82         return;\

    83 } while (0)

    84 

    85 #define QSKIP(statement, mode) \

    86 do {\

    87     QTest::qSkip(statement, QTest::mode, __FILE__, __LINE__);\

    88     return;\

    89 } while (0)

    90 

    91 #define QEXPECT_FAIL(dataIndex, comment, mode)\

    92 do {\

    93     if (!QTest::qExpectFail(dataIndex, comment, QTest::mode, __FILE__, __LINE__))\

    94         return;\

    95 } while (0)

    96 

    97 #define QFETCH(type, name)\

    98     type name = *static_cast<type *>(QTest::qData(#name, ::qMetaTypeId<type >()))

    99 

   100 #define QFETCH_GLOBAL(type, name)\

   101     type name = *static_cast<type *>(QTest::qGlobalData(#name, ::qMetaTypeId<type >()))

   102 

   103 #define DEPENDS_ON(funcName)

   104 

   105 #define QTEST(actual, testElement)\

   106 do {\

   107     if (!QTest::qTest(actual, testElement, #actual, #testElement, __FILE__, __LINE__))\

   108         return;\

   109 } while (0)

   110 

   111 #define QWARN(msg)\

   112     QTest::qWarn(msg)

   113 

   114 class QObject;

   115 class QTestData;

   116 

   117 #define QTEST_COMPARE_DECL(KLASS)\

   118     template<> Q_TESTLIB_EXPORT char *toString<KLASS >(const KLASS &);

   119 

   120 namespace QTest

   121 {

   122     template <typename T>

   123     inline char *toString(const T &)

   124     {

   125         return 0;

   126     }

   127 

   128 

   129     Q_TESTLIB_EXPORT char *toHexRepresentation(const char *ba, int length);

   130     Q_TESTLIB_EXPORT char *toString(const char *);

   131     Q_TESTLIB_EXPORT char *toString(const void *);

   132 

   133     Q_TESTLIB_EXPORT int qExec(QObject *testObject, int argc = 0, char **argv = 0);

   134     Q_TESTLIB_EXPORT int qExec(QObject *testObject, const QStringList &arguments);

   135 

   136     Q_TESTLIB_EXPORT bool qVerify(bool statement, const char *statementStr, const char *description,

   137                                  const char *file, int line);

   138     Q_TESTLIB_EXPORT void qFail(const char *statementStr, const char *file, int line);

   139     Q_TESTLIB_EXPORT void qSkip(const char *message, SkipMode mode, const char *file, int line);

   140     Q_TESTLIB_EXPORT bool qExpectFail(const char *dataIndex, const char *comment, TestFailMode mode,

   141                            const char *file, int line);

   142     Q_TESTLIB_EXPORT void qWarn(const char *message);

   143     Q_TESTLIB_EXPORT void ignoreMessage(QtMsgType type, const char *message);

   144 

   145     Q_TESTLIB_EXPORT void *qData(const char *tagName, int typeId);

   146     Q_TESTLIB_EXPORT void *qGlobalData(const char *tagName, int typeId);

   147     Q_TESTLIB_EXPORT void *qElementData(const char *elementName, int metaTypeId);

   148     Q_TESTLIB_EXPORT QObject *testObject();

   149 

   150     Q_TESTLIB_EXPORT const char *currentTestFunction();

   151     Q_TESTLIB_EXPORT const char *currentDataTag();

   152     Q_TESTLIB_EXPORT bool currentTestFailed();

   153 

   154     Q_TESTLIB_EXPORT Qt::Key asciiToKey(char ascii);

   155     Q_TESTLIB_EXPORT char keyToAscii(Qt::Key key);

   156 

   157     Q_TESTLIB_EXPORT bool compare_helper(bool success, const char *msg, const char *file,

   158                                           int line);

   159     Q_TESTLIB_EXPORT bool compare_helper(bool success, const char *msg, char *val1, char *val2,

   160                                          const char *expected, const char *actual,

   161                                          const char *file, int line);

   162     Q_TESTLIB_EXPORT void qSleep(int ms);

   163     Q_TESTLIB_EXPORT void addColumnInternal(int id, const char *name);

   164 

   165     template <typename T>

   166     inline void addColumn(const char *name, T * = 0)

   167     {

   168         addColumnInternal(qMetaTypeId<T>(), name);

   169     }

   170     Q_TESTLIB_EXPORT QTestData &newRow(const char *dataTag);

   171 

   172     template <typename T>

   173     inline bool qCompare(T const &t1, T const &t2, const char *actual, const char *expected,

   174                         const char *file, int line)

   175     {

   176         return (t1 == t2)

   177             ? compare_helper(true, "COMPARE()", file, line)

   178             : compare_helper(false, "Compared values are not the same",

   179                              toString<T>(t1), toString<T>(t2), actual, expected, file, line);

   180     }

   181 

   182 

   183     template <>

   184     Q_TESTLIB_EXPORT bool qCompare<float>(float const &t1, float const &t2,

   185                     const char *actual, const char *expected, const char *file, int line);

   186 

   187     template <>

   188     Q_TESTLIB_EXPORT bool qCompare<double>(double const &t1, double const &t2,

   189                     const char *actual, const char *expected, const char *file, int line);

   190 

   191     inline bool compare_ptr_helper(const void *t1, const void *t2, const char *actual,

   192                                    const char *expected, const char *file, int line)

   193     {

   194         return (t1 == t2)

   195             ? compare_helper(true, "COMPARE()", file, line)

   196             : compare_helper(false, "Compared pointers are not the same",

   197                              toString(t1), toString(t2), actual, expected, file, line);

   198     }

   199 

   200     Q_TESTLIB_EXPORT bool compare_string_helper(const char *t1, const char *t2, const char *actual,

   201                                       const char *expected, const char *file, int line);

   202 

   203 #ifndef qdoc

   204     QTEST_COMPARE_DECL(short)

   205     QTEST_COMPARE_DECL(ushort)

   206     QTEST_COMPARE_DECL(int)

   207     QTEST_COMPARE_DECL(uint)

   208     QTEST_COMPARE_DECL(long)

   209     QTEST_COMPARE_DECL(ulong)

   210     QTEST_COMPARE_DECL(qint64)

   211     QTEST_COMPARE_DECL(quint64)

   212 

   213     QTEST_COMPARE_DECL(float)

   214     QTEST_COMPARE_DECL(double)

   215     QTEST_COMPARE_DECL(char)

   216     QTEST_COMPARE_DECL(bool)

   217 #endif

   218 

   219 #ifndef QTEST_NO_SPECIALIZATIONS

   220     template <typename T1, typename T2>

   221     bool qCompare(T1 const &, T2 const &, const char *, const char *, const char *, int);

   222 

   223 #if defined(QT_COORD_TYPE) && (defined(QT_ARCH_ARM) || defined(QT_NO_FPU) || defined(QT_ARCH_WINDOWSCE))

   224     template <>

   225     inline bool qCompare<qreal, float>(qreal const &t1, float const &t2, const char *actual,

   226                                  const char *expected, const char *file, int line)

   227     {

   228         return qCompare<qreal>(t1, qreal(t2), actual, expected, file, line);

   229     }

   230 

   231     template <>

   232     inline bool qCompare<float, qreal>(float const &t1, qreal const &t2, const char *actual,

   233                                  const char *expected, const char *file, int line)

   234     {

   235         return qCompare<qreal>(qreal(t1), t2, actual, expected, file, line);

   236     }

   237 

   238 #elif defined(QT_COORD_TYPE) || defined(QT_ARCH_ARM) || defined(QT_NO_FPU) || defined(QT_ARCH_WINDOWSCE) || defined(QT_ARCH_SYMBIAN)

   239     template <>

   240     inline bool qCompare<qreal, double>(qreal const &t1, double const &t2, const char *actual,

   241                                  const char *expected, const char *file, int line)

   242     {

   243         return qCompare<float>(float(t1), float(t2), actual, expected, file, line);

   244     }

   245 

   246     template <>

   247     inline bool qCompare<double, qreal>(double const &t1, qreal const &t2, const char *actual,

   248                                  const char *expected, const char *file, int line)

   249     {

   250         return qCompare<float>(float(t1), float(t2), actual, expected, file, line);

   251     }

   252 

   253 #endif

   254 

   255     template <typename T>

   256     inline bool qCompare(const T *t1, const T *t2, const char *actual, const char *expected,

   257                         const char *file, int line)

   258     {

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

   260     }

   261     template <typename T>

   262     inline bool qCompare(T *t1, T *t2, const char *actual, const char *expected,

   263                         const char *file, int line)

   264     {

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

   266     }

   267 

   268     template <typename T1, typename T2>

   269     inline bool qCompare(const T1 *t1, const T2 *t2, const char *actual, const char *expected,

   270                         const char *file, int line)

   271     {

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

   273     }

   274     template <typename T1, typename T2>

   275     inline bool qCompare(T1 *t1, T2 *t2, const char *actual, const char *expected,

   276                         const char *file, int line)

   277     {

   278         return compare_ptr_helper(const_cast<const T1 *>(t1),

   279                 static_cast<const T1 *>(const_cast<const T2 *>(t2)), actual, expected, file, line);

   280     }

   281     template<>

   282     inline bool qCompare<char>(const char *t1, const char *t2, const char *actual,

   283                                        const char *expected, const char *file, int line)

   284     {

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

   286     }

   287     template<>

   288     inline bool qCompare<char>(char *t1, char *t2, const char *actual, const char *expected,

   289                         const char *file, int line)

   290     {

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

   292     }

   293 #else  /* QTEST_NO_SPECIALIZATIONS */

   294 

   295 // In Symbian we have QTEST_NO_SPECIALIZATIONS defined, but still float related specialization

   296 // should be used. If QTEST_NO_SPECIALIZATIONS is enabled we get ambiguous overload errors.

   297 #if defined(QT_ARCH_SYMBIAN)

   298     template <typename T1, typename T2>

   299     bool qCompare(T1 const &, T2 const &, const char *, const char *, const char *, int);

   300 

   301     template <>

   302     inline bool qCompare<qreal, double>(qreal const &t1, double const &t2, const char *actual,

   303                                  const char *expected, const char *file, int line)

   304     {

   305         return qCompare<float>(float(t1), float(t2), actual, expected, file, line);

   306     }

   307 

   308     template <>

   309     inline bool qCompare<double, qreal>(double const &t1, qreal const &t2, const char *actual,

   310                                  const char *expected, const char *file, int line)

   311     {

   312         return qCompare<float>(float(t1), float(t2), actual, expected, file, line);

   313     }

   314 #endif

   315 

   316     inline bool qCompare(const char *t1, const char *t2, const char *actual,

   317                          const char *expected, const char *file, int line)

   318     {

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

   320     }

   321 

   322     inline bool qCompare(char *t1, char *t2, const char *actual, const char *expected,

   323                          const char *file, int line)

   324     {

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

   326     }

   327 #endif

   328 

   329     /* The next two specializations are for MSVC that shows problems with implicit

   330        conversions

   331      */

   332 #ifndef QTEST_NO_SPECIALIZATIONS

   333     template<>

   334 #endif

   335     inline bool qCompare(char *t1, const char *t2, const char *actual,

   336                          const char *expected, const char *file, int line)

   337     {

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

   339     }

   340 #ifndef QTEST_NO_SPECIALIZATIONS

   341     template<>

   342 #endif

   343     inline bool qCompare(const char *t1, char *t2, const char *actual,

   344                          const char *expected, const char *file, int line)

   345     {

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

   347     }

   348 

   349     // NokiaX86 and RVCT do not like implicitly comparing bool with int

   350 #ifndef QTEST_NO_SPECIALIZATIONS

   351     template <>

   352 #endif

   353     inline bool qCompare(bool const &t1, int const &t2,

   354                     const char *actual, const char *expected, const char *file, int line)

   355     {

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

   357     }

   358 

   359 

   360     template <class T>

   361     inline bool qTest(const T& actual, const char *elementName, const char *actualStr,

   362                      const char *expected, const char *file, int line)

   363     {

   364         return qCompare(actual, *static_cast<const T *>(QTest::qElementData(elementName,

   365                        qMetaTypeId<T>())), actualStr, expected, file, line);

   366     }

   367 }

   368 

   369 #undef QTEST_COMPARE_DECL

   370 

   371 QT_END_NAMESPACE

   372 

   373 QT_END_HEADER

   374 

   375 #endif