typehierarchybuilder_test.cpp 6.38 KB
Newer Older
1 2
/****************************************************************************
**
3
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 5 6 7 8 9 10 11 12
** Contact: http://www.qt-project.org/legal
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
Eike Ziller's avatar
Eike Ziller committed
13 14
** conditions see http://www.qt.io/licensing.  For further information
** use the contact form at http://www.qt.io/contact-us.
15 16 17
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
Eike Ziller's avatar
Eike Ziller committed
18 19 20 21 22 23
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file.  Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 25 26 27 28 29 30 31 32
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/

#include "cpptoolsplugin.h"

33
#include "cppmodelmanager.h"
34
#include "cpptoolstestcase.h"
35 36 37
#include "typehierarchybuilder.h"

#include <cplusplus/Overview.h>
38
#include <cplusplus/SymbolVisitor.h>
39
#include <utils/algorithm.h>
40 41 42 43 44 45 46 47 48
#include <utils/fileutils.h>

#include <QDir>
#include <QtTest>

using namespace CPlusPlus;
using namespace CppTools;
using namespace CppTools::Internal;

49 50
Q_DECLARE_METATYPE(QList<Tests::TestDocument>)

51 52 53 54 55 56 57 58 59
namespace {

QString toString(const TypeHierarchy &hierarchy, int indent = 0)
{
    Symbol *symbol = hierarchy.symbol();
    QString result = QString(indent, QLatin1Char(' '))
        + Overview().prettyName(symbol->name()) + QLatin1Char('\n');

    QList<TypeHierarchy> sortedHierarchy = hierarchy.hierarchy();
60 61 62 63
    Overview oo;
    Utils::sort(sortedHierarchy, [&oo](const TypeHierarchy &h1, const TypeHierarchy &h2) -> bool {
        return oo.prettyName(h1.symbol()->name()) < oo.prettyName(h2.symbol()->name());
    });
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
    foreach (TypeHierarchy childHierarchy, sortedHierarchy)
        result += toString(childHierarchy, indent + 2);
    return result;
}

class FindFirstClassInDocument: private SymbolVisitor
{
public:
    FindFirstClassInDocument() : m_clazz(0) {}

    Class *operator()(const Document::Ptr &document)
    {
        accept(document->globalNamespace());
        return m_clazz;
    }

private:
    bool preVisit(Symbol *symbol)
    {
        if (m_clazz)
            return false;

        if (Class *c = symbol->asClass()) {
            m_clazz = c;
            return false;
        }

        return true;
    }

94
private:
95 96 97
    Class *m_clazz;
};

98
class TypeHierarchyBuilderTestCase : public Tests::TestCase
99 100
{
public:
101 102
    TypeHierarchyBuilderTestCase(const QList<Tests::TestDocument> &documents,
                                 const QString &expectedHierarchy)
103
    {
104 105
        QVERIFY(succeededSoFar());

106 107 108 109 110
        Tests::TemporaryDir temporaryDir;
        QVERIFY(temporaryDir.isValid());

        QList<Tests::TestDocument> documents_ = documents;

111
        // Write files
112
        QSet<QString> filePaths;
113 114 115 116
        for (int i = 0, size = documents_.size(); i < size; ++i) {
            documents_[i].setBaseDirectory(temporaryDir.path());
            QVERIFY(documents_[i].writeToDisk());
            filePaths << documents_[i].filePath();
117 118 119
        }

        // Parse files
120 121
        QVERIFY(parseFiles(filePaths));
        const Snapshot snapshot = globalSnapshot();
122 123

        // Get class for which to generate the hierarchy
124
        const Document::Ptr firstDocument = snapshot.document(documents_.first().filePath());
125 126
        QVERIFY(firstDocument);
        QVERIFY(firstDocument->diagnosticMessages().isEmpty());
127 128 129 130 131 132 133 134 135 136
        Class *clazz = FindFirstClassInDocument()(firstDocument);
        QVERIFY(clazz);

        // Generate and compare hierarchies
        TypeHierarchyBuilder typeHierarchyBuilder(clazz, snapshot);
        const TypeHierarchy hierarchy = typeHierarchyBuilder.buildDerivedTypeHierarchy();

        const QString actualHierarchy = toString(hierarchy);
//        Uncomment for updating/generating reference data:
//        qDebug() << actualHierarchy;
137
        QCOMPARE(actualHierarchy, expectedHierarchy);
138 139 140 141 142 143 144
    }
};

} // anonymous namespace

void CppToolsPlugin::test_typehierarchy_data()
{
145
    QTest::addColumn<QList<Tests::TestDocument> >("documents");
146 147
    QTest::addColumn<QString>("expectedHierarchy");

148
    typedef Tests::TestDocument TestDocument;
149 150 151

    QTest::newRow("basic-single-document")
        << (QList<TestDocument>()
152 153 154 155 156 157
            << TestDocument("a.h",
                            "class A {};\n"
                            "class B : public A {};\n"
                            "class C1 : public B {};\n"
                            "class C2 : public B {};\n"
                            "class D : public C1 {};\n"))
158 159 160 161 162 163 164 165 166
        << QString::fromLatin1(
            "A\n"
            "  B\n"
            "    C1\n"
            "      D\n"
            "    C2\n" );

    QTest::newRow("basic-multiple-documents")
        << (QList<TestDocument>()
167 168 169 170 171 172 173 174 175 176 177 178 179 180
            << TestDocument("a.h",
                            "class A {};")
            << TestDocument("b.h",
                            "#include \"a.h\"\n"
                            "class B : public A {};")
            << TestDocument("c1.h",
                            "#include \"b.h\"\n"
                            "class C1 : public B {};")
            << TestDocument("c2.h",
                            "#include \"b.h\"\n"
                            "class C2 : public B {};")
            << TestDocument("d.h",
                            "#include \"c1.h\"\n"
                            "class D : public C1 {};"))
181 182 183 184 185 186 187 188 189 190 191
        << QString::fromLatin1(
            "A\n"
            "  B\n"
            "    C1\n"
            "      D\n"
            "    C2\n"
            );
}

void CppToolsPlugin::test_typehierarchy()
{
192
    QFETCH(QList<Tests::TestDocument>, documents);
193 194
    QFETCH(QString, expectedHierarchy);

195
    TypeHierarchyBuilderTestCase(documents, expectedHierarchy);
196
}