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/qtestassert.h"

    43 

    44 #include "QtTest/private/qtestlog_p.h"

    45 #include "QtTest/private/qtestresult_p.h"

    46 #include "QtTest/private/qabstracttestlogger_p.h"

    47 #include "QtTest/private/qplaintestlogger_p.h"

    48 #include "QtTest/private/qxmltestlogger_p.h"

    49 #include <QtCore/qatomic.h>

    50 #include <QtCore/qbytearray.h>

    51 

    52 #include <stdlib.h>

    53 #include <string.h>

    54 #include <limits.h>

    55 

    56 

    57 #include "qtestlogger_p.h"

    58 

    59 QT_BEGIN_NAMESPACE

    60 

    61 namespace QTest {

    62 

    63     struct IgnoreResultList

    64     {

    65         inline IgnoreResultList(QtMsgType tp, const char *message)

    66             : type(tp), next(0)

    67         { msg = qstrdup(message); }

    68         inline ~IgnoreResultList()

    69         { delete [] msg; }

    70 

    71         static inline void clearList(IgnoreResultList *&list)

    72         {

    73             while (list) {

    74                 IgnoreResultList *current = list;

    75                 list = list->next;

    76                 delete current;

    77             }

    78         }

    79 

    80         QtMsgType type;

    81         char *msg;

    82         IgnoreResultList *next;

    83     };

    84 

    85     static IgnoreResultList *ignoreResultList = 0;

    86 

    87     static QTestLog::LogMode logMode = QTestLog::Plain;

    88     static QTestLog::FlushMode flushMode = QTestLog::NoFlush;

    89     static int verbosity = 0;

    90     static int maxWarnings = 2002;

    91 

    92     static QAbstractTestLogger *testLogger = 0;

    93     static const char *outFile = 0;

    94 

    95     static QtMsgHandler oldMessageHandler;

    96 

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

    98     {

    99         IgnoreResultList *last = 0;

   100         IgnoreResultList *list = ignoreResultList;

   101         while (list) {

   102             if (list->type == type && strcmp(msg, list->msg) == 0) {

   103                 // remove the item from the list

   104                 if (last)

   105                     last->next = list->next;

   106                 else if (list->next)

   107                     ignoreResultList = list->next;

   108                 else

   109                     ignoreResultList = 0;

   110 

   111                 delete list;

   112                 return true;

   113             }

   114 

   115             last = list;

   116             list = list->next;

   117         }

   118         return false;

   119     }

   120 

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

   122     {

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

   124 

   125         if (!msg || !QTest::testLogger) {

   126             // if this goes wrong, something is seriously broken.

   127             qInstallMsgHandler(oldMessageHandler);

   128             QTEST_ASSERT(msg);

   129             QTEST_ASSERT(QTest::testLogger);

   130         }

   131 

   132         if (handleIgnoredMessage(type, msg))

   133             // the message is expected, so just swallow it.

   134             return;

   135 

   136         if (type != QtFatalMsg) {

   137             if (counter <= 0)

   138                 return;

   139 

   140             if (!counter.deref()) {

   141                 QTest::testLogger->addMessage(QAbstractTestLogger::QSystem,

   142                         "Maximum amount of warnings exceeded. Use -maxwarnings to override.");

   143                 return;

   144             }

   145         }

   146 

   147         switch (type) {

   148         case QtDebugMsg:

   149             QTest::testLogger->addMessage(QAbstractTestLogger::QDebug, msg);

   150             break;

   151         case QtCriticalMsg:

   152             QTest::testLogger->addMessage(QAbstractTestLogger::QSystem, msg);

   153             break;

   154         case QtWarningMsg:

   155             QTest::testLogger->addMessage(QAbstractTestLogger::QWarning, msg);

   156             break;

   157         case QtFatalMsg:

   158             QTest::testLogger->addMessage(QAbstractTestLogger::QFatal, msg);

   159             /* Right now, we're inside the custom message handler and we're

   160              * being qt_message_output in qglobal.cpp. After we return from

   161              * this function, it will proceed with calling exit() and abort()

   162              * and hence crash. Therefore, we call these logging functions such

   163              * that we wrap up nicely, and in particular produce well-formed XML. */

   164             QTestResult::addFailure("Received a fatal error.", "Unknown file", 0);

   165             QTestLog::leaveTestFunction();

   166             QTestLog::stopLogging();

   167             break;

   168         }

   169     }

   170 

   171 }

   172 

   173 QTestLog::QTestLog()

   174 {

   175 }

   176 

   177 QTestLog::~QTestLog()

   178 {

   179 }

   180 

   181 void QTestLog::enterTestFunction(const char* function)

   182 {

   183     QTEST_ASSERT(QTest::testLogger);

   184     QTEST_ASSERT(function);

   185 

   186     QTest::testLogger->enterTestFunction(function);

   187 }

   188 

   189 int QTestLog::unhandledIgnoreMessages()

   190 {

   191     int i = 0;

   192     QTest::IgnoreResultList *list = QTest::ignoreResultList;

   193     while (list) {

   194         ++i;

   195         list = list->next;

   196     }

   197     return i;

   198 }

   199 

   200 void QTestLog::leaveTestFunction()

   201 {

   202     QTEST_ASSERT(QTest::testLogger);

   203 

   204     QTest::IgnoreResultList::clearList(QTest::ignoreResultList);

   205     QTest::testLogger->leaveTestFunction();

   206 }

   207 

   208 void QTestLog::printUnhandledIgnoreMessages()

   209 {

   210     QTEST_ASSERT(QTest::testLogger);

   211 

   212     char msg[1024];

   213     QTest::IgnoreResultList *list = QTest::ignoreResultList;

   214     while (list) {

   215         QTest::qt_snprintf(msg, 1024, "Did not receive message: \"%s\"", list->msg);

   216         QTest::testLogger->addMessage(QAbstractTestLogger::Info, msg);

   217 

   218         list = list->next;

   219     }

   220 }

   221 

   222 void QTestLog::addPass(const char *msg)

   223 {

   224     QTEST_ASSERT(QTest::testLogger);

   225     QTEST_ASSERT(msg);

   226 

   227     QTest::testLogger->addIncident(QAbstractTestLogger::Pass, msg);

   228 }

   229 

   230 void QTestLog::addFail(const char *msg, const char *file, int line)

   231 {

   232     QTEST_ASSERT(QTest::testLogger);

   233 

   234     QTest::testLogger->addIncident(QAbstractTestLogger::Fail, msg, file, line);

   235 }

   236 

   237 void QTestLog::addXFail(const char *msg, const char *file, int line)

   238 {

   239     QTEST_ASSERT(QTest::testLogger);

   240     QTEST_ASSERT(msg);

   241     QTEST_ASSERT(file);

   242 

   243     QTest::testLogger->addIncident(QAbstractTestLogger::XFail, msg, file, line);

   244 }

   245 

   246 void QTestLog::addXPass(const char *msg, const char *file, int line)

   247 {

   248     QTEST_ASSERT(QTest::testLogger);

   249     QTEST_ASSERT(msg);

   250     QTEST_ASSERT(file);

   251 

   252     QTest::testLogger->addIncident(QAbstractTestLogger::XPass, msg, file, line);

   253 }

   254 

   255 void QTestLog::addSkip(const char *msg, QTest::SkipMode /*mode*/,

   256                        const char *file, int line)

   257 {

   258     QTEST_ASSERT(QTest::testLogger);

   259     QTEST_ASSERT(msg);

   260     QTEST_ASSERT(file);

   261 

   262     QTest::testLogger->addMessage(QAbstractTestLogger::Skip, msg, file, line);

   263 }

   264 

   265 void QTestLog::addBenchmarkResult(const QBenchmarkResult &result)

   266 {

   267     QTEST_ASSERT(QTest::testLogger);

   268     QTest::testLogger->addBenchmarkResult(result);

   269 }

   270 

   271 void QTestLog::startLogging()

   272 {

   273     QTEST_ASSERT(!QTest::testLogger);

   274 

   275     switch (QTest::logMode) {

   276         case QTestLog::Plain:

   277             QTest::testLogger = new QPlainTestLogger;

   278             break;

   279         case QTestLog::XML:{

   280             if(QTest::flushMode == QTestLog::FLushOn)

   281                 QTest::testLogger = new QXmlTestLogger(QXmlTestLogger::Complete);

   282             else

   283                 QTest::testLogger = new QTestLogger(QTestLogger::TLF_XML);

   284             break;

   285         }case QTestLog::LightXML:{

   286             if(QTest::flushMode == QTestLog::FLushOn)

   287                 QTest::testLogger = new QXmlTestLogger(QXmlTestLogger::Light);

   288             else

   289                 QTest::testLogger = new QTestLogger(QTestLogger::TLF_LightXml);

   290             break;

   291         }case QTestLog::XunitXML:

   292             QTest::testLogger = new QTestLogger(QTestLogger::TLF_XunitXml);

   293         }

   294 

   295     QTest::testLogger->startLogging();

   296 

   297     QTest::oldMessageHandler = qInstallMsgHandler(QTest::messageHandler);

   298 }

   299 

   300 void QTestLog::stopLogging()

   301 {

   302     qInstallMsgHandler(QTest::oldMessageHandler);

   303 

   304     QTEST_ASSERT(QTest::testLogger);

   305     QTest::testLogger->stopLogging();

   306     delete QTest::testLogger;

   307     QTest::testLogger = 0;

   308 }

   309 

   310 void QTestLog::warn(const char *msg)

   311 {

   312     QTEST_ASSERT(QTest::testLogger);

   313     QTEST_ASSERT(msg);

   314 

   315     QTest::testLogger->addMessage(QAbstractTestLogger::Warn, msg);

   316 }

   317 

   318 void QTestLog::info(const char *msg, const char *file, int line)

   319 {

   320     QTEST_ASSERT(msg);

   321 

   322     if (QTest::testLogger)

   323         QTest::testLogger->addMessage(QAbstractTestLogger::Info, msg, file, line);

   324 }

   325 

   326 void QTestLog::setLogMode(LogMode mode)

   327 {

   328     QTest::logMode = mode;

   329 }

   330 

   331 QTestLog::LogMode QTestLog::logMode()

   332 {

   333     return QTest::logMode;

   334 }

   335 

   336 void QTestLog::setVerboseLevel(int level)

   337 {

   338     QTest::verbosity = level;

   339 }

   340 

   341 int QTestLog::verboseLevel()

   342 {

   343     return QTest::verbosity;

   344 }

   345 

   346 void QTestLog::addIgnoreMessage(QtMsgType type, const char *msg)

   347 {

   348     QTest::IgnoreResultList *item = new QTest::IgnoreResultList(type, msg);

   349 

   350     QTest::IgnoreResultList *list = QTest::ignoreResultList;

   351     if (!list) {

   352         QTest::ignoreResultList = item;

   353         return;

   354     }

   355     while (list->next)

   356         list = list->next;

   357     list->next = item;

   358 }

   359 

   360 void QTestLog::redirectOutput(const char *fileName)

   361 {

   362     QTEST_ASSERT(fileName);

   363 

   364     QTest::outFile = fileName;

   365 }

   366 

   367 const char *QTestLog::outputFileName()

   368 {

   369     return QTest::outFile;

   370 }

   371 

   372 void QTestLog::setMaxWarnings(int m)

   373 {

   374     QTest::maxWarnings = m <= 0 ? INT_MAX : m + 2;

   375 }

   376 

   377 void QTestLog::setFlushMode(FlushMode mode)

   378 {

   379     QTest::flushMode = mode;

   380 }

   381 

   382 QT_END_NAMESPACE