cppmodelmanager_test.cpp 39.2 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 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
** 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
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** 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.
**
****************************************************************************/

30
#include "builtineditordocumentparser.h"
31
#include "cppsourceprocessor.h"
32 33
#include "cpptoolsplugin.h"
#include "cpptoolstestcase.h"
34
#include "editordocumenthandle.h"
35 36
#include "modelmanagertesthelper.h"

37
#include <coreplugin/editormanager/editormanager.h>
38
#include <coreplugin/testdatadir.h>
39 40
#include <projectexplorer/projectexplorer.h>
#include <projectexplorer/session.h>
41 42

#include <cplusplus/LookupContext.h>
43
#include <utils/hostosinfo.h>
44

45
#include <QDebug>
46 47
#include <QFileInfo>
#include <QtTest>
48 49

using namespace CppTools::Internal;
hjk's avatar
hjk committed
50
using namespace ProjectExplorer;
51

52
typedef CPlusPlus::Document Document;
53
typedef CppTools::ProjectInfo ProjectInfo;
54 55
typedef CppTools::ProjectPart ProjectPart;
typedef CppTools::ProjectFile ProjectFile;
56

Orgad Shaneh's avatar
Orgad Shaneh committed
57
Q_DECLARE_METATYPE(QList<ProjectFile>)
58

59 60
namespace {

61 62
inline QString _(const QByteArray &ba) { return QString::fromLatin1(ba, ba.size()); }

63
class MyTestDataDir : public Core::Tests::TestDataDir
64
{
65
public:
66
    MyTestDataDir(const QString &dir)
67
        : TestDataDir(_(SRCDIR "/../../../tests/cppmodelmanager/") + dir)
68
    {}
69

70
    QString includeDir(bool cleaned = true) const
71
    { return directory(_("include"), cleaned); }
72 73

    QString frameworksDir(bool cleaned = true) const
74
    { return directory(_("frameworks"), cleaned); }
75 76

    QString fileFromSourcesDir(const QString &fileName) const
77
    { return directory(_("sources")) + fileName; }
78 79
};

80 81 82 83 84 85 86 87 88
// TODO: When possible, use this helper class in all tests
class ProjectCreator
{
public:
    ProjectCreator(ModelManagerTestHelper *modelManagerTestHelper)
        : modelManagerTestHelper(modelManagerTestHelper)
    {}

    /// 'files' is expected to be a list of file names that reside in 'dir'.
89
    void create(const QString &name, const QString &dir, const QStringList &files)
90
    {
91
        const MyTestDataDir projectDir(dir);
92 93 94 95 96 97 98 99
        foreach (const QString &file, files)
            projectFiles << projectDir.file(file);

        Project *project = modelManagerTestHelper->createProject(name);
        projectInfo = CppModelManager::instance()->projectInfo(project);
        QCOMPARE(projectInfo.project().data(), project);

        ProjectPart::Ptr part(new ProjectPart);
100
        part->languageVersion = ProjectPart::CXX14;
101 102 103 104 105
        part->qtVersion = ProjectPart::Qt5;
        foreach (const QString &file, projectFiles) {
            ProjectFile projectFile(file, ProjectFile::classify(file));
            part->files.append(projectFile);
        }
106
        projectInfo.appendProjectPart(part);
107
        projectInfo.finish();
108 109 110 111 112 113 114
    }

    ModelManagerTestHelper *modelManagerTestHelper;
    ProjectInfo projectInfo;
    QStringList projectFiles;
};

115 116 117 118 119 120 121 122
/// Open and configure given project as example project and remove
/// generated *.user file on destruction.
///
/// Requirement: No *.user file exists for the project.
class ExampleProjectConfigurator
{
public:
    ExampleProjectConfigurator(const QString &projectFile,
hjk's avatar
hjk committed
123
                               ProjectExplorerPlugin *projectExplorer)
124
    {
125
        const QString projectUserFile = projectFile + _(".user");
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
        QVERIFY(!QFileInfo(projectUserFile).exists());

        // Open project
        QString errorOpeningProject;
        m_project = projectExplorer->openProject(projectFile, &errorOpeningProject);
        QVERIFY(m_project);
        QVERIFY(errorOpeningProject.isEmpty());

        // Configure project
        m_project->configureAsExampleProject(QStringList());

        m_fileToRemove = projectUserFile;
    }

    ~ExampleProjectConfigurator()
    {
        QVERIFY(!m_fileToRemove.isEmpty());
        QVERIFY(QFile::remove(m_fileToRemove));
    }

hjk's avatar
hjk committed
146
    Project *project() const
147 148 149 150 151
    {
        return m_project;
    }

private:
hjk's avatar
hjk committed
152
    Project *m_project;
153 154
    QString m_fileToRemove;
};
155

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
/// Changes a file on the disk and restores its original contents on destruction
class FileChangerAndRestorer
{
public:
    FileChangerAndRestorer(const QString &filePath)
        : m_filePath(filePath)
    {
    }

    ~FileChangerAndRestorer()
    {
        restoreContents();
    }

    /// Saves the contents also internally so it can be restored on destruction
    bool readContents(QByteArray *contents)
    {
        Utils::FileReader fileReader;
        const bool isFetchOk = fileReader.fetch(m_filePath);
        if (isFetchOk) {
            m_originalFileContents = fileReader.data();
            if (contents)
                *contents = m_originalFileContents;
        }
        return isFetchOk;
    }

183
    bool writeContents(const QByteArray &contents) const
184
    {
185
        return CppTools::Tests::TestCase::writeFile(m_filePath, contents);
186 187 188 189 190
    }

private:
    void restoreContents() const
    {
191
        CppTools::Tests::TestCase::writeFile(m_filePath, m_originalFileContents);
192 193 194 195 196 197
    }

