cppcompletion_test.cpp 96.5 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
2
**
Eike Ziller's avatar
Eike Ziller committed
3 4
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
7
**
hjk's avatar
hjk committed
8 9 10 11
** 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
Eike Ziller's avatar
Eike Ziller committed
12 13
** a written agreement between you and The Qt Company.  For licensing terms and
** conditions see http://www.qt.io/terms-conditions.  For further information
Eike Ziller's avatar
Eike Ziller committed
14
** use the contact form at http://www.qt.io/contact-us.
15 16
**
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17
** 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.
hjk's avatar
hjk committed
24
**
Eike Ziller's avatar
Eike Ziller committed
25 26
** In addition, as a special exception, The Qt Company gives you certain additional
** rights.  These rights are described in The Qt Company LGPL Exception
27 28
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
29
****************************************************************************/
30

31
#include "cppcompletionassist.h"
32
#include "cppmodelmanager.h"
33 34
#include "cpptoolsplugin.h"
#include "cpptoolstestcase.h"
35 36

#include <texteditor/codeassist/iassistproposal.h>
37
#include <texteditor/convenience.h>
38
#include <texteditor/texteditor.h>
39 40
#include <texteditor/textdocument.h>
#include <coreplugin/editormanager/editormanager.h>
41 42

#include <utils/changeset.h>
43 44
#include <utils/fileutils.h>

hjk's avatar
hjk committed
45
#include <QDebug>
46
#include <QDir>
47 48
#include <QTextDocument>
#include <QtTest>
49 50 51 52 53 54 55 56 57 58

/*!
    Tests for code completion.
 */
using namespace CPlusPlus;
using namespace CppTools;
using namespace CppTools::Internal;
using namespace TextEditor;
using namespace Core;

59 60 61
namespace {

typedef QByteArray _;
62

63
class CompletionTestCase : public Tests::TestCase
64 65
{
public:
66 67
    CompletionTestCase(const QByteArray &sourceText, const QByteArray &textToInsert = QByteArray(),
                       bool isObjC = false)
68
        : m_position(-1), m_editorWidget(0), m_textDocument(0), m_editor(0)
69
    {
70 71 72
        QVERIFY(succeededSoFar());
        m_succeededSoFar = false;

73 74 75 76
        m_source = sourceText;
        m_position = m_source.indexOf('@');
        QVERIFY(m_position != -1);
        m_source[m_position] = ' ';
77 78

        // Write source to file
79 80
        m_temporaryDir.reset(new Tests::TemporaryDir());
        QVERIFY(m_temporaryDir->isValid());
81
        const QByteArray fileExt = isObjC ? "mm" : "h";
82
        const QString fileName = m_temporaryDir->createFile("file." + fileExt, m_source);
83
        QVERIFY(!fileName.isEmpty());
84 85

        // Open in editor
86 87 88
        m_editor = EditorManager::openEditor(fileName);
        QVERIFY(m_editor);
        closeEditorAtEndOfTestCase(m_editor);
89
        m_editorWidget = qobject_cast<TextEditorWidget *>(m_editor->widget());
90
        QVERIFY(m_editorWidget);
91

92
        m_textDocument = m_editorWidget->document();
93 94

        // Get Document
95
        const Document::Ptr document = waitForFileInGlobalSnapshot(fileName);
96 97
        QVERIFY(document);
        QVERIFY(document->diagnosticMessages().isEmpty());
98

99
        m_snapshot.insert(document);
100 101 102

        if (!textToInsert.isEmpty())
            insertText(textToInsert);
103 104

        m_succeededSoFar = true;
105
    }
106

107 108 109
    QStringList getCompletions(bool *replaceAccessOperator = 0) const
    {
        QStringList completions;
110 111
        LanguageFeatures languageFeatures = LanguageFeatures::defaultFeatures();
        languageFeatures.objCEnabled = false;
112
        CppCompletionAssistInterface *ai
113
            = new CppCompletionAssistInterface(m_editorWidget->textDocument()->filePath().toString(),
114
                                               m_textDocument, m_position,
115
                                               ExplicitlyInvoked, m_snapshot,
116 117
                                               ProjectPart::HeaderPaths(),
                                               languageFeatures);
118
        InternalCppCompletionAssistProcessor processor;
119 120 121

        const Tests::IAssistProposalScopedPointer proposal(processor.perform(ai));
        if (!proposal.d)
122
            return completions;
123
        IAssistProposalModel *model = proposal.d->model();
124 125 126 127 128 129
        if (!model)
            return completions;
        CppAssistProposalModel *listmodel = dynamic_cast<CppAssistProposalModel *>(model);
        if (!listmodel)
            return completions;

130
        const int pos = proposal.d->basePosition();
131
        const int length = m_position - pos;
132
        const QString prefix = Convenience::textAt(QTextCursor(m_textDocument), pos,
133
                                                   length);
134 135
        if (!prefix.isEmpty())
            listmodel->filter(prefix);
136 137
        if (listmodel->isSortable(prefix))
            listmodel->sort(prefix);
138

139 140 141 142 143
        for (int i = 0; i < listmodel->size(); ++i)
            completions << listmodel->text(i);

        if (replaceAccessOperator)
            *replaceAccessOperator = listmodel->m_replaceDotForArrow;
144

145 146
        return completions;
    }
147

148 149 150
    void insertText(const QByteArray &text)
    {
        Utils::ChangeSet change;
151 152
        change.insert(m_position, QLatin1String(text));
        QTextCursor cursor(m_textDocument);
153
        change.apply(&cursor);
154
        m_position += text.length();
155
    }
156

157
private:
158 159 160
    QByteArray m_source;
    int m_position;
    Snapshot m_snapshot;
161
    QScopedPointer<Tests::TemporaryDir> m_temporaryDir;
162
    TextEditorWidget *m_editorWidget;
163 164
    QTextDocument *m_textDocument;
    IEditor *m_editor;
165
};
166

167 168 169 170 171 172
bool isProbablyGlobalCompletion(const QStringList &list)
{
    const int numberOfPrimitivesAndBasicKeywords = (T_LAST_PRIMITIVE - T_FIRST_PRIMITIVE)
            + (T_FIRST_OBJC_AT_KEYWORD - T_FIRST_KEYWORD);

    return list.size() >= numberOfPrimitivesAndBasicKeywords
173 174
        && list.contains(QLatin1String("override"))
        && list.contains(QLatin1String("final"))
175 176 177 178
        && list.contains(QLatin1String("if"))
        && list.contains(QLatin1String("bool"));
}

179 180
} // anonymous namespace

