src/testlib/qsignaldumper.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/legal
   5 **
   6 ** This file is part of the QtTest module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** Commercial License Usage
  10 ** Licensees holding valid commercial Qt licenses may use this file in
  11 ** accordance with the commercial license agreement provided with the
  12 ** Software or, alternatively, in accordance with the terms contained in
  13 ** a written agreement between you and Digia.  For licensing terms and
  14 ** conditions see http://qt.digia.com/licensing.  For further information
  15 ** use the contact form at http://qt.digia.com/contact-us.
  16 **
  17 ** GNU Lesser General Public License Usage
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Digia gives you certain additional
  26 ** rights.  These rights are described in the Digia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** GNU General Public License Usage
  30 ** Alternatively, this file may be used under the terms of the GNU
  31 ** General Public License version 3.0 as published by the Free Software
  32 ** Foundation and appearing in the file LICENSE.GPL included in the
  33 ** packaging of this file.  Please review the following information to
  34 ** ensure the GNU General Public License version 3.0 requirements will be
  35 ** met: http://www.gnu.org/copyleft/gpl.html.
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QtTest/private/qsignaldumper_p.h>
  43
  44 #include <QtCore/qlist.h>
  45 #include <QtCore/qmetaobject.h>
  46 #include <QtCore/qmetatype.h>
  47 #include <QtCore/qobject.h>
  48 #include <QtCore/qvariant.h>
  49
  50 #include <QtTest/private/qtestlog_p.h>
  51
  52 #include <QtCore/private/qmetaobject_p.h>
  53
  54 QT_BEGIN_NAMESPACE
  55
  56 namespace QTest
  57 {
  58
  59 inline static void qPrintMessage(const QByteArray &ba)
  60 {
  61     QTestLog::info(ba.constData(), 0, 0);
  62 }
  63
  64 Q_GLOBAL_STATIC(QList<QByteArray>, ignoreClasses)
  65 static int iLevel = 0;
  66 static int ignoreLevel = 0;
  67 enum { IndentSpacesCount = 4 };
  68
  69 static void qSignalDumperCallback(QObject *caller, int signal_index, void **argv)
  70 {
  71     Q_ASSERT(caller); Q_ASSERT(argv); Q_UNUSED(argv);
  72     const QMetaObject *mo = caller->metaObject();
  73     Q_ASSERT(mo);
  74     QMetaMethod member = QMetaObjectPrivate::signal(mo, signal_index);
  75     Q_ASSERT(member.isValid());
  76
  77     if (QTest::ignoreClasses() && QTest::ignoreClasses()->contains(mo->className())) {
  78         ++QTest::ignoreLevel;
  79         return;
  80     }
  81
  82     QByteArray str;
  83     str.fill(' ', QTest::iLevel++ * QTest::IndentSpacesCount);
  84     str += "Signal: ";
  85     str += mo->className();
  86     str += '(';
  87
  88     QString objname = caller->objectName();
  89     str += objname.toLocal8Bit();
  90     if (!objname.isEmpty())
  91         str += ' ';
  92     str += QByteArray::number(quintptr(caller), 16);
  93
  94     str += ") ";
  95     str += member.name();
  96     str += " (";
  97
  98     QList<QByteArray> args = member.parameterTypes();
  99     for (int i = 0; i < args.count(); ++i) {
 100         const QByteArray &arg = args.at(i);
 101         int typeId = QMetaType::type(args.at(i).constData());
 102         if (arg.endsWith('*') || arg.endsWith('&')) {
 103             str += '(';
 104             str += arg;
 105             str += ')';
 106             if (arg.endsWith('&'))
 107                 str += '@';
 108
 109             quintptr addr = quintptr(*reinterpret_cast<void **>(argv[i + 1]));
 110             str.append(QByteArray::number(addr, 16));
 111         } else if (typeId != QMetaType::UnknownType) {
 112             Q_ASSERT(typeId != QMetaType::Void); // void parameter => metaobject is corrupt
 113             str.append(arg)
 114                 .append('(')
 115                 .append(QVariant(typeId, argv[i + 1]).toString().toLocal8Bit())
 116                 .append(')');
 117         }
 118         str.append(", ");
 119     }
 120     if (str.endsWith(", "))
 121         str.chop(2);
 122     str.append(')');
 123     qPrintMessage(str);
 124 }
 125
 126 static void qSignalDumperCallbackSlot(QObject *caller, int method_index, void **argv)
 127 {
 128     Q_ASSERT(caller); Q_ASSERT(argv); Q_UNUSED(argv);
 129     const QMetaObject *mo = caller->metaObject();
 130     Q_ASSERT(mo);
 131     QMetaMethod member = mo->method(method_index);
 132     if (!member.isValid())
 133         return;
 134
 135     if (QTest::ignoreLevel ||
 136             (QTest::ignoreClasses() && QTest::ignoreClasses()->contains(mo->className())))
 137         return;
 138
 139     QByteArray str;
 140     str.fill(' ', QTest::iLevel * QTest::IndentSpacesCount);
 141     str += "Slot: ";
 142     str += mo->className();
 143     str += '(';
 144
 145     QString objname = caller->objectName();
 146     str += objname.toLocal8Bit();
 147     if (!objname.isEmpty())
 148         str += ' ';
 149     str += QByteArray::number(quintptr(caller), 16);
 150
 151     str += ") ";
 152     str += member.methodSignature();
 153     qPrintMessage(str);
 154 }
 155
 156 static void qSignalDumperCallbackEndSignal(QObject *caller, int /*signal_index*/)
 157 {
 158     Q_ASSERT(caller); Q_ASSERT(caller->metaObject());
 159     if (QTest::ignoreClasses()
 160             && QTest::ignoreClasses()->contains(caller->metaObject()->className())) {
 161         --QTest::ignoreLevel;
 162         Q_ASSERT(QTest::ignoreLevel >= 0);
 163         return;
 164     }
 165     --QTest::iLevel;
 166     Q_ASSERT(QTest::iLevel >= 0);
 167 }
 168
 169 }
 170
 171 void QSignalDumper::startDump()
 172 {
 173     static QSignalSpyCallbackSet set = { QTest::qSignalDumperCallback,
 174         QTest::qSignalDumperCallbackSlot, QTest::qSignalDumperCallbackEndSignal, 0 };
 175     qt_register_signal_spy_callbacks(set);
 176 }
 177
 178 void QSignalDumper::endDump()
 179 {
 180     static QSignalSpyCallbackSet nset = { 0, 0, 0 ,0 };
 181     qt_register_signal_spy_callbacks(nset);
 182 }
 183
 184 void QSignalDumper::ignoreClass(const QByteArray &klass)
 185 {
 186     if (QTest::ignoreClasses())
 187         QTest::ignoreClasses()->append(klass);
 188 }
 189
 190 void QSignalDumper::clearIgnoredClasses()
 191 {
 192     if (QTest::ignoreClasses())
 193         QTest::ignoreClasses()->clear();
 194 }
 195
 196 QT_END_NAMESPACE