    QByteArray m_originalFileContents;
    const QString &m_filePath;
};

198
static QSet<QString> updateProjectInfo(CppModelManager *modelManager, ModelManagerTestHelper *helper,
199 200 201 202 203 204 205 206
                                     const ProjectInfo &projectInfo)
{
    helper->resetRefreshedSourceFiles();
    modelManager->updateProjectInfo(projectInfo).waitForFinished();
    QCoreApplication::processEvents();
    return helper->waitForRefreshedSourceFiles();
}

207 208
} // anonymous namespace

209 210
/// Check: The preprocessor cleans include and framework paths.
void CppToolsPlugin::test_modelmanager_paths_are_clean()
211 212 213 214
{
    ModelManagerTestHelper helper;
    CppModelManager *mm = CppModelManager::instance();

215
    const MyTestDataDir testDataDir(_("testdata"));
216

217
    Project *project = helper.createProject(_("test_modelmanager_paths_are_clean"));
218 219 220
    ProjectInfo pi = mm->projectInfo(project);
    QCOMPARE(pi.project().data(), project);

221 222
    typedef ProjectPart::HeaderPath HeaderPath;

223
    ProjectPart::Ptr part(new ProjectPart);
224
    part->languageVersion = ProjectPart::CXX14;
225
    part->qtVersion = ProjectPart::Qt5;
226
    part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
227 228 229
    part->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDir.includeDir(false), HeaderPath::IncludePath)
            << HeaderPath(testDataDir.frameworksDir(false), HeaderPath::FrameworkPath);
230
    pi.appendProjectPart(part);
231
    pi.finish();
232 233 234

    mm->updateProjectInfo(pi);

235 236 237 238 239
    QList<HeaderPath> headerPaths = mm->headerPaths();
    QCOMPARE(headerPaths.size(), 2);
    QVERIFY(headerPaths.contains(HeaderPath(testDataDir.includeDir(), HeaderPath::IncludePath)));
    QVERIFY(headerPaths.contains(HeaderPath(testDataDir.frameworksDir(),
                                            HeaderPath::FrameworkPath)));
240
}
241

242
/// Check: Frameworks headers are resolved.
243 244
void CppToolsPlugin::test_modelmanager_framework_headers()
{
245
    if (Utils::HostOsInfo::isWindowsHost())
246
        QSKIP("Can't resolve framework soft links on Windows.");
247

248 249 250
    ModelManagerTestHelper helper;
    CppModelManager *mm = CppModelManager::instance();

251
    const MyTestDataDir testDataDir(_("testdata"));
252

253
    Project *project = helper.createProject(_("test_modelmanager_framework_headers"));
254 255 256
    ProjectInfo pi = mm->projectInfo(project);
    QCOMPARE(pi.project().data(), project);

257 258
    typedef ProjectPart::HeaderPath HeaderPath;

259
    ProjectPart::Ptr part(new ProjectPart);
260
    part->languageVersion = ProjectPart::CXX14;
261
    part->qtVersion = ProjectPart::Qt5;
262
    part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
263 264 265
    part->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDir.includeDir(false), HeaderPath::IncludePath)
            << HeaderPath(testDataDir.frameworksDir(false), HeaderPath::FrameworkPath);
266
    const QString &source = testDataDir.fileFromSourcesDir(
267
        _("test_modelmanager_framework_headers.cpp"));
268
    part->files << ProjectFile(source, ProjectFile::CXXSource);
269
    pi.appendProjectPart(part);
270
    pi.finish();
271

272
    mm->updateProjectInfo(pi).waitForFinished();
273 274
    QCoreApplication::processEvents();

275
    QVERIFY(mm->snapshot().contains(source));
276
    Document::Ptr doc = mm->document(source);
277 278 279 280 281 282 283 284 285 286 287 288 289 290
    QVERIFY(!doc.isNull());
    CPlusPlus::Namespace *ns = doc->globalNamespace();
    QVERIFY(ns);
    QVERIFY(ns->memberCount() > 0);
    for (unsigned i = 0, ei = ns->memberCount(); i < ei; ++i) {
        CPlusPlus::Symbol *s = ns->memberAt(i);
        QVERIFY(s);
        QVERIFY(s->name());
        const CPlusPlus::Identifier *id = s->name()->asNameId();
        QVERIFY(id);
        QByteArray chars = id->chars();
        QVERIFY(chars.startsWith("success"));
    }
}
291 292

/// QTCREATORBUG-9056
293 294 295
/// Check: If the project configuration changes, all project files and their
///        includes have to be reparsed.
void CppToolsPlugin::test_modelmanager_refresh_also_includes_of_project_files()
296 297 298 299
{
    ModelManagerTestHelper helper;
    CppModelManager *mm = CppModelManager::instance();

300
    const MyTestDataDir testDataDir(_("testdata"));
301

302 303
    const QString testCpp(testDataDir.fileFromSourcesDir(_("test_modelmanager_refresh.cpp")));
    const QString testHeader(testDataDir.fileFromSourcesDir( _("test_modelmanager_refresh.h")));
304

305
    Project *project = helper.createProject(
306
                _("test_modelmanager_refresh_also_includes_of_project_files"));
307 308 309
    ProjectInfo pi = mm->projectInfo(project);
    QCOMPARE(pi.project().data(), project);

310 311
    typedef ProjectPart::HeaderPath HeaderPath;

312
    ProjectPart::Ptr part(new ProjectPart);
313
    part->languageVersion = ProjectPart::CXX14;
314
    part->qtVersion = ProjectPart::Qt5;
315
    part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
316 317
    part->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDir.includeDir(false), HeaderPath::IncludePath);