181 182 183 184 185 186 187 188 189 190 191 192 193 194
void CppToolsPlugin::test_completion_basic_1()
{
    const QByteArray source =
            "class Foo\n"
            "{\n"
            "    void foo();\n"
            "    int m;\n"
            "};\n"
            "\n"
            "void func() {\n"
            "    Foo f;\n"
            "    @\n"
            "}";
    CompletionTestCase test(source);
195
    QVERIFY(test.succeededSoFar());
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222

    QStringList basicCompletions = test.getCompletions();
    QVERIFY(!basicCompletions.contains(QLatin1String("foo")));
    QVERIFY(!basicCompletions.contains(QLatin1String("m")));
    QVERIFY(basicCompletions.contains(QLatin1String("Foo")));
    QVERIFY(basicCompletions.contains(QLatin1String("func")));
    QVERIFY(basicCompletions.contains(QLatin1String("f")));

    test.insertText("f.");

    QStringList memberCompletions = test.getCompletions();
    QVERIFY(memberCompletions.contains(QLatin1String("foo")));
    QVERIFY(memberCompletions.contains(QLatin1String("m")));
    QVERIFY(!memberCompletions.contains(QLatin1String("func")));
    QVERIFY(!memberCompletions.contains(QLatin1String("f")));
}

void CppToolsPlugin::test_completion_prefix_first_QTCREATORBUG_8737()
{
    const QByteArray source =
            "void f()\n"
            "{\n"
            "    int a_b_c, a_c, a_c_a;\n"
            "    @;\n"
            "}\n"
            ;
    CompletionTestCase test(source, "a_c");
223
    QVERIFY(test.succeededSoFar());
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248

    QStringList completions = test.getCompletions();

    QVERIFY(completions.size() >= 2);
    QCOMPARE(completions.at(0), QLatin1String("a_c"));
    QCOMPARE(completions.at(1), QLatin1String("a_c_a"));
    QVERIFY(completions.contains(QLatin1String("a_b_c")));
}

void CppToolsPlugin::test_completion_prefix_first_QTCREATORBUG_9236()
{
    const QByteArray source =
            "class r_etclass\n"
            "{\n"
            "public:\n"
            "    int raEmTmber;\n"
            "    void r_e_t(int re_t)\n"
            "    {\n"
            "        int r_et;\n"
            "        int rETUCASE;\n"
            "        @\n"
            "    }\n"
            "};\n"
            ;
    CompletionTestCase test(source, "ret");
249
    QVERIFY(test.succeededSoFar());
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267

    QStringList completions = test.getCompletions();
    QVERIFY(completions.size() >= 2);
    QCOMPARE(completions.at(0), QLatin1String("return"));
    QCOMPARE(completions.at(1), QLatin1String("rETUCASE"));
    QVERIFY(completions.contains(QLatin1String("r_etclass")));
    QVERIFY(completions.contains(QLatin1String("raEmTmber")));
    QVERIFY(completions.contains(QLatin1String("r_e_t")));
    QVERIFY(completions.contains(QLatin1String("re_t")));
    QVERIFY(completions.contains(QLatin1String("r_et")));
}

void CppToolsPlugin::test_completion_template_function()
{
    QFETCH(QByteArray, code);
    QFETCH(QStringList, expectedCompletions);

    CompletionTestCase test(code);
268
    QVERIFY(test.succeededSoFar());
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296

    QStringList actualCompletions = test.getCompletions();
    QString errorPattern(QLatin1String("Completion not found: %1"));
    foreach (const QString &completion, expectedCompletions) {
        QByteArray errorMessage = errorPattern.arg(completion).toUtf8();
        QVERIFY2(actualCompletions.contains(completion), errorMessage.data());
    }
}

void CppToolsPlugin::test_completion_template_function_data()
{
    QTest::addColumn<QByteArray>("code");
    QTest::addColumn<QStringList>("expectedCompletions");

    QByteArray code;
    QStringList completions;

    code =
           "template <class tclass, typename tname, int tint>\n"
           "tname Hello(const tclass &e)\n"
           "{\n"
           "    tname e2 = e;\n"
           "    @\n"
           "}";

    completions.append(QLatin1String("tclass"));
    completions.append(QLatin1String("tname"));
    completions.append(QLatin1String("tint"));
297

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
    QTest::newRow("case: template parameters in template function body")
            << code << completions;

    completions.clear();

    code =
           "template <class tclass, typename tname, int tint>\n"
           "tname Hello(const tclass &e, @)\n"
           "{\n"
           "    tname e2 = e;\n"
           "}";

    completions.append(QLatin1String("tclass"));
    completions.append(QLatin1String("tname"));
    completions.append(QLatin1String("tint"));
313

314 315 316 317 318 319 320 321 322 323 324
    QTest::newRow("case: template parameters in template function parameters list")
            << code << completions;
}

