feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
cbe9a665c554cb99a5717404303d1009bc9f9720
qt-creator/tests/unit/unittest/symbolscollector-test.cpp

496 lines
16 KiB
C++
Raw Normal View History

Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** 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 The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "googletest.h"
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
#include "filesystem-utilities.h"
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
#include <symbolscollector.h>
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
#include <filepathcaching.h>
UnitTests: Use memory database Tests get more reliable if the database is not shared between different tests and the testing is speed up by not accessing the file system. Change-Id: Ieb3c5495df4f0fae2293111949792774b01bf913 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-10-18 13:34:05 +02:00
#include <refactoringdatabaseinitializer.h>
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
#include <QDir>
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
using testing::PrintToString;
using testing::AllOf;
using testing::Contains;
using testing::Not;
using testing::Field;
using testing::Key;
using testing::Pair;
using testing::Value;
using testing::_;
Clang: Collect source files Change-Id: If0183cafd00ed7e42bacbdb72a1d65624dc03cee Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-10-26 13:23:27 +02:00
using ClangBackEnd::FilePath;
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
using ClangBackEnd::FilePathId;
using ClangBackEnd::FilePathCaching;
Clang: Add Symbol Indexing It is a first step and now a database is generated if you start QtCreator. Some code is now shared with the PchManager which can be improved in the future. Change-Id: Ic267fe7960f6c455d91832859a673ce98f269aa2 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-17 12:44:52 +02:00
using ClangBackEnd::V2::FileContainers;
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
using ClangBackEnd::SourceLocationEntry;
using ClangBackEnd::SymbolEntry;
using ClangBackEnd::SymbolType;
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
using ClangBackEnd::SymbolIndex;
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
using ClangBackEnd::UsedDefine;
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
using Sqlite::Database;
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
namespace {
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
MATCHER_P5(IsSourceLocationEntry, symbolId, filePathId, line, column, symbolType,
std::string(negation ? "isn't" : "is")
+ PrintToString(SourceLocationEntry{symbolId, filePathId, {line, column}, symbolType})
)
{
const SourceLocationEntry &entry = arg;
return entry.filePathId == filePathId
&& entry.lineColumn.line == line
&& entry.lineColumn.column == column
&& entry.symbolType == symbolType
&& entry.symbolId == symbolId;
}
MATCHER_P2(HasLineColumn, line, column,
std::string(negation ? "isn't" : "is")
+ PrintToString(Utils::LineColumn{line, column})
)
{
const SourceLocationEntry &entry = arg;
return entry.lineColumn.line == line
&& entry.lineColumn.column == column;
}
Clang: Improve Macro collection Now undefined macros are added to used macros but we filter out header guards and dynamic libraries export. The export is quite simple but without we would think that exports change the AST. Change-Id: Ic16f60a6675e397dfd769c53caf77056708d8459 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-23 14:10:17 +01:00
MATCHER_P(HasSymbolName, symbolName,
std::string(negation ? "hasn't" : "has")
+ " symbol name: "
+ symbolName
)
{
const SymbolEntry &entry = arg.second;
return entry.symbolName == symbolName;
}
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
class SymbolsCollector : public testing::Test
{
protected:
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
FilePathId filePathId(Utils::SmallStringView string)
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
{
Clang: Handle native file in the file cache Different types are introduced for normalized and native file path. So the compiler is warning you if you try the wrong format. Change-Id: I1da0686b142cbf9bb7578468c2b50f90a94cebf9 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-11-16 17:48:53 +01:00
return filePathCache.filePathId(ClangBackEnd::FilePathView{string});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
}
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
SymbolIndex symbolId(const Utils::SmallString &symbolName)
{
for (const auto &entry : collector.symbols()) {
if (entry.second.symbolName == symbolName)
return entry.first;
}
return 0;
}
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
protected:
UnitTests: Use memory database Tests get more reliable if the database is not shared between different tests and the testing is speed up by not accessing the file system. Change-Id: Ieb3c5495df4f0fae2293111949792774b01bf913 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-10-18 13:34:05 +02:00
Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> initializer{database};
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
FilePathCaching filePathCache{database};
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
ClangBackEnd::SymbolsCollector collector{filePathCache};
};
TEST_F(SymbolsCollector, CollectSymbolName)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_simple.cpp")}, {"cc"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.symbols(),
Clang: Improve Macro collection Now undefined macros are added to used macros but we filter out header guards and dynamic libraries export. The export is quite simple but without we would think that exports change the AST. Change-Id: Ic16f60a6675e397dfd769c53caf77056708d8459 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-23 14:10:17 +01:00
Contains(HasSymbolName("x")));
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
}
TEST_F(SymbolsCollector, SymbolMatchesLocation)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_simple.cpp")}, {"cc"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
AllOf(Field(&SourceLocationEntry::symbolId, symbolId("function")),
HasLineColumn(1, 6))));
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
}
TEST_F(SymbolsCollector, OtherSymboldMatchesLocation)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_simple.cpp")}, {"cc"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
AllOf(Field(&SourceLocationEntry::symbolId, symbolId("function")),
HasLineColumn(2, 6))));
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
}
TEST_F(SymbolsCollector, CollectFilePath)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_simple.cpp")}, {"cc"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
AllOf(Field(&SourceLocationEntry::filePathId,
filePathId(TESTDATA_DIR"/symbolscollector_simple.cpp")),
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
Field(&SourceLocationEntry::symbolType, SymbolType::Declaration))));
}
TEST_F(SymbolsCollector, CollectLineColumn)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_simple.cpp")}, {"cc"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
AllOf(HasLineColumn(1, 6),
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
Field(&SourceLocationEntry::symbolType, SymbolType::Declaration))));
}
TEST_F(SymbolsCollector, CollectReference)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_simple.cpp")}, {"cc"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
AllOf(HasLineColumn(14, 5),
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
Field(&SourceLocationEntry::symbolType, SymbolType::DeclarationReference))));
}
TEST_F(SymbolsCollector, ReferencedSymboldMatchesLocation)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_simple.cpp")}, {"cc"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
AllOf(Field(&SourceLocationEntry::symbolId, symbolId("function")),
HasLineColumn(14, 5))));
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
}
Clang: Add Symbol Indexing It is a first step and now a database is generated if you start QtCreator. Some code is now shared with the PchManager which can be improved in the future. Change-Id: Ic267fe7960f6c455d91832859a673ce98f269aa2 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-17 12:44:52 +02:00
TEST_F(SymbolsCollector, DISABLED_ON_WINDOWS(CollectInUnsavedFile))
{
FileContainers unsaved{{{TESTDATA_DIR, "symbolscollector_generated_file.h"},
"void function();",
{}}};
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_unsaved.cpp")}, {"cc"});
Clang: Add Symbol Indexing It is a first step and now a database is generated if you start QtCreator. Some code is now shared with the PchManager which can be improved in the future. Change-Id: Ic267fe7960f6c455d91832859a673ce98f269aa2 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-17 12:44:52 +02:00
collector.addUnsavedFiles(std::move(unsaved));
collector.collectSymbols();
ASSERT_THAT(collector.symbols(),
Clang: Improve Macro collection Now undefined macros are added to used macros but we filter out header guards and dynamic libraries export. The export is quite simple but without we would think that exports change the AST. Change-Id: Ic16f60a6675e397dfd769c53caf77056708d8459 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-23 14:10:17 +01:00
Contains(HasSymbolName("function")));
Clang: Add Symbol Indexing It is a first step and now a database is generated if you start QtCreator. Some code is now shared with the PchManager which can be improved in the future. Change-Id: Ic267fe7960f6c455d91832859a673ce98f269aa2 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-17 12:44:52 +02:00
}
Clang: Collect source files Change-Id: If0183cafd00ed7e42bacbdb72a1d65624dc03cee Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-10-26 13:23:27 +02:00
TEST_F(SymbolsCollector, SourceFiles)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Collect source files Change-Id: If0183cafd00ed7e42bacbdb72a1d65624dc03cee Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-10-26 13:23:27 +02:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceFiles(),
UnorderedElementsAre(filePathId(TESTDATA_DIR "/symbolscollector_main.cpp"),
filePathId(TESTDATA_DIR "/symbolscollector_header1.h"),
filePathId(TESTDATA_DIR "/symbolscollector_header2.h")));
}
TEST_F(SymbolsCollector, MainFileInSourceFiles)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Collect source files Change-Id: If0183cafd00ed7e42bacbdb72a1d65624dc03cee Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-10-26 13:23:27 +02:00
ASSERT_THAT(collector.sourceFiles(),
ElementsAre(filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")));
}
TEST_F(SymbolsCollector, ResetMainFileInSourceFiles)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Collect source files Change-Id: If0183cafd00ed7e42bacbdb72a1d65624dc03cee Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-10-26 13:23:27 +02:00
ASSERT_THAT(collector.sourceFiles(),
ElementsAre(filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")));
}
TEST_F(SymbolsCollector, DontDuplicateSourceFiles)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Collect source files Change-Id: If0183cafd00ed7e42bacbdb72a1d65624dc03cee Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-10-26 13:23:27 +02:00
collector.collectSymbols();
collector.collectSymbols();
ASSERT_THAT(collector.sourceFiles(),
UnorderedElementsAre(filePathId(TESTDATA_DIR "/symbolscollector_main.cpp"),
filePathId(TESTDATA_DIR "/symbolscollector_header1.h"),
filePathId(TESTDATA_DIR "/symbolscollector_header2.h")));
}
Clang: Clear SymbolCollector before updating new project parts Change-Id: I82e9bb4f66a7597bb911fbc97d6022ff3fdb0b35 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-12-13 12:04:19 +01:00
TEST_F(SymbolsCollector, ClearSourceFiles)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Clear SymbolCollector before updating new project parts Change-Id: I82e9bb4f66a7597bb911fbc97d6022ff3fdb0b35 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-12-13 12:04:19 +01:00
collector.clear();
ASSERT_THAT(collector.sourceFiles(), IsEmpty());
}
TEST_F(SymbolsCollector, ClearSymbols)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Clear SymbolCollector before updating new project parts Change-Id: I82e9bb4f66a7597bb911fbc97d6022ff3fdb0b35 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-12-13 12:04:19 +01:00
collector.collectSymbols();
collector.clear();
ASSERT_THAT(collector.symbols(), IsEmpty());
}
TEST_F(SymbolsCollector, ClearSourceLocations)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Clear SymbolCollector before updating new project parts Change-Id: I82e9bb4f66a7597bb911fbc97d6022ff3fdb0b35 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-12-13 12:04:19 +01:00
collector.collectSymbols();
collector.clear();
ASSERT_THAT(collector.sourceLocations(), IsEmpty());
}
TEST_F(SymbolsCollector, DontCollectSymbolsAfterFilesAreCleared)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Clear SymbolCollector before updating new project parts Change-Id: I82e9bb4f66a7597bb911fbc97d6022ff3fdb0b35 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-12-13 12:04:19 +01:00
collector.clear();
collector.collectSymbols();
ASSERT_THAT(collector.symbols(), IsEmpty());
}
TEST_F(SymbolsCollector, DontCollectSourceFilesAfterFilesAreCleared)
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.addFiles({filePathId(TESTDATA_DIR "/symbolscollector_main.cpp")}, {"cc"});
Clang: Clear SymbolCollector before updating new project parts Change-Id: I82e9bb4f66a7597bb911fbc97d6022ff3fdb0b35 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2017-12-13 12:04:19 +01:00
collector.clear();
collector.collectSymbols();
ASSERT_THAT(collector.sourceFiles(), IsEmpty());
}
Clang: Improve Macro collection Now undefined macros are added to used macros but we filter out header guards and dynamic libraries export. The export is quite simple but without we would think that exports change the AST. Change-Id: Ic16f60a6675e397dfd769c53caf77056708d8459 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-23 14:10:17 +01:00
TEST_F(SymbolsCollector, CollectUsedDefinesWithExternalDefine)
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.usedDefines(),
ElementsAre(Eq(UsedDefine{"DEFINED", fileId}),
Eq(UsedDefine{"IF_DEFINE", fileId}),
Eq(UsedDefine{"__clang__", fileId}),
Eq(UsedDefine{"IF_NOT_DEFINE", fileId}),
Eq(UsedDefine{"MACRO_EXPANSION", fileId}),
Eq(UsedDefine{"COMPILER_ARGUMENT", fileId})));
}
Clang: Improve Macro collection Now undefined macros are added to used macros but we filter out header guards and dynamic libraries export. The export is quite simple but without we would think that exports change the AST. Change-Id: Ic16f60a6675e397dfd769c53caf77056708d8459 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-23 14:10:17 +01:00
TEST_F(SymbolsCollector, CollectUsedDefinesWithoutExternalDefine)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc"});
collector.collectSymbols();
ASSERT_THAT(collector.usedDefines(),
ElementsAre(Eq(UsedDefine{"DEFINED", fileId}),
Eq(UsedDefine{"IF_DEFINE", fileId}),
Eq(UsedDefine{"__clang__", fileId}),
Eq(UsedDefine{"IF_NOT_DEFINE", fileId}),
Eq(UsedDefine{"MACRO_EXPANSION", fileId}),
Eq(UsedDefine{"COMPILER_ARGUMENT", fileId})));
}
TEST_F(SymbolsCollector, DontCollectHeaderGuards)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc"});
collector.collectSymbols();
ASSERT_THAT(collector.usedDefines(),
Not(Contains(Eq(UsedDefine{"SYMBOLSCOLLECTOR_DEFINES_H", fileId}))));
}
TEST_F(SymbolsCollector, DontCollectDynamicLibraryExports)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc"});
collector.collectSymbols();
ASSERT_THAT(collector.usedDefines(),
Not(Contains(Eq(UsedDefine{"CLASS_EXPORT", fileId}))));
}
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
TEST_F(SymbolsCollector, CollectMacroDefinitionSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("IF_NOT_DEFINE"), fileId, 4, 9, SymbolType::MacroDefinition)));
}
TEST_F(SymbolsCollector, CollectMacroUsageInIfNotDefSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("IF_NOT_DEFINE"), fileId, 6, 9, SymbolType::MacroUsage)));
}
TEST_F(SymbolsCollector, CollectSecondMacroUsageInIfNotDefSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("IF_NOT_DEFINE"), fileId, 9, 9, SymbolType::MacroUsage)));
}
TEST_F(SymbolsCollector, CollectMacroUsageCompilerArgumentSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("COMPILER_ARGUMENT"), fileId, 12, 9, SymbolType::MacroUsage)));
}
TEST_F(SymbolsCollector, CollectMacroUsageInIfDefSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("IF_DEFINE"), fileId, 17, 8, SymbolType::MacroUsage)));
}
TEST_F(SymbolsCollector, CollectMacroUsageInDefinedSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("DEFINED"), fileId, 22, 13, SymbolType::MacroUsage)));
}
TEST_F(SymbolsCollector, CollectMacroUsageExpansionSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("MACRO_EXPANSION"), fileId, 27, 10, SymbolType::MacroUsage)));
}
TEST_F(SymbolsCollector, CollectMacroUsageUndefSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("UN_DEFINE"), fileId, 34, 8, SymbolType::MacroUndefinition)));
}
TEST_F(SymbolsCollector, CollectMacroUsageBuiltInSourceLocation)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.sourceLocations(),
Contains(IsSourceLocationEntry(symbolId("__clang__"), fileId, 29, 9, SymbolType::MacroUsage)));
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
}
Clang: Improve Macro collection Now undefined macros are added to used macros but we filter out header guards and dynamic libraries export. The export is quite simple but without we would think that exports change the AST. Change-Id: Ic16f60a6675e397dfd769c53caf77056708d8459 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-23 14:10:17 +01:00
TEST_F(SymbolsCollector, CollectMacroDefinitionSymbols)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc"});
collector.collectSymbols();
ASSERT_THAT(collector.symbols(),
Contains(HasSymbolName("IF_NOT_DEFINE")));
}
TEST_F(SymbolsCollector, CollectMacroBuiltInSymbols)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc"});
collector.collectSymbols();
ASSERT_THAT(collector.symbols(),
Contains(HasSymbolName("__clang__")));
}
TEST_F(SymbolsCollector, CollectMacroCompilerArgumentSymbols)
{
auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
collector.collectSymbols();
ASSERT_THAT(collector.symbols(),
Contains(HasSymbolName("COMPILER_ARGUMENT")));
}
Clang: Add symbols collector Change-Id: I64c25eef8eaa6cc6c3ff09d41866972b6c7248d0 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-07-24 14:55:51 +02:00
}
Copy Permalink