src/testlib/qtestresult.cpp

   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 #include "QtTest/private/qtestresult_p.h"
  43 #include <QtCore/qglobal.h>
  44
  45 #include "QtTest/private/qtestlog_p.h"
  46 #include "QtTest/qtestdata.h"
  47 #include "QtTest/qtestassert.h"
  48
  49 #include <stdio.h>
  50 #include <string.h>
  51
  52 QT_BEGIN_NAMESPACE
  53
  54 namespace QTest
  55 {
  56     static QTestData *currentTestData = 0;
  57     static QTestData *currentGlobalTestData = 0;
  58     static const char *currentTestFunc = 0;
  59     static const char *currentTestObjectName = 0;
  60     static bool failed = false;
  61     static bool dataFailed = false;
  62     static bool skipCurrentTest = false;
  63     static QTestResult::TestLocation location = QTestResult::NoWhere;
  64
  65     static int fails = 0;
  66     static int passes = 0;
  67     static int skips = 0;
  68
  69     static const char *expectFailComment = 0;
  70     static int expectFailMode = 0;
  71 }
  72
  73 void QTestResult::reset()
  74 {
  75     QTest::currentTestData = 0;
  76     QTest::currentGlobalTestData = 0;
  77     QTest::currentTestFunc = 0;
  78     QTest::currentTestObjectName = 0;
  79     QTest::failed = false;
  80     QTest::dataFailed = false;
  81     QTest::location = QTestResult::NoWhere;
  82
  83     QTest::fails = 0;
  84     QTest::passes = 0;
  85     QTest::skips = 0;
  86
  87     QTest::expectFailComment = 0;
  88     QTest::expectFailMode = 0;
  89 }
  90
  91 bool QTestResult::allDataPassed()
  92 {
  93     return !QTest::failed;
  94 }
  95
  96 bool QTestResult::currentTestFailed()
  97 {
  98     return QTest::dataFailed;
  99 }
 100
 101 QTestData *QTestResult::currentGlobalTestData()
 102 {
 103     return QTest::currentGlobalTestData;
 104 }
 105
 106 QTestData *QTestResult::currentTestData()
 107 {
 108     return QTest::currentTestData;
 109 }
 110
 111 void QTestResult::setCurrentGlobalTestData(QTestData *data)
 112 {
 113     QTest::currentGlobalTestData = data;
 114 }
 115
 116 void QTestResult::setCurrentTestData(QTestData *data)
 117 {
 118     QTest::currentTestData = data;
 119     QTest::dataFailed = false;
 120 }
 121
 122 void QTestResult::setCurrentTestFunction(const char *func)
 123 {
 124     QTest::currentTestFunc = func;
 125     QTest::failed = false;
 126     if (!func)
 127         QTest::location = NoWhere;
 128     if (func)
 129         QTestLog::enterTestFunction(func);
 130 }
 131
 132 static void clearExpectFail()
 133 {
 134     QTest::expectFailMode = 0;
 135     delete [] const_cast<char *>(QTest::expectFailComment);
 136     QTest::expectFailComment = 0;
 137 }
 138
 139 void QTestResult::finishedCurrentTestFunction()
 140 {
 141     if (!QTest::failed && QTestLog::unhandledIgnoreMessages()) {
 142         QTestLog::printUnhandledIgnoreMessages();
 143         addFailure("Not all expected messages were received", 0, 0);
 144     }
 145
 146     if (!QTest::failed && !QTest::skipCurrentTest) {
 147         QTestLog::addPass("");
 148         ++QTest::passes;
 149     }
 150     QTest::currentTestFunc = 0;
 151     QTest::failed = false;
 152     QTest::dataFailed = false;
 153     QTest::location = NoWhere;
 154
 155     QTestLog::leaveTestFunction();
 156
 157     clearExpectFail();
 158 }
 159
 160 const char *QTestResult::currentTestFunction()
 161 {
 162     return QTest::currentTestFunc;
 163 }
 164
 165 const char *QTestResult::currentDataTag()
 166 {
 167     return QTest::currentTestData ? QTest::currentTestData->dataTag()
 168                                    : static_cast<const char *>(0);
 169 }
 170
 171 const char *QTestResult::currentGlobalDataTag()
 172 {
 173     return QTest::currentGlobalTestData ? QTest::currentGlobalTestData->dataTag()
 174                                          : static_cast<const char *>(0);
 175 }
 176
 177 static bool isExpectFailData(const char *dataIndex)
 178 {
 179     if (!dataIndex || dataIndex[0] == '\0')
 180         return true;
 181     if (!QTest::currentTestData)
 182         return false;
 183     if (strcmp(dataIndex, QTest::currentTestData->dataTag()) == 0)
 184         return true;
 185     return false;
 186 }
 187
 188 bool QTestResult::expectFail(const char *dataIndex, const char *comment,
 189                              QTest::TestFailMode mode, const char *file, int line)
 190 {
 191     QTEST_ASSERT(comment);
 192     QTEST_ASSERT(mode > 0);
 193
 194     if (!isExpectFailData(dataIndex))
 195         return true; // we don't care
 196
 197     if (QTest::expectFailMode) {
 198         clearExpectFail();
 199         addFailure("Already expecting a fail", file, line);
 200         return false;
 201     }
 202
 203     QTest::expectFailMode = mode;
 204     QTest::expectFailComment = comment;
 205     return true;
 206 }
 207
 208 static bool checkStatement(bool statement, const char *msg, const char *file, int line)
 209 {
 210     if (statement) {
 211         if (QTest::expectFailMode) {
 212             QTestLog::addXPass(msg, file, line);
 213             bool doContinue = (QTest::expectFailMode == QTest::Continue);
 214             clearExpectFail();
 215             QTest::failed = true;
 216             ++QTest::fails;
 217             return doContinue;
 218         }
 219         return true;
 220     }
 221
 222     if (QTest::expectFailMode) {
 223         QTestLog::addXFail(QTest::expectFailComment, file, line);
 224         bool doContinue = (QTest::expectFailMode == QTest::Continue);
 225         clearExpectFail();
 226         return doContinue;
 227     }
 228
 229     QTestResult::addFailure(msg, file, line);
 230     return false;
 231 }
 232
 233 bool QTestResult::verify(bool statement, const char *statementStr,
 234                          const char *description, const char *file, int line)
 235 {
 236     char msg[1024];
 237
 238     if (QTestLog::verboseLevel() >= 2) {
 239         QTest::qt_snprintf(msg, 1024, "QVERIFY(%s)", statementStr);
 240         QTestLog::info(msg, file, line);
 241     }
 242
 243     QTest::qt_snprintf(msg, 1024, "'%s' returned FALSE. (%s)", statementStr, description);
 244
 245     return checkStatement(statement, msg, file, line);
 246 }
 247
 248 bool QTestResult::compare(bool success, const char *msg, const char *file, int line)
 249 {
 250     if (QTestLog::verboseLevel() >= 2) {
 251         QTestLog::info(msg, file, line);
 252     }
 253
 254     return checkStatement(success, msg, file, line);
 255 }
 256
 257 bool QTestResult::compare(bool success, const char *msg, char *val1, char *val2,
 258                           const char *actual, const char *expected, const char *file, int line)
 259 {
 260     QTEST_ASSERT(expected);
 261     QTEST_ASSERT(actual);
 262
 263     if (!val1 && !val2)
 264         return compare(success, msg, file, line);
 265
 266     char buf[1024];
 267     QTest::qt_snprintf(buf, 1024, "%s\n   Actual (%s): %s\n   Expected (%s): %s", msg,
 268                        actual, val1 ? val1 : "<null>",
 269                        expected, val2 ? val2 : "<null>");
 270     delete [] val1;
 271     delete [] val2;
 272     return compare(success, buf, file, line);
 273 }
 274
 275 void QTestResult::addFailure(const char *message, const char *file, int line)
 276 {
 277     clearExpectFail();
 278
 279     QTestLog::addFail(message, file, line);
 280     QTest::failed = true;
 281     QTest::dataFailed = true;
 282     ++QTest::fails;
 283 }
 284
 285 void QTestResult::addSkip(const char *message, QTest::SkipMode mode,
 286                           const char *file, int line)
 287 {
 288     clearExpectFail();
 289
 290     QTestLog::addSkip(message, mode, file, line);
 291     ++QTest::skips;
 292 }
 293
 294 QTestResult::TestLocation QTestResult::currentTestLocation()
 295 {
 296     return QTest::location;
 297 }
 298
 299 void QTestResult::setCurrentTestLocation(TestLocation loc)
 300 {
 301     QTest::location = loc;
 302 }
 303
 304 void QTestResult::setCurrentTestObject(const char *name)
 305 {
 306     QTest::currentTestObjectName = name;
 307 }
 308
 309 const char *QTestResult::currentTestObjectName()
 310 {
 311     return QTest::currentTestObjectName ? QTest::currentTestObjectName : "";
 312 }
 313
 314 int QTestResult::passCount()
 315 {
 316     return QTest::passes;
 317 }
 318
 319 int QTestResult::failCount()
 320 {
 321     return QTest::fails;
 322 }
 323
 324 int QTestResult::skipCount()
 325 {
 326     return QTest::skips;
 327 }
 328
 329 void QTestResult::ignoreMessage(QtMsgType type, const char *msg)
 330 {
 331     QTestLog::addIgnoreMessage(type, msg);
 332 }
 333
 334 bool QTestResult::testFailed()
 335 {
 336     return QTest::failed;
 337 }
 338
 339 void QTestResult::setSkipCurrentTest(bool value)
 340 {
 341     QTest::skipCurrentTest = value;
 342 }
 343
 344 bool QTestResult::skipCurrentTest()
 345 {
 346     return QTest::skipCurrentTest;
 347 }
 348
 349 QT_END_NAMESPACE