void CppToolsPlugin::test_completion()
{
    QFETCH(QByteArray, code);
    QFETCH(QByteArray, prefix);
    QFETCH(QStringList, expectedCompletions);

    CompletionTestCase test(code, prefix);
325
    QVERIFY(test.succeededSoFar());
326 327 328 329 330

    QStringList actualCompletions = test.getCompletions();
    actualCompletions.sort();
    expectedCompletions.sort();

Nikolai Kosjar's avatar
Nikolai Kosjar committed
331
    QEXPECT_FAIL("template_as_base: explicit typedef from base", "QTCREATORBUG-14218", Abort);
332 333 334 335 336
    QEXPECT_FAIL("enum_in_function_in_struct_in_function", "QTCREATORBUG-13757", Abort);
    QEXPECT_FAIL("enum_in_function_in_struct_in_function_cxx11", "QTCREATORBUG-13757", Abort);
    QEXPECT_FAIL("enum_in_function_in_struct_in_function_anon", "QTCREATORBUG-13757", Abort);
    QEXPECT_FAIL("enum_in_class_accessed_in_member_func_cxx11", "QTCREATORBUG-13757", Abort);
    QEXPECT_FAIL("enum_in_class_accessed_in_member_func_inline_cxx11", "QTCREATORBUG-13757", Abort);
Nikolai Kosjar's avatar
Nikolai Kosjar committed
337 338 339 340
    QEXPECT_FAIL("pointer_indirect_specialization", "QTCREATORBUG-14141", Abort);
    QEXPECT_FAIL("pointer_indirect_specialization_typedef", "QTCREATORBUG-14141", Abort);
    QEXPECT_FAIL("pointer_indirect_specialization_double_indirection", "QTCREATORBUG-14141", Abort);
    QEXPECT_FAIL("pointer_indirect_specialization_double_indirection_with_base", "QTCREATORBUG-14141", Abort);
341 342 343
    QCOMPARE(actualCompletions, expectedCompletions);
}

344 345 346 347
void CppToolsPlugin::test_global_completion_data()
{
    QTest::addColumn<QByteArray>("code");
    QTest::addColumn<QByteArray>("prefix");
348
    QTest::addColumn<QStringList>("requiredCompletionItems");
349 350 351 352 353

    // Check that special completion after '&' for Qt5 signal/slots does not
    // interfere global completion after '&'
    QTest::newRow("global completion after & in return expression")
         << _("void f() { foo(myObject, @); }\n")
354 355
         << _("&")
         << QStringList();
356 357
    QTest::newRow("global completion after & in function argument")
         << _("int f() { return @; }\n")
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
         << _("&")
         << QStringList();

    // Check global completion after one line comments
    const QByteArray codeTemplate = "int myGlobal;\n"
                                    "<REPLACEMENT>\n"
                                    "@\n";
    const QStringList replacements = QStringList()
            << QLatin1String("// text")
            << QLatin1String("// text.")
            << QLatin1String("/// text")
            << QLatin1String("/// text.")
               ;
    foreach (const QString &replacement, replacements) {
        QByteArray code = codeTemplate;
        code.replace("<REPLACEMENT>", replacement.toUtf8());
        const QByteArray tag = _("completion after comment: ") + replacement.toUtf8();
        QTest::newRow(tag) << code << QByteArray() << QStringList(QLatin1String("myGlobal"));
    }
377 378 379 380 381 382
}

void CppToolsPlugin::test_global_completion()
{
    QFETCH(QByteArray, code);
    QFETCH(QByteArray, prefix);
383
    QFETCH(QStringList, requiredCompletionItems);
384 385 386

    CompletionTestCase test(code, prefix);
    QVERIFY(test.succeededSoFar());
387 388 389
    const QStringList completions = test.getCompletions();
    QVERIFY(isProbablyGlobalCompletion(completions));
    QVERIFY(completions.toSet().contains(requiredCompletionItems.toSet()));
390 391
}

392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
static void enumTestCase(const QByteArray &tag, const QByteArray &source,
                         const QByteArray &prefix = QByteArray())
{
    QByteArray fullSource = source;
    fullSource.replace('$', "enum E { val1, val2, val3 };");
    QTest::newRow(tag) << fullSource << (prefix + "val")
            << (QStringList()
                << QLatin1String("val1")
                << QLatin1String("val2")
                << QLatin1String("val3"));

    QTest::newRow(tag + "_cxx11") << fullSource << (prefix + "E::")
            << (QStringList()
                << QLatin1String("E")
                << QLatin1String("val1")
                << QLatin1String("val2")
                << QLatin1String("val3"));

    fullSource.replace("enum E ", "enum ");
    QTest::newRow(tag + "_anon") << fullSource << (prefix + "val")
            << (QStringList()
                << QLatin1String("val1")
                << QLatin1String("val2")
                << QLatin1String("val3"));
}