318
    part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
319
    pi.appendProjectPart(part);
320
    pi.finish();
321

322
    QSet<QString> refreshedFiles = updateProjectInfo(mm, &helper, pi);
323 324 325 326 327 328
    QCOMPARE(refreshedFiles.size(), 1);
    QVERIFY(refreshedFiles.contains(testCpp));
    CPlusPlus::Snapshot snapshot = mm->snapshot();
    QVERIFY(snapshot.contains(testHeader));
    QVERIFY(snapshot.contains(testCpp));

329 330 331 332
    Document::Ptr headerDocumentBefore = snapshot.document(testHeader);
    const QList<CPlusPlus::Macro> macrosInHeaderBefore = headerDocumentBefore->definedMacros();
    QCOMPARE(macrosInHeaderBefore.size(), 1);
    QVERIFY(macrosInHeaderBefore.first().name() == "test_modelmanager_refresh_h");
333

334
    // Introduce a define that will enable another define once the document is reparsed.
335
    part->projectDefines = QByteArray("#define TEST_DEFINE 1\n");
336 337
    pi.clearProjectParts();
    pi.appendProjectPart(part);
338
    pi.finish();
339

340
    refreshedFiles = updateProjectInfo(mm, &helper, pi);
341 342 343 344 345 346

    QCOMPARE(refreshedFiles.size(), 1);
    QVERIFY(refreshedFiles.contains(testCpp));
    snapshot = mm->snapshot();
    QVERIFY(snapshot.contains(testHeader));
    QVERIFY(snapshot.contains(testCpp));
347 348 349 350 351 352

    Document::Ptr headerDocumentAfter = snapshot.document(testHeader);
    const QList<CPlusPlus::Macro> macrosInHeaderAfter = headerDocumentAfter->definedMacros();
    QCOMPARE(macrosInHeaderAfter.size(), 2);
    QVERIFY(macrosInHeaderAfter.at(0).name() == "test_modelmanager_refresh_h");
    QVERIFY(macrosInHeaderAfter.at(1).name() == "TEST_DEFINE_DEFINED");
353
}
354 355

/// QTCREATORBUG-9205
356
/// Check: When reparsing the same files again, no errors occur
357
///        (The CppSourceProcessor's already seen files are properly cleared!).
358
void CppToolsPlugin::test_modelmanager_refresh_several_times()
359 360 361 362
{
    ModelManagerTestHelper helper;
    CppModelManager *mm = CppModelManager::instance();

363
    const MyTestDataDir testDataDir(_("testdata_refresh"));
364

365 366 367
    const QString testHeader1(testDataDir.file(_("defines.h")));
    const QString testHeader2(testDataDir.file(_("header.h")));
    const QString testCpp(testDataDir.file(_("source.cpp")));
368

369
    Project *project = helper.createProject(_("test_modelmanager_refresh_several_times"));
370 371 372 373
    ProjectInfo pi = mm->projectInfo(project);
    QCOMPARE(pi.project().data(), project);

    ProjectPart::Ptr part(new ProjectPart);
374
    part->languageVersion = ProjectPart::CXX14;
375 376 377 378
    part->qtVersion = ProjectPart::Qt5;
    part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader));
    part->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader));
    part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
379
    pi.appendProjectPart(part);
380
    pi.finish();
381 382 383
    mm->updateProjectInfo(pi);

    CPlusPlus::Snapshot snapshot;
384
    QSet<QString> refreshedFiles;
385 386
    CPlusPlus::Document::Ptr document;

387
    QByteArray defines = "#define FIRST_DEFINE";
388
    for (int i = 0; i < 2; ++i) {
389 390 391 392
        pi.clearProjectParts();
        ProjectPart::Ptr part(new ProjectPart);
        // Simulate project configuration change by having different defines each time.
        defines += "\n#define ANOTHER_DEFINE";
393
        part->projectDefines = defines;
394
        part->languageVersion = ProjectPart::CXX14;
395 396 397 398 399
        part->qtVersion = ProjectPart::Qt5;
        part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader));
        part->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader));
        part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
        pi.appendProjectPart(part);
400
        pi.finish();
401

402
        refreshedFiles = updateProjectInfo(mm, &helper, pi);
403
        QCOMPARE(refreshedFiles.size(), 3);
404

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
        QVERIFY(refreshedFiles.contains(testHeader1));
        QVERIFY(refreshedFiles.contains(testHeader2));
        QVERIFY(refreshedFiles.contains(testCpp));

        snapshot = mm->snapshot();
        QVERIFY(snapshot.contains(testHeader1));
        QVERIFY(snapshot.contains(testHeader2));
        QVERIFY(snapshot.contains(testCpp));

        // No diagnostic messages expected
        document = snapshot.document(testHeader1);
        QVERIFY(document->diagnosticMessages().isEmpty());

        document = snapshot.document(testHeader2);
        QVERIFY(document->diagnosticMessages().isEmpty());

        document = snapshot.document(testCpp);
        QVERIFY(document->diagnosticMessages().isEmpty());
    }
}
425