418
void CppToolsPlugin::test_completion_data()
419
{
420 421 422 423 424
    QTest::addColumn<QByteArray>("code");
    QTest::addColumn<QByteArray>("prefix");
    QTest::addColumn<QStringList>("expectedCompletions");

    QTest::newRow("forward_declarations_present") << _(
425 426 427 428 429 430 431 432 433 434 435 436
            "class Foo\n"
            "{\n"
            "    struct Bar;\n"
            "    int i;\n"
            "};\n"
            "\n"
            "struct Foo::Bar \n"
            "{\n"
            "    Bar() {}\n"
            "};\n"
            "\n"
            "@\n"
437 438
        ) << _("Foo::Bar::") << (QStringList()
            << QLatin1String("Bar"));
439

440
    QTest::newRow("inside_parentheses_c_style_conversion") << _(
441 442 443 444 445 446 447 448 449 450 451 452 453 454
            "class Base\n"
            "{\n"
            "    int i_base;\n"
            "};\n"
            "\n"
            "class Derived : public Base\n"
            "{\n"
            "    int i_derived;\n"
            "};\n"
            "\n"
            "void fun()\n"
            "{\n"
            "    Base *b = new Derived;\n"
            "    if (1)\n"
455
            "        @;\n"
456
            "}\n"
457 458 459 460 461
        ) << _("((Derived *)b)->") << (QStringList()
            << QLatin1String("Derived")
            << QLatin1String("Base")
            << QLatin1String("i_derived")
            << QLatin1String("i_base"));
462

463
    QTest::newRow("inside_parentheses_cast_operator_conversion") << _(
464 465 466 467 468 469 470 471 472 473 474 475 476 477
            "class Base\n"
            "{\n"
            "    int i_base;\n"
            "};\n"
            "\n"
            "class Derived : public Base\n"
            "{\n"
            "    int i_derived;\n"
            "};\n"
            "\n"
            "void fun()\n"
            "{\n"
            "    Base *b = new Derived;\n"
            "    if (1)\n"
478
            "        @;\n"
479
            "}\n"
480 481 482 483 484
        ) << _("(static_cast<Derived *>(b))->") << (QStringList()
            << QLatin1String("Derived")
            << QLatin1String("Base")
            << QLatin1String("i_derived")
            << QLatin1String("i_base"));
485

486
    QTest::newRow("template_1") << _(
487 488 489 490 491 492 493 494 495 496 497
            "template <class T>\n"
            "class Foo\n"
            "{\n"
            "    typedef T Type;\n"
            "    T foo();\n"
            "    T m;\n"
            "};\n"
            "\n"
            "void func() {\n"
            "    Foo f;\n"
            "    @\n"
498 499 500 501 502 503
            "}"
        ) << _("Foo::") << (QStringList()
              << QLatin1String("Foo")
              << QLatin1String("Type")
              << QLatin1String("foo")
              << QLatin1String("m"));
504

505
    QTest::newRow("template_2") << _(
506 507 508 509 510 511 512 513 514 515 516
            "template <class T>\n"
            "struct List\n"
            "{\n"
            "    T &at(int);\n"
            "};\n"
            "\n"
            "struct Tupple { int a; int b; };\n"
            "\n"
            "void func() {\n"
            "    List<Tupple> l;\n"
            "    @\n"
517 518 519 520 521
            "}"
        ) << _("l.at(0).") << (QStringList()
            << QLatin1String("Tupple")
            << QLatin1String("a")
            << QLatin1String("b"));
522

523
    QTest::newRow("template_3") << _(
524 525 526 527 528 529 530 531 532 533 534
            "template <class T>\n"
            "struct List\n"
            "{\n"
            "    T t;\n"
            "};\n"
            "\n"
            "struct Tupple { int a; int b; };\n"
            "\n"
            "void func() {\n"
            "    List<Tupple> l;\n"
            "    @\n"
535 536 537 538 539
            "}"
        ) << _("l.t.") << (QStringList()
            << QLatin1String("Tupple")
            << QLatin1String("a")
            << QLatin1String("b"));
540

541
    QTest::newRow("template_4") << _(
542 543 544 545 546 547 548 549 550 551 552 553
            "template <class T>\n"
            "struct List\n"
            "{\n"
            "    typedef T U;\n"
            "    U u;\n"
            "};\n"
            "\n"
            "struct Tupple { int a; int b; };\n"
            "\n"
            "void func() {\n"
            "    List<Tupple> l;\n"
            "    @\n"
554 555 556 557 558
            "}"
        ) << _("l.u.") << (QStringList()
            << QLatin1String("Tupple")
            << QLatin1String("a")
            << QLatin1String("b"));
559

560
    QTest::newRow("template_5") << _(
561 562 563 564 565 566 567 568 569 570 571 572
            "template <class T>\n"
            "struct List\n"
            "{\n"
            "    T u;\n"
            "};\n"
            "\n"
            "struct Tupple { int a; int b; };\n"
            "\n"
            "void func() {\n"
            "    typedef List<Tupple> LT;\n"
            "    LT l;"
            "    @\n"
573 574 575 576 577
            "}"
        ) << _("l.u.") << (QStringList()
            << QLatin1String("Tupple")
            << QLatin1String("a")
            << QLatin1String("b"));
578

579
    QTest::newRow("template_6") << _(
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
            "class Item\n"
            "{\n"
            "    int i;\n"
            "};\n"
            "\n"
            "template <typename T>\n"
            "class Container\n"
            "{\n"
            "    T get();\n"
            "};\n"
            "\n"
            "template <typename T> class Container;\n"
            "\n"
            "class ItemContainer: public Container<Item>\n"
            "{};\n"
            "ItemContainer container;\n"
            "@\n"
597 598 599
        ) << _("container.get().") << (QStringList()
            << QLatin1String("Item")
            << QLatin1String("i"));
600

601
    QTest::newRow("template_7") << _(
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
            "struct Test\n"
            "{\n"
            "   int i;\n"
            "};\n"
            "\n"
            "template<typename T>\n"
            "struct TemplateClass\n"
            "{\n"
            "    T* ptr;\n"
            "\n"
            "    typedef T element_type;\n"
            "    TemplateClass(T* t) : ptr(t) {}\n"
            "    element_type* operator->()\n"
            "    {\n"
            "        return ptr;\n"
            "    }\n"
            "};\n"
            "\n"
            "TemplateClass<Test> p(new Test);\n"
            "@\n"
622 623 624
        ) << _("p->") << (QStringList()
            << QLatin1String("Test")
            << QLatin1String("i"));
625

626
    QTest::newRow("type_of_pointer_is_typedef") << _(
627 628 629 630 631 632
            "typedef struct Foo\n"
            "{\n"
            "    int foo;\n"
            "} Foo;\n"
            "Foo *bar;\n"
            "@\n"
633 634 635
        ) << _("bar->") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("foo"));
636

637
    QTest::newRow("instantiate_full_specialization") << _(
638 639 640 641 642 643 644 645 646 647 648 649 650 651
            "template<typename T>\n"
            "struct Template\n"
            "{\n"
            "   int templateT_i;\n"
            "};\n"
            "\n"
            "template<>\n"
            "struct Template<char>\n"
            "{\n"
            "    int templateChar_i;\n"
            "};\n"
            "\n"
            "Template<char> templateChar;\n"
            "@\n"
652 653 654
        ) << _("templateChar.") << (QStringList()
            << QLatin1String("Template")
            << QLatin1String("templateChar_i"));
655

656
    QTest::newRow("template_as_base: base as template directly") << _(
657 658 659 660 661 662
            "class Data { int dataMember; };\n"
            "template <class T> class Other : public T { int otherMember; };\n"
            "\n"
            "void func() {\n"
            "    Other<Data> c;\n"
            "    @\n"
663 664 665 666 667 668
            "}"
        ) << _("c.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember")
            << QLatin1String("Other")
            << QLatin1String("otherMember"));
669

670
    QTest::newRow("template_as_base: base as class template") << _(
671 672 673 674 675 676 677
            "class Data { int dataMember; };\n"
            "template <class T> class Other : public T { int otherMember; };\n"
            "template <class T> class More : public Other<T> { int moreMember; };\n"
            "\n"
            "void func() {\n"
            "    More<Data> c;\n"
            "    @\n"
678 679 680 681 682 683 684 685 686 687
            "}"
        ) << _("c.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember")
            << QLatin1String("Other")
            << QLatin1String("otherMember")
            << QLatin1String("More")
            << QLatin1String("moreMember"));

    QTest::newRow("template_as_base: base as globally qualified class template") << _(
688 689 690 691 692 693 694
            "class Data { int dataMember; };\n"
            "template <class T> class Other : public T { int otherMember; };\n"
            "template <class T> class More : public ::Other<T> { int moreMember; };\n"
            "\n"
            "void func() {\n"
            "    More<Data> c;\n"
            "    @\n"
695 696 697 698 699 700 701 702 703 704
            "}"
        ) << _("c.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember")
            << QLatin1String("Other")
            << QLatin1String("otherMember")
            << QLatin1String("More")
            << QLatin1String("moreMember"));

    QTest::newRow("template_as_base: base as namespace qualified class template") << _(
705 706 707 708 709 710 711 712 713
            "class Data { int dataMember; };\n"
            "namespace NS {\n"
            "template <class T> class Other : public T { int otherMember; };\n"
            "}\n"
            "template <class T> class More : public NS::Other<T> { int moreMember; };\n"
            "\n"
            "void func() {\n"
            "    More<Data> c;\n"
            "    @\n"
714 715 716 717 718 719 720 721 722 723
            "}"
        ) << _("c.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember")
            << QLatin1String("Other")
            << QLatin1String("otherMember")
            << QLatin1String("More")
            << QLatin1String("moreMember"));

    QTest::newRow("template_as_base: base as nested template name") << _(
724 725 726 727 728 729 730 731 732
            "class Data { int dataMember; };\n"
            "namespace NS {\n"
            "template <class T> class Delegate { typedef Data<T> Type; };\n"
            "}\n"
            "template <class T> class Final : public NS::Delegate<T>::Type { int finalMember; };\n"
            "\n"
            "void func() {\n"
            "    Final<Data> c;\n"
            "    @\n"
733 734 735 736 737 738
            "}"
        ) << _("c.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember")
            << QLatin1String("Final")
            << QLatin1String("finalMember"));
739

740
    QTest::newRow("template_as_base: base as nested template name in non-template") << _(
741 742 743 744 745 746 747 748 749
            "class Data { int dataMember; };\n"
            "namespace NS {\n"
            "template <class T> class Delegate { typedef Data<T> Type; };\n"
            "}\n"
            "class Final : public NS::Delegate<Data>::Type { int finalMember; };\n"
            "\n"
            "void func() {\n"
            "    Final c;\n"
            "    @\n"
750 751 752 753 754 755
            "}"
        ) << _("c.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember")
            << QLatin1String("Final")
            << QLatin1String("finalMember"));
756

757
    QTest::newRow("template_as_base: base as template name in non-template") << _(
758 759 760 761 762 763 764 765 766
            "class Data { int dataMember; };\n"
            "namespace NS {\n"
            "template <class T> class Other : public T { int otherMember; };\n"
            "}\n"
            "class Final : public NS::Other<Data> { int finalMember; };\n"
            "\n"
            "void func() {\n"
            "    Final c;\n"
            "    @\n"
767 768 769 770 771 772 773 774 775
            "}"
        ) << _("c.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember")
            << QLatin1String("Final")
            << QLatin1String("finalMember")
            << QLatin1String("Other")
            << QLatin1String("otherMember"));

776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
    QTest::newRow("template_as_base: typedef not available in derived") << _(
            "class Data { int dataMember; };\n"
            "template <class T> struct Base { typedef T F; };\n"
            "template <class T> struct Derived : Base<T> { F f; };\n"
            "\n"
            "void func() {\n"
            "    Derived<Data> d;\n"
            "    @\n"
            "}\n"
        ) << _("d.f.") << QStringList();

    QTest::newRow("template_as_base: explicit typedef from base") << _(
            "class Data { int dataMember; };\n"
            "template <class T> struct Base { typedef T F; };\n"
            "template <class T> struct Derived : Base<T>\n"
            "{\n"
            "   typedef typename Base<T>::F F;\n"
            "   F f;\n"
            "};\n"
            "\n"
            "void func() {\n"
            "    Derived<Data> d;\n"
            "    @\n"
            "}\n"
        ) << _("d.f.") << (QStringList()
            << QLatin1String("Data")
            << QLatin1String("dataMember"));

804
    QTest::newRow("use_global_identifier_as_base_class: derived as global and base as global") << _(
805 806 807 808 809 810 811 812 813 814 815
            "struct Global\n"
            "{\n"
            "    int int_global;\n"
            "};\n"
            "\n"
            "struct Final : ::Global\n"
            "{\n"
            "   int int_final;\n"
            "};\n"
            "\n"
            "Final c;\n"
816 817 818 819 820 821 822
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_global")
            << QLatin1String("int_final")
            << QLatin1String("Final")
            << QLatin1String("Global"));

823
    QTest::newRow("use_global_identifier_as_base_class: derived is inside namespace. "
824
                  "base as global") << _(
825 826 827 828 829 830 831 832 833 834 835 836 837 838
            "struct Global\n"
            "{\n"
            "    int int_global;\n"
            "};\n"
            "\n"
            "namespace NS\n"
            "{\n"
            "struct Final : ::Global\n"
            "{\n"
            "   int int_final;\n"
            "};\n"
            "}\n"
            "\n"
            "NS::Final c;\n"
839 840 841 842 843 844
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_global")
            << QLatin1String("int_final")
            << QLatin1String("Final")
            << QLatin1String("Global"));
845

846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
    QTest::newRow("use_global_identifier_as_base_class: derived is enclosed by template. "
                  "base as global") << _(
            "struct Global\n"
            "{\n"
            "    int int_global;\n"
            "};\n"
            "\n"
            "template <typename T>\n"
            "struct Enclosing\n"
            "{\n"
            "struct Final : ::Global\n"
            "{\n"
            "   int int_final;\n"
            "};\n"
            "};\n"
            "\n"
            "Enclosing<int>::Final c;\n"
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_global")
            << QLatin1String("int_final")
            << QLatin1String("Final")
            << QLatin1String("Global"));
869

870
    QTest::newRow("base_class_has_name_the_same_as_derived: base class is derived class") << _(
871 872 873 874 875 876
            "struct A : A\n"
            "{\n"
            "   int int_a;\n"
            "};\n"
            "\n"
            "A c;\n"
877 878 879 880
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_a")
            << QLatin1String("A"));
881

882 883
    QTest::newRow("base_class_has_name_the_same_as_derived: base class is derived class. "
                  "class is in namespace") << _(
884 885 886 887 888 889 890 891 892
            "namespace NS\n"
            "{\n"
            "struct A : A\n"
            "{\n"
            "   int int_a;\n"
            "};\n"
            "}\n"
            "\n"
            "NS::A c;\n"
893 894 895 896
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_a")
            << QLatin1String("A"));
897

898 899
    QTest::newRow("base_class_has_name_the_same_as_derived: base class is derived class. "
                  "class is in namespace. use scope operator for base class") << _(
900 901 902 903 904 905 906 907 908
            "namespace NS\n"
            "{\n"
            "struct A : NS::A\n"
            "{\n"
            "   int int_a;\n"
            "};\n"
            "}\n"
            "\n"
            "NS::A c;\n"
909 910 911 912
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_a")
            << QLatin1String("A"));
913

914 915
    QTest::newRow("base_class_has_name_the_same_as_derived: base class has the same name as "
                  "derived but in different namespace") << _(
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
            "namespace NS1\n"
            "{\n"
            "struct A\n"
            "{\n"
            "   int int_ns1_a;\n"
            "};\n"
            "}\n"
            "namespace NS2\n"
            "{\n"
            "struct A : NS1::A\n"
            "{\n"
            "   int int_ns2_a;\n"
            "};\n"
            "}\n"
            "\n"
            "NS2::A c;\n"
932 933 934 935 936
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_ns1_a")
            << QLatin1String("int_ns2_a")
            << QLatin1String("A"));
937

938 939
    QTest::newRow("base_class_has_name_the_same_as_derived: base class has the same name as "
                  "derived (in namespace) but is nested by different class") << _(
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
            "struct Enclosing\n"
            "{\n"
            "struct A\n"
            "{\n"
            "   int int_enclosing_a;\n"
            "};\n"
            "};\n"
            "namespace NS2\n"
            "{\n"
            "struct A : Enclosing::A\n"
            "{\n"
            "   int int_ns2_a;\n"
            "};\n"
            "}\n"
            "\n"
            "NS2::A c;\n"
956 957 958 959 960
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_enclosing_a")
            << QLatin1String("int_ns2_a")
            << QLatin1String("A"));
961

962 963
    QTest::newRow("base_class_has_name_the_same_as_derived: base class has the same name as "
                  "derived (nested) but is nested by different class") << _(
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
            "struct EnclosingBase\n"
            "{\n"
            "struct A\n"
            "{\n"
            "   int int_enclosing_base_a;\n"
            "};\n"
            "};\n"
            "struct EnclosingDerived\n"
            "{\n"
            "struct A : EnclosingBase::A\n"
            "{\n"
            "   int int_enclosing_derived_a;\n"
            "};\n"
            "};\n"
            "\n"
            "EnclosingDerived::A c;\n"
980 981 982 983 984
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_enclosing_base_a")
            << QLatin1String("int_enclosing_derived_a")
            << QLatin1String("A"));
985

986 987
    QTest::newRow("base_class_has_name_the_same_as_derived: base class is derived class. "
                  "class is a template") << _(
988 989 990 991 992 993 994
            "template <typename T>\n"
            "struct A : A\n"
            "{\n"
            "   int int_a;\n"
            "};\n"
            "\n"
            "A<int> c;\n"
995 996 997 998
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("int_a")
            << QLatin1String("A"));
999

1000
    QTest::newRow("cyclic_inheritance: direct cyclic inheritance") << _(
1001 1002 1003 1004 1005 1006
            "struct B;\n"
            "struct A : B { int _a; };\n"
            "struct B : A { int _b; };\n"
            "\n"
            "A c;\n"
            "@\n"
1007 1008 1009 1010 1011
        ) << _("c.") << (QStringList()
            << QLatin1String("A")
            << QLatin1String("_a")
            << QLatin1String("B")
            << QLatin1String("_b"));
1012

1013
    QTest::newRow("cyclic_inheritance: indirect cyclic inheritance") << _(
1014 1015 1016 1017 1018 1019 1020
            "struct C;\n"
            "struct A : C { int _a; };\n"
            "struct B : A { int _b; };\n"
            "struct C : B { int _c; };\n"
            "\n"
            "A c;\n"
            "@\n"
1021 1022 1023 1024 1025 1026 1027 1028 1029
        ) << _("c.") << (QStringList()
            << QLatin1String("A")
            << QLatin1String("_a")
            << QLatin1String("B")
            << QLatin1String("_b")
            << QLatin1String("C")
            << QLatin1String("_c"));

    QTest::newRow("cyclic_inheritance: indirect cyclic inheritance") << _(
1030 1031 1032 1033 1034 1035 1036
            "struct B;\n"
            "struct A : B { int _a; };\n"
            "struct C { int _c; };\n"
            "struct B : C, A { int _b; };\n"
            "\n"
            "A c;\n"
            "@\n"
1037 1038 1039 1040 1041 1042 1043 1044 1045
        ) << _("c.") << (QStringList()
            << QLatin1String("A")
            << QLatin1String("_a")
            << QLatin1String("B")
            << QLatin1String("_b")
            << QLatin1String("C")
            << QLatin1String("_c"));

    QTest::newRow("cyclic_inheritance: direct cyclic inheritance with templates") << _(
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
            "template< typename T > struct C;\n"
            "template< typename T, typename S > struct D : C< S >\n"
            "{\n"
            "   T _d_t;\n"
            "   S _d_s;\n"
            "};\n"
            "template< typename T > struct C : D< T, int >\n"
            "{\n"
            "   T _c_t;\n"
            "};\n"
            "\n"
            "D<int, float> c;\n"
            "@\n"
1059 1060 1061 1062 1063 1064 1065 1066
        ) << _("c.") << (QStringList()
            << QLatin1String("D")
            << QLatin1String("_d_t")
            << QLatin1String("_d_s")
            << QLatin1String("C")
            << QLatin1String("_c_t"));

    QTest::newRow("cyclic_inheritance: indirect cyclic inheritance with templates") << _(
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
            "template< typename T > struct C;\n"
            "template< typename T, typename S > struct D : C< S >\n"
            "{\n"
            "   T _d_t;\n"
            "   S _d_s;\n"
            "};\n"
            "template< typename T > struct B : D< T, int >\n"
            "{\n"
            "   T _b_t;\n"
            "};\n"
            "template< typename T > struct C : B<T>\n"
            "{\n"
            "   T _c_t;\n"
            "};\n"
            "\n"
            "D<int, float> c;\n"
            "@\n"
1084 1085 1086 1087 1088 1089 1090 1091 1092
        ) << _("c.") << (QStringList()
            << QLatin1String("D")
            << QLatin1String("_d_t")
            << QLatin1String("_d_s")
            << QLatin1String("C")
            << QLatin1String("_c_t")
            << QLatin1String("B")
            << QLatin1String("_b_t"));

1093
    QTest::newRow("cyclic_inheritance: direct cyclic inheritance with templates. "
1094
                  "more complex situation") << _(
1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
           "namespace NS\n"
           "{\n"
           "template <typename T> struct SuperClass\n"
           "{\n"
           "    typedef T Type;\n"
           "    Type super_class_type;\n"
           "};\n"
           "}\n"
           "\n"
           "template <typename T>\n"
           "struct Class;\n"
           "\n"
           "template <typename T, typename S>\n"
           "struct ClassRecurse : Class<S>\n"
           "{\n"
           "    T class_recurse_t;\n"
           "    S class_recurse_s;\n"
           "};\n"
           "\n"
           "template <typename T>\n"
           "struct Class : ClassRecurse< T, typename ::NS::SuperClass<T>::Type >\n"
           "{\n"
           "    T class_t;\n"
           "};\n"
           "\n"
           "Class<int> c;\n"
           "@\n"
1122 1123 1124 1125 1126 1127 1128 1129
        ) << _("c.") << (QStringList()
            << QLatin1String("Class")
            << QLatin1String("ClassRecurse")
            << QLatin1String("class_t")
            << QLatin1String("class_recurse_s")
            << QLatin1String("class_recurse_t"));

    QTest::newRow("enclosing_template_class: nested class with enclosing template class") << _(
1130 1131 1132 1133 1134 1135 1136 1137
            "template<typename T>\n"
            "struct Enclosing\n"
            "{\n"
            "    struct Nested { int int_nested; }; \n"
            "    int int_enclosing;\n"
            "};\n"
            "\n"
            "Enclosing<int>::Nested c;"
1138 1139 1140 1141
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("Nested")
            << QLatin1String("int_nested"));
1142

1143 1144
    QTest::newRow("enclosing_template_class: nested template class with enclosing template "
                  "class") << _(
1145 1146 1147 1148 1149 1150 1151 1152
            "template<typename T>\n"
            "struct Enclosing\n"
            "{\n"
            "    template<typename T> struct Nested { int int_nested; }; \n"
            "    int int_enclosing;\n"
            "};\n"
            "\n"
            "Enclosing<int>::Nested<int> c;"
1153 1154 1155 1156
            "@\n"
        ) << _("c.") << (QStringList()
            << QLatin1String("Nested")
            << QLatin1String("int_nested"));
1157

1158
    QTest::newRow("instantiate_nested_class_when_enclosing_is_template") << _(
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
            "struct Foo \n"
            "{\n"
            "    int foo_i;\n"
            "};\n"
            "\n"
            "template <typename T>\n"
            "struct Enclosing\n"
            "{\n"
            "    struct Nested\n"
            "    {\n"
            "        T nested_t;\n"
            "    } nested;\n"
            "\n"
            "    T enclosing_t;\n"
            "};\n"
            "\n"
            "Enclosing<Foo> enclosing;\n"
            "@\n"
1177 1178 1179
        ) << _("enclosing.nested.nested_t.") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("foo_i"));
1180

1181
    QTest::newRow("instantiate_nested_of_nested_class_when_enclosing_is_template") << _(
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
            "struct Foo \n"
            "{\n"
            "    int foo_i;\n"
            "};\n"
            "\n"
            "template <typename T>\n"
            "struct Enclosing\n"
            "{\n"
            "    struct Nested\n"
            "    {\n"
            "        T nested_t;\n"
            "        struct NestedNested\n"
            "        {\n"
            "            T nestedNested_t;\n"
            "        } nestedNested;\n"
            "    } nested;\n"
            "\n"
            "    T enclosing_t;\n"
            "};\n"
            "\n"
            "Enclosing<Foo> enclosing;\n"
            "@\n"
1204 1205 1206
        ) << _("enclosing.nested.nestedNested.nestedNested_t.") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("foo_i"));
1207

1208
    QTest::newRow("instantiate_template_with_default_argument_type") << _(
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
            "struct Foo\n"
            "{\n"
            "    int bar;\n"
            "};\n"
            "\n"
            "template <typename T = Foo>\n"
            "struct Template\n"
            "{\n"
            "    T t;\n"
            "};\n"
            "\n"
            "Template<> templateWithDefaultTypeOfArgument;\n"
            "@\n"
1222 1223 1224
        ) << _("templateWithDefaultTypeOfArgument.t.") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("bar"));
1225

1226
    QTest::newRow("instantiate_template_with_default_argument_type_as_template") << _(
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
            "struct Foo\n"
            "{\n"
            "    int bar;\n"
            "};\n"
            "\n"
            "template <typename T>\n"
            "struct TemplateArg\n"
            "{\n"
            "    T t;\n"
            "};\n"
            "template <typename T, typename S = TemplateArg<T> >\n"
            "struct Template\n"
            "{\n"
            "    S s;\n"
            "};\n"
            "\n"
            "Template<Foo> templateWithDefaultTypeOfArgument;\n"
1244
            "@\n"
1245 1246 1247
        ) << _("templateWithDefaultTypeOfArgument.s.t.") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("bar"));
1248

1249
    QTest::newRow("typedef_of_pointer") << _(
1250 1251 1252 1253 1254 1255
            "struct Foo { int bar; };\n"
            "typedef Foo *FooPtr;\n"
            "void main()\n"
            "{\n"
            "   FooPtr ptr;\n"
            "   @\n"
1256 1257 1258 1259
            "}"
        ) << _("ptr->") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("bar"));
1260

1261
    QTest::newRow("typedef_of_pointer_inside_function") << _(
1262 1263 1264 1265 1266 1267
            "struct Foo { int bar; };\n"
            "void f()\n"
            "{\n"
            "   typedef Foo *FooPtr;\n"
            "   FooPtr ptr;\n"
            "   @\n"
1268 1269 1270 1271
            "}"
        ) << _("ptr->") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("bar"));
1272

1273
    QTest::newRow("typedef_is_inside_function_before_declaration_block") << _(
1274 1275 1276 1277 1278 1279 1280 1281 1282
            "struct Foo { int bar; };\n"
            "void f()\n"
            "{\n"
            "   typedef Foo *FooPtr;\n"
            "   if (true) {\n"
            "       FooPtr ptr;\n"
            "       @\n"
            "   }"
            "}"
1283 1284 1285
        ) << _("ptr->") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("bar"));
1286

1287
    QTest::newRow("resolve_complex_typedef_with_template") << _(
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
            "template <typename T>\n"
            "struct Template2\n"
            "{\n"
            "    typedef typename T::template Template1<T>::TT TemplateTypedef;\n"
            "    TemplateTypedef templateTypedef;\n"
            "};\n"
            "struct Foo\n"
            "{\n"
            "    int bar;\n"
            "    template <typename T>\n"
            "    struct Template1\n"
            "    {\n"
            "        typedef T TT;\n"
            "    };\n"
            "};\n"
            "void fun()\n"
            "{\n"
            "    Template2<Foo> template2;\n"
            "    @\n"
            "}\n"
1308 1309 1310 1311
        ) << _("template2.templateTypedef.") << (QStringList()
            << QLatin1String("Foo")
            << QLatin1String("bar")
            << QLatin1String("Template1"));