426 427 428 429 430 431 432
/// QTCREATORBUG-9581
/// Check: If nothing has changes, nothing should be reindexed.
void CppToolsPlugin::test_modelmanager_refresh_test_for_changes()
{
    ModelManagerTestHelper helper;
    CppModelManager *mm = CppModelManager::instance();

433 434
    const MyTestDataDir testDataDir(_("testdata_refresh"));
    const QString testCpp(testDataDir.file(_("source.cpp")));
435

436
    Project *project = helper.createProject(_("test_modelmanager_refresh_2"));
437 438 439 440
    ProjectInfo pi = mm->projectInfo(project);
    QCOMPARE(pi.project().data(), project);

    ProjectPart::Ptr part(new ProjectPart);
441
    part->languageVersion = ProjectPart::CXX14;
442 443 444
    part->qtVersion = ProjectPart::Qt5;
    part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
    pi.appendProjectPart(part);
445
    pi.finish();
446 447

    // Reindexing triggers a reparsing thread
448
    helper.resetRefreshedSourceFiles();
449 450
    QFuture<void> firstFuture = mm->updateProjectInfo(pi);
    QVERIFY(firstFuture.isStarted() || firstFuture.isRunning());
451
    firstFuture.waitForFinished();
452
    const QSet<QString> refreshedFiles = helper.waitForRefreshedSourceFiles();
453 454 455 456 457 458 459 460
    QCOMPARE(refreshedFiles.size(), 1);
    QVERIFY(refreshedFiles.contains(testCpp));

    // No reindexing since nothing has changed
    QFuture<void> subsequentFuture = mm->updateProjectInfo(pi);
    QVERIFY(subsequentFuture.isCanceled() && subsequentFuture.isFinished());
}

461 462 463 464 465 466 467
/// Check: (1) Added project files are recognized and parsed.
/// Check: (2) Removed project files are recognized and purged from the snapshot.
void CppToolsPlugin::test_modelmanager_refresh_added_and_purge_removed()
{
    ModelManagerTestHelper helper;
    CppModelManager *mm = CppModelManager::instance();

468
    const MyTestDataDir testDataDir(_("testdata_refresh"));
469

470 471 472
    const QString testHeader1(testDataDir.file(_("header.h")));
    const QString testHeader2(testDataDir.file(_("defines.h")));
    const QString testCpp(testDataDir.file(_("source.cpp")));
473

474
    Project *project = helper.createProject(_("test_modelmanager_refresh_3"));
475 476 477 478
    ProjectInfo pi = mm->projectInfo(project);
    QCOMPARE(pi.project().data(), project);

    ProjectPart::Ptr part(new ProjectPart);
479
    part->languageVersion = ProjectPart::CXX14;
480 481 482 483
    part->qtVersion = ProjectPart::Qt5;
    part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
    part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader));
    pi.appendProjectPart(part);
484
    pi.finish();
485 486

    CPlusPlus::Snapshot snapshot;
487
    QSet<QString> refreshedFiles;
488

489
    refreshedFiles = updateProjectInfo(mm, &helper, pi);
490 491 492 493 494 495 496 497 498 499 500 501

    QCOMPARE(refreshedFiles.size(), 2);
    QVERIFY(refreshedFiles.contains(testHeader1));
    QVERIFY(refreshedFiles.contains(testCpp));

    snapshot = mm->snapshot();
    QVERIFY(snapshot.contains(testHeader1));
    QVERIFY(snapshot.contains(testCpp));

    // Now add testHeader2 and remove testHeader1
    pi.clearProjectParts();
    ProjectPart::Ptr newPart(new ProjectPart);
502
    newPart->languageVersion = ProjectPart::CXX14;
503 504 505 506
    newPart->qtVersion = ProjectPart::Qt5;
    newPart->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
    newPart->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader));
    pi.appendProjectPart(newPart);
507
    pi.finish();
508

509
    refreshedFiles = updateProjectInfo(mm, &helper, pi);
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532

    // Only the added project file was reparsed
    QCOMPARE(refreshedFiles.size(), 1);
    QVERIFY(refreshedFiles.contains(testHeader2));

    snapshot = mm->snapshot();
    QVERIFY(snapshot.contains(testHeader2));
    QVERIFY(snapshot.contains(testCpp));
    // The removed project file is not anymore in the snapshot
    QVERIFY(!snapshot.contains(testHeader1));
}

/// Check: Timestamp modified files are reparsed if project files are added or removed
///        while the project configuration stays the same
void CppToolsPlugin::test_modelmanager_refresh_timeStampModified_if_sourcefiles_change()
{
    QFETCH(QString, fileToChange);
    QFETCH(QList<ProjectFile>, initialProjectFiles);
    QFETCH(QList<ProjectFile>, finalProjectFiles);

    ModelManagerTestHelper helper;
    CppModelManager *mm = CppModelManager::instance();

533
    Project *project = helper.createProject(_("test_modelmanager_refresh_timeStampModified"));
534 535 536 537
    ProjectInfo pi = mm->projectInfo(project);
    QCOMPARE(pi.project().data(), project);

    ProjectPart::Ptr part(new ProjectPart);
538
    part->languageVersion = ProjectPart::CXX14;
539 540 541
    part->qtVersion = ProjectPart::Qt5;
    foreach (const ProjectFile &file, initialProjectFiles)
        part->files.append(file);
542
    pi.clearProjectParts();
543
    pi.appendProjectPart(part);
544
    pi.finish();
545 546 547

    Document::Ptr document;
    CPlusPlus::Snapshot snapshot;
548
    QSet<QString> refreshedFiles;
549

550
    refreshedFiles = updateProjectInfo(mm, &helper, pi);
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569

    QCOMPARE(refreshedFiles.size(), initialProjectFiles.size());
    snapshot = mm->snapshot();
    foreach (const ProjectFile &file, initialProjectFiles) {
        QVERIFY(refreshedFiles.contains(file.path));
        QVERIFY(snapshot.contains(file.path));
    }

    document = snapshot.document(fileToChange);
    const QDateTime lastModifiedBefore = document->lastModified();
    QCOMPARE(document->globalSymbolCount(), 1U);
    QCOMPARE(document->globalSymbolAt(0)->name()->identifier()->chars(), "someGlobal");

    // Modify the file
    QTest::qSleep(1000); // Make sure the timestamp is different
    FileChangerAndRestorer fileChangerAndRestorer(fileToChange);
    QByteArray originalContents;
    QVERIFY(fileChangerAndRestorer.readContents(&originalContents));
    const QByteArray newFileContentes = originalContents + "\nint addedOtherGlobal;";
570
    QVERIFY(fileChangerAndRestorer.writeContents(newFileContentes));
571 572 573 574 575 576 577

    // Add or remove source file. The configuration stays the same.
    part->files.clear();
    foreach (const ProjectFile &file, finalProjectFiles)
        part->files.append(file);
    pi.clearProjectParts();
    pi.appendProjectPart(part);
578
    pi.finish();
579

580
    refreshedFiles = updateProjectInfo(mm, &helper, pi);
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601

    QCOMPARE(refreshedFiles.size(), finalProjectFiles.size());
    snapshot = mm->snapshot();
    foreach (const ProjectFile &file, finalProjectFiles) {
        QVERIFY(refreshedFiles.contains(file.path));
        QVERIFY(snapshot.contains(file.path));
    }
    document = snapshot.document(fileToChange);
    const QDateTime lastModifiedAfter = document->lastModified();
    QVERIFY(lastModifiedAfter > lastModifiedBefore);
    QCOMPARE(document->globalSymbolCount(), 2U);
    QCOMPARE(document->globalSymbolAt(0)->name()->identifier()->chars(), "someGlobal");
    QCOMPARE(document->globalSymbolAt(1)->name()->identifier()->chars(), "addedOtherGlobal");
}

void CppToolsPlugin::test_modelmanager_refresh_timeStampModified_if_sourcefiles_change_data()
{
    QTest::addColumn<QString>("fileToChange");
    QTest::addColumn<QList<ProjectFile> >("initialProjectFiles");
    QTest::addColumn<QList<ProjectFile> >("finalProjectFiles");

602 603 604
    const MyTestDataDir testDataDir(_("testdata_refresh2"));
    const QString testCpp(testDataDir.file(_("source.cpp")));
    const QString testCpp2(testDataDir.file(_("source2.cpp")));
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619

    const QString fileToChange = testCpp;
    QList<ProjectFile> projectFiles1 = QList<ProjectFile>()
        << ProjectFile(testCpp, ProjectFile::CXXSource);
    QList<ProjectFile> projectFiles2 = QList<ProjectFile>()
        << ProjectFile(testCpp, ProjectFile::CXXSource)
        << ProjectFile(testCpp2, ProjectFile::CXXSource);

    // Add a file
    QTest::newRow("case: add project file") << fileToChange << projectFiles1 << projectFiles2;

    // Remove a file
    QTest::newRow("case: remove project file") << fileToChange << projectFiles2 << projectFiles1;
}

620 621
/// Check: If a second project is opened, the code model is still aware of
///        files of the first project.
622 623
void CppToolsPlugin::test_modelmanager_snapshot_after_two_projects()
{
624
    QSet<QString> refreshedFiles;
625 626 627 628 629 630
    ModelManagerTestHelper helper;
    ProjectCreator project1(&helper);
    ProjectCreator project2(&helper);
    CppModelManager *mm = CppModelManager::instance();

    // Project 1
631 632 633 634 635
    project1.create(_("test_modelmanager_snapshot_after_two_projects.1"),
                    _("testdata_project1"),
                    QStringList() << _("foo.h")
                                  << _("foo.cpp")
                                  << _("main.cpp"));
636

637
    refreshedFiles = updateProjectInfo(mm, &helper, project1.projectInfo);
638
    QCOMPARE(refreshedFiles, project1.projectFiles.toSet());
639 640 641 642 643 644
    const int snapshotSizeAfterProject1 = mm->snapshot().size();

    foreach (const QString &file, project1.projectFiles)
        QVERIFY(mm->snapshot().contains(file));

    // Project 2
645 646 647 648 649
    project2.create(_("test_modelmanager_snapshot_after_two_projects.2"),
                    _("testdata_project2"),
                    QStringList() << _("bar.h")
                                  << _("bar.cpp")
                                  << _("main.cpp"));
650

651
    refreshedFiles = updateProjectInfo(mm, &helper, project2.projectInfo);
652
    QCOMPARE(refreshedFiles, project2.projectFiles.toSet());
653 654 655 656 657 658 659 660 661 662

    const int snapshotSizeAfterProject2 = mm->snapshot().size();
    QVERIFY(snapshotSizeAfterProject2 > snapshotSizeAfterProject1);
    QVERIFY(snapshotSizeAfterProject2 >= snapshotSizeAfterProject1 + project2.projectFiles.size());

    foreach (const QString &file, project1.projectFiles)
        QVERIFY(mm->snapshot().contains(file));
    foreach (const QString &file, project2.projectFiles)
        QVERIFY(mm->snapshot().contains(file));
}
663

664 665
/// Check: (1) For a project with a *.ui file an AbstractEditorSupport object
///            is added for the ui_* file.
666
/// Check: (2) The CppSourceProcessor can successfully resolve the ui_* file
667
///            though it might not be actually generated in the build dir.
668 669
void CppToolsPlugin::test_modelmanager_extraeditorsupport_uiFiles()
{
670 671
    ModelManagerTestHelper helper;

672 673
    MyTestDataDir testDataDirectory(_("testdata_guiproject1"));
    const QString projectFile = testDataDirectory.file(_("testdata_guiproject1.pro"));
674 675

    // Open project with *.ui file
hjk's avatar
hjk committed
676
    ProjectExplorerPlugin *pe = ProjectExplorerPlugin::instance();
677 678
    ExampleProjectConfigurator exampleProjectConfigurator(projectFile, pe);
    Project *project = exampleProjectConfigurator.project();
679 680 681 682

    // Check working copy.
    // An AbstractEditorSupport object should have been added for the ui_* file.
    CppModelManagerInterface *mm = CppModelManagerInterface::instance();
683
    WorkingCopy workingCopy = mm->workingCopy();
684 685 686 687

    QCOMPARE(workingCopy.size(), 2); // mm->configurationFileName() and "ui_*.h"

    QStringList fileNamesInWorkinCopy;
688
    QHashIterator<QString, QPair<QByteArray, unsigned> > it = workingCopy.iterator();
689 690 691 692 693
    while (it.hasNext()) {
        it.next();
        fileNamesInWorkinCopy << QFileInfo(it.key()).fileName();
    }
    fileNamesInWorkinCopy.sort();
694
    const QString expectedUiHeaderFileName = _("ui_mainwindow.h");
695 696 697
    QCOMPARE(fileNamesInWorkinCopy.at(0), mm->configurationFileName());
    QCOMPARE(fileNamesInWorkinCopy.at(1), expectedUiHeaderFileName);

698 699
    // Check CppSourceProcessor / includes.
    // The CppSourceProcessor is expected to find the ui_* file in the working copy.
700
    const QString fileIncludingTheUiFile = testDataDirectory.file(_("mainwindow.cpp"));
701 702 703 704 705 706 707 708
    while (!mm->snapshot().document(fileIncludingTheUiFile))
        QCoreApplication::processEvents();

    const CPlusPlus::Snapshot snapshot = mm->snapshot();
    const Document::Ptr document = snapshot.document(fileIncludingTheUiFile);
    QVERIFY(document);
    const QStringList includedFiles = document->includedFiles();
    QCOMPARE(includedFiles.size(), 2);
709 710
    QCOMPARE(QFileInfo(includedFiles.at(0)).fileName(), _("mainwindow.h"));
    QCOMPARE(QFileInfo(includedFiles.at(1)).fileName(), _("ui_mainwindow.h"));
711 712

    // Close Project
hjk's avatar
hjk committed
713
    SessionManager::removeProject(project);
714
    helper.waitForFinishedGc();
715
}
716 717 718 719 720

/// QTCREATORBUG-9828: Locator shows symbols of closed files
/// Check: The garbage collector should be run if the last CppEditor is closed.
void CppToolsPlugin::test_modelmanager_gc_if_last_cppeditor_closed()
{
721 722
    ModelManagerTestHelper helper;

723 724
    MyTestDataDir testDataDirectory(_("testdata_guiproject1"));
    const QString file = testDataDirectory.file(_("main.cpp"));
725 726

    CppModelManager *mm = CppModelManager::instance();
727
    helper.resetRefreshedSourceFiles();
728 729

    // Open a file in the editor
hjk's avatar
hjk committed
730
    QCOMPARE(Core::DocumentModel::openedDocuments().size(), 0);
731
    Core::IEditor *editor = Core::EditorManager::openEditor(file);
732
    QVERIFY(editor);
hjk's avatar
hjk committed
733
    QCOMPARE(Core::DocumentModel::openedDocuments().size(), 1);
734 735 736
    QVERIFY(mm->isCppEditor(editor));
    QVERIFY(mm->workingCopy().contains(file));

737 738
    // Wait until the file is refreshed
    helper.waitForRefreshedSourceFiles();
739 740

    // Close file/editor
741
    Core::EditorManager::closeDocument(editor->document(), /*askAboutModifiedEditors=*/ false);
742
    helper.waitForFinishedGc();
743 744 745 746 747

    // Check: File is removed from the snapshpt
    QVERIFY(!mm->workingCopy().contains(file));
    QVERIFY(!mm->snapshot().contains(file));
}
748 749 750 751 752 753

/// Check: Files that are open in the editor are not garbage collected.
void CppToolsPlugin::test_modelmanager_dont_gc_opened_files()
{
    ModelManagerTestHelper helper;

754 755
    MyTestDataDir testDataDirectory(_("testdata_guiproject1"));
    const QString file = testDataDirectory.file(_("main.cpp"));
756 757

    CppModelManager *mm = CppModelManager::instance();
758
    helper.resetRefreshedSourceFiles();
759 760

    // Open a file in the editor
hjk's avatar
hjk committed
761
    QCOMPARE(Core::DocumentModel::openedDocuments().size(), 0);
762
    Core::IEditor *editor = Core::EditorManager::openEditor(file);
763
    QVERIFY(editor);
hjk's avatar
hjk committed
764
    QCOMPARE(Core::DocumentModel::openedDocuments().size(), 1);
765 766
    QVERIFY(mm->isCppEditor(editor));

767 768
    // Wait until the file is refreshed and check whether it is in the working copy
    helper.waitForRefreshedSourceFiles();
769

770 771 772 773 774 775 776 777 778 779
    QVERIFY(mm->workingCopy().contains(file));

    // Run the garbage collector
    mm->GC();

    // Check: File is still there
    QVERIFY(mm->workingCopy().contains(file));
    QVERIFY(mm->snapshot().contains(file));

    // Close editor
780
    Core::EditorManager::closeDocument(editor->document());
781 782 783
    helper.waitForFinishedGc();
    QVERIFY(mm->snapshot().isEmpty());
}
784 785 786 787 788 789 790

namespace {
struct EditorCloser {
    Core::IEditor *editor;
    EditorCloser(Core::IEditor *editor): editor(editor) {}
    ~EditorCloser()
    {
791
        using namespace CppTools;
792
        if (editor)
793
            QVERIFY(Tests::TestCase::closeEditorWithoutGarbageCollectorInvocation(editor));
794 795
    }
};
796 797 798 799 800 801 802 803

QString nameOfFirstDeclaration(const Document::Ptr &doc)
{
    if (doc && doc->globalNamespace()) {
        if (CPlusPlus::Symbol *s = doc->globalSymbolAt(0)) {
            if (CPlusPlus::Declaration *decl = s->asDeclaration()) {
                if (const CPlusPlus::Name *name = decl->name()) {
                    if (const CPlusPlus::Identifier *identifier = name->identifier())
804
                        return QString::fromUtf8(identifier->chars(), identifier->size());
805 806 807 808 809 810
                }
            }
        }
    }
    return QString();
}
811 812 813 814 815 816
}

void CppToolsPlugin::test_modelmanager_defines_per_project()
{
    ModelManagerTestHelper helper;

817 818 819 820
    MyTestDataDir testDataDirectory(_("testdata_defines"));
    const QString main1File = testDataDirectory.file(_("main1.cpp"));
    const QString main2File = testDataDirectory.file(_("main2.cpp"));
    const QString header = testDataDirectory.file(_("header.h"));
821 822 823

    CppModelManager *mm = CppModelManager::instance();

824
    Project *project = helper.createProject(_("test_modelmanager_defines_per_project"));
825

826 827
    typedef ProjectPart::HeaderPath HeaderPath;

828
    ProjectPart::Ptr part1(new ProjectPart);
829
    part1->projectFile = QLatin1String("project1.projectfile");
830 831
    part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
    part1->files.append(ProjectFile(header, ProjectFile::CXXHeader));
832
    part1->languageVersion = ProjectPart::CXX11;
833
    part1->qtVersion = ProjectPart::NoQt;
834
    part1->projectDefines = QByteArray("#define SUB1\n");
835 836
    part1->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
837 838

    ProjectPart::Ptr part2(new ProjectPart);
839
    part2->projectFile = QLatin1String("project1.projectfile");
840 841
    part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource));
    part2->files.append(ProjectFile(header, ProjectFile::CXXHeader));
842
    part2->languageVersion = ProjectPart::CXX11;
843
    part2->qtVersion = ProjectPart::NoQt;
844
    part2->projectDefines = QByteArray("#define SUB2\n");
845 846
    part2->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
847 848 849 850

    ProjectInfo pi = mm->projectInfo(project);
    pi.appendProjectPart(part1);
    pi.appendProjectPart(part2);
851
    pi.finish();
852

853
    updateProjectInfo(mm, &helper, pi);
854 855 856
    QCOMPARE(mm->snapshot().size(), 4);

    // Open a file in the editor
hjk's avatar
hjk committed
857
    QCOMPARE(Core::DocumentModel::openedDocuments().size(), 0);
858

859 860 861 862 863 864 865 866 867 868 869 870 871
    struct Data {
        QString firstDeclarationName;
        QString fileName;
    } d[] = {
        { _("one"), main1File },
        { _("two"), main2File }
    };
    const int size = sizeof(d) / sizeof(d[0]);
    for (int i = 0; i < size; ++i) {
        const QString firstDeclarationName = d[i].firstDeclarationName;
        const QString fileName = d[i].fileName;

        Core::IEditor *editor = Core::EditorManager::openEditor(fileName);
872 873
        EditorCloser closer(editor);
        QVERIFY(editor);
hjk's avatar
hjk committed
874
        QCOMPARE(Core::DocumentModel::openedDocuments().size(), 1);
875 876
        QVERIFY(mm->isCppEditor(editor));

877 878 879 880
//        CppEditorSupport *sup = mm->cppEditorSupport(
//                    qobject_cast<TextEditor::BaseTextEditor *>(editor));
//        while (sup->lastSemanticInfoDocument().isNull())
//            QCoreApplication::processEvents();
881

882
        Document::Ptr doc = mm->document(fileName);
883
        QCOMPARE(nameOfFirstDeclaration(doc), firstDeclarationName);
884 885
    }
}
886

887
void CppToolsPlugin::test_modelmanager_precompiled_headers()
888 889 890
{
    ModelManagerTestHelper helper;

891 892 893 894 895 896
    MyTestDataDir testDataDirectory(_("testdata_defines"));
    const QString main1File = testDataDirectory.file(_("main1.cpp"));
    const QString main2File = testDataDirectory.file(_("main2.cpp"));
    const QString header = testDataDirectory.file(_("header.h"));
    const QString pch1File = testDataDirectory.file(_("pch1.h"));
    const QString pch2File = testDataDirectory.file(_("pch2.h"));
897 898 899

    CppModelManager *mm = CppModelManager::instance();

900
    Project *project = helper.createProject(_("test_modelmanager_defines_per_project_pch"));
901

902 903
    typedef ProjectPart::HeaderPath HeaderPath;

904
    ProjectPart::Ptr part1(new ProjectPart);
905
    part1->projectFile = QLatin1String("project1.projectfile");
906 907
    part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
    part1->files.append(ProjectFile(header, ProjectFile::CXXHeader));
908
    part1->languageVersion = ProjectPart::CXX11;
909 910
    part1->qtVersion = ProjectPart::NoQt;
    part1->precompiledHeaders.append(pch1File);
911 912
    part1->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
913 914

    ProjectPart::Ptr part2(new ProjectPart);
915
    part2->projectFile = QLatin1String("project2.projectfile");
916 917
    part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource));
    part2->files.append(ProjectFile(header, ProjectFile::CXXHeader));
918
    part2->languageVersion = ProjectPart::CXX11;
919 920
    part2->qtVersion = ProjectPart::NoQt;
    part2->precompiledHeaders.append(pch2File);
921 922
    part2->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
923 924 925 926

    ProjectInfo pi = mm->projectInfo(project);
    pi.appendProjectPart(part1);
    pi.appendProjectPart(part2);
927
    pi.finish();
928

929
    updateProjectInfo(mm, &helper, pi);
930 931 932
    QCOMPARE(mm->snapshot().size(), 4);

    // Open a file in the editor
hjk's avatar
hjk committed
933
    QCOMPARE(Core::DocumentModel::openedDocuments().size(), 0);
934

935 936
    struct Data {
        QString firstDeclarationName;
937
        QString firstClassInPchFile;
938 939
        QString fileName;
    } d[] = {
940 941
        { _("one"), _("ClassInPch1"), main1File },
        { _("two"), _("ClassInPch2"), main2File }
942 943 944 945
    };
    const int size = sizeof(d) / sizeof(d[0]);
    for (int i = 0; i < size; ++i) {
        const QString firstDeclarationName = d[i].firstDeclarationName;
946
        const QByteArray firstClassInPchFile = d[i].firstClassInPchFile.toUtf8();
947 948 949
        const QString fileName = d[i].fileName;

        Core::IEditor *editor = Core::EditorManager::openEditor(fileName);
950 951
        EditorCloser closer(editor);
        QVERIFY(editor);
hjk's avatar
hjk committed
952
        QCOMPARE(Core::DocumentModel::openedDocuments().size(), 1);
953 954
        QVERIFY(mm->isCppEditor(editor));

955 956 957
        BuiltinEditorDocumentParser *parser = BuiltinEditorDocumentParser::get(fileName);
        parser->setUsePrecompiledHeaders(true);
        parser->update(mm->workingCopy());
958 959 960 961 962 963

        // Check if defines from pch are considered
        Document::Ptr document = mm->document(fileName);
        QCOMPARE(nameOfFirstDeclaration(document), firstDeclarationName);

        // Check if declarations from pch are considered
964
        CPlusPlus::LookupContext context(document, parser->snapshot());
965 966 967 968 969 970
        const CPlusPlus::Identifier *identifier
            = document->control()->identifier(firstClassInPchFile.data());
        const QList<CPlusPlus::LookupItem> results = context.lookup(identifier,
                                                                    document->globalNamespace());
        QVERIFY(!results.isEmpty());
        QVERIFY(results.first().declaration()->type()->asClassType());
971 972
    }
}
973 974 975 976 977

void CppToolsPlugin::test_modelmanager_defines_per_editor()
{
    ModelManagerTestHelper helper;

978 979 980 981
    MyTestDataDir testDataDirectory(_("testdata_defines"));
    const QString main1File = testDataDirectory.file(_("main1.cpp"));
    const QString main2File = testDataDirectory.file(_("main2.cpp"));
    const QString header = testDataDirectory.file(_("header.h"));
982 983 984

    CppModelManager *mm = CppModelManager::instance();

985
    Project *project = helper.createProject(_("test_modelmanager_defines_per_editor"));
986

987 988
    typedef ProjectPart::HeaderPath HeaderPath;

989 990 991
    ProjectPart::Ptr part1(new ProjectPart);
    part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
    part1->files.append(ProjectFile(header, ProjectFile::CXXHeader));
992
    part1->languageVersion = ProjectPart::CXX11;
993
    part1->qtVersion = ProjectPart::NoQt;
994 995
    part1->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
996 997 998 999

    ProjectPart::Ptr part2(new ProjectPart);
    part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource));
    part2->files.append(ProjectFile(header, ProjectFile::CXXHeader));
1000
    part2->languageVersion = ProjectPart::CXX11;
1001
    part2->qtVersion = ProjectPart::NoQt;
1002 1003
    part2->headerPaths = QList<HeaderPath>()
            << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
1004 1005 1006 1007

    ProjectInfo pi = mm->projectInfo(project);
    pi.appendProjectPart(part1);
    pi.appendProjectPart(part2);
1008
    pi.finish();
1009

1010
    updateProjectInfo(mm, &helper, pi);
1011 1012 1013 1014

    QCOMPARE(mm->snapshot().size(), 4);

    // Open a file in the editor
hjk's avatar
hjk committed
1015
    QCOMPARE(Core::DocumentModel::openedDocuments().size(), 0);
1016

1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
    struct Data {
        QString editorDefines;
        QString firstDeclarationName;
    } d[] = {
        { _("#define SUB1\n"), _("one") },
        { _("#define SUB2\n"), _("two") }
    };
    const int size = sizeof(d) / sizeof(d[0]);
    for (int i = 0; i < size; ++i) {
        const QString editorDefines = d[i].editorDefines;
        const QString firstDeclarationName = d[i].firstDeclarationName;

1029 1030 1031
        Core::IEditor *editor = Core::EditorManager::openEditor(main1File);
        EditorCloser closer(editor);
        QVERIFY(editor);
hjk's avatar
hjk committed
1032
        QCOMPARE(Core::DocumentModel::openedDocuments().size(), 1);
1033 1034
        QVERIFY(mm->isCppEditor(editor));

1035 1036 1037 1038
        const QString filePath = editor->document()->filePath();
        BaseEditorDocumentParser *parser = BaseEditorDocumentParser::get(filePath);
        parser->setEditorDefines(editorDefines.toUtf8());
        parser->update(mm->workingCopy());
Erik Verbruggen's avatar