837 lines
31 KiB
C++
837 lines
31 KiB
C++
#include "Test/Tester.h"
|
|
#include "Index/HeaderIndex.h"
|
|
|
|
namespace clice::testing {
|
|
|
|
namespace {
|
|
|
|
using namespace clice::index::memory;
|
|
|
|
struct DumpConfig {
|
|
bool enable_total = false;
|
|
bool enable_contexts = false;
|
|
bool enable_symbol = false;
|
|
bool enable_occurrence = false;
|
|
};
|
|
|
|
auto dump = [](HeaderIndex& index, DumpConfig config) {
|
|
if(config.enable_total) {
|
|
std::println("\n---------------------------Total Info---------------------------");
|
|
std::println("file count: {}", index.file_count());
|
|
std::println("header context count: {}", index.header_context_count());
|
|
std::println("canonical context count: {}", index.canonical_context_count());
|
|
std::println("symbol count: {}", index.symbols.size());
|
|
std::println("occurrence count: {}", index.occurrences.size());
|
|
}
|
|
|
|
if(config.enable_contexts) {
|
|
std::println("\n--------------------------Contexts Info-------------------------");
|
|
for(auto& [path, contents]: index.header_contexts) {
|
|
std::println("{}:", path);
|
|
for(auto& context: contents) {
|
|
std::println(" include: {}, hctx_id: {}, cctx_id: {}",
|
|
context.include,
|
|
context.hctx_id,
|
|
context.cctx_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(config.enable_symbol) {
|
|
std::println("\n-------------------------Symbols Info--------------------------");
|
|
for(auto& [symbol_id, symbol]: index.symbols) {
|
|
std::println("symbol: {}, kind: {}", symbol.name, symbol.kind.name());
|
|
for(auto& relation: symbol.relations) {
|
|
if(relation.ctx.is_dependent()) {
|
|
auto context = index.dependent_elem_states[relation.ctx.offset()];
|
|
std::println(" kind: {}, context: {:#b}",
|
|
relation.kind.name(),
|
|
context.to_ulong());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(config.enable_occurrence) {
|
|
std::println("\n-------------------------Occurrences Info--------------------------");
|
|
for(auto& [range, occurrences]: index.occurrences) {
|
|
std::println("occurrence: {} {}", range.begin, range.end);
|
|
for(auto& occurrence: occurrences) {
|
|
if(occurrence.ctx.is_dependent()) {
|
|
auto context = index.dependent_elem_states[occurrence.ctx.offset()];
|
|
std::println(" target: {}, context: {:#b}",
|
|
occurrence.target_symbol,
|
|
context.to_ulong());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/// TODO: We should have a more clean way to save test data(like json), rather than out put code
|
|
/// directly.
|
|
auto test_code = [](HeaderIndex& index, std::uint32_t id) {
|
|
std::string code;
|
|
std::string index_name = std::format("index{}", id);
|
|
code += std::format("RawIndex {};", index_name);
|
|
auto& [path, contexts] = *index.header_contexts.begin();
|
|
code += std::format(R"({}.add_context("{}", {});)", index_name, path, contexts[0].include);
|
|
code += "\n";
|
|
|
|
for(auto& [symbol_id, symbol]: index.symbols) {
|
|
code += "{";
|
|
code += std::format(R"(
|
|
auto& symbol = {}.get_symbol({}ull);
|
|
symbol.name = "{}";
|
|
symbol.kind = SymbolKind::{};
|
|
)",
|
|
index_name,
|
|
symbol_id,
|
|
symbol.name,
|
|
symbol.kind.name());
|
|
code += "\n";
|
|
|
|
for(auto& relation: symbol.relations) {
|
|
code += std::format(R"({}.add_relation(
|
|
symbol,
|
|
Relation{{
|
|
.kind = RelationKind::{},
|
|
.range = {{ {}, {} }},
|
|
.target_symbol = {}ull,
|
|
}}
|
|
);)",
|
|
index_name,
|
|
relation.kind.name(),
|
|
relation.range.begin,
|
|
relation.range.end,
|
|
relation.target_symbol);
|
|
}
|
|
code += "}\n";
|
|
}
|
|
|
|
// for(auto& [range, occurrence_group]: index.occurrences) {
|
|
// code += "{";
|
|
// code += std::format("LocalSourceRange range{{ {}, {} }};\n", range.begin, range.end);
|
|
// for(auto& occurrence: occurrence_group) {
|
|
// code += std::format("index.add_occurrence(range, {});\n",
|
|
// occurrence.target_symbol);
|
|
// }
|
|
// code += "}";
|
|
// }
|
|
|
|
return code;
|
|
};
|
|
|
|
suite<"HeaderIndex"> header_index = [] {
|
|
test("AddRemoveContext") = [&] {
|
|
HeaderIndex index;
|
|
|
|
{
|
|
auto context = index.add_context("test.h", 1);
|
|
expect(that % context.cctx_id == 0);
|
|
expect(that % context.hctx_id == 0);
|
|
expect(that % index.header_context_count() == 1);
|
|
expect(that % index.canonical_context_count() == 1);
|
|
}
|
|
|
|
{
|
|
auto context = index.add_context("test.h", 2);
|
|
expect(that % context.cctx_id == 1);
|
|
expect(that % context.hctx_id == 1);
|
|
expect(that % index.header_context_count() == 2);
|
|
expect(that % index.canonical_context_count() == 2);
|
|
}
|
|
|
|
expect(that % index.file_count() == 1);
|
|
|
|
{
|
|
auto context = index.add_context("test2.h", 1);
|
|
expect(that % context.cctx_id == 2);
|
|
expect(that % context.hctx_id == 2);
|
|
expect(that % index.header_context_count() == 3);
|
|
expect(that % index.canonical_context_count() == 3);
|
|
}
|
|
|
|
expect(that % index.file_count() == 2);
|
|
|
|
index.remove("test.h");
|
|
|
|
expect(that % index.header_context_count() == 1);
|
|
expect(that % index.canonical_context_count() == 1);
|
|
|
|
/// Test reuse context id and context ref.
|
|
{
|
|
auto context = index.add_context("test3.h", 1);
|
|
expect(that % context.cctx_id == 0);
|
|
expect(that % context.hctx_id == 0);
|
|
expect(that % index.header_context_count() == 2);
|
|
expect(that % index.canonical_context_count() == 2);
|
|
}
|
|
|
|
{
|
|
index.add_context("test4.h", 1);
|
|
expect(that % index.header_context_count() == 3);
|
|
expect(that % index.canonical_context_count() == 3);
|
|
}
|
|
|
|
{
|
|
index.add_context("test5.h", 1);
|
|
expect(that % index.header_context_count() == 4);
|
|
expect(that % index.canonical_context_count() == 4);
|
|
}
|
|
|
|
expect(that % index.file_count() == 4);
|
|
};
|
|
|
|
test("SymbolInsert") = [&] {
|
|
HeaderIndex index;
|
|
index.add_context("test.h", 1);
|
|
index.add_occurrence({1, 2}, 1);
|
|
};
|
|
|
|
test("MergeEmpty") = [&] {
|
|
HeaderIndex base;
|
|
|
|
RawIndex index;
|
|
index.add_occurrence({1, 2}, 1);
|
|
base.merge("test.h", 1, index);
|
|
expect(that % base.header_context_count() == 1);
|
|
expect(that % base.canonical_context_count() == 1);
|
|
expect(that % base.file_count() == 1);
|
|
|
|
RawIndex index2;
|
|
base.merge("test2.h", 1, index2);
|
|
expect(that % base.header_context_count() == 2);
|
|
expect(that % base.canonical_context_count() == 2);
|
|
expect(that % base.file_count() == 2);
|
|
|
|
RawIndex index3;
|
|
base.merge("test3.h", 1, index3);
|
|
expect(that % base.header_context_count() == 3);
|
|
expect(that % base.canonical_context_count() == 2);
|
|
expect(that % base.file_count() == 3);
|
|
};
|
|
|
|
test("MergeOccurrence") = [&] {
|
|
HeaderIndex base;
|
|
|
|
RawIndex index;
|
|
index.add_occurrence({1, 2}, 1);
|
|
base.merge("test.h", 1, index);
|
|
|
|
RawIndex index2;
|
|
index2.add_occurrence({1, 2}, 1);
|
|
base.merge("test2.h", 1, index2);
|
|
expect(that % base.header_context_count() == 2);
|
|
expect(that % base.canonical_context_count() == 1);
|
|
expect(that % base.file_count() == 2);
|
|
|
|
RawIndex index3;
|
|
index3.add_occurrence({1, 2}, 2);
|
|
base.merge("test3.h", 1, index3);
|
|
expect(that % base.header_context_count() == 3);
|
|
expect(that % base.canonical_context_count() == 2);
|
|
expect(that % base.file_count() == 3);
|
|
};
|
|
|
|
test("MergeSymbol") = [&] {
|
|
LocalSourceRange range = {0, 0};
|
|
|
|
HeaderIndex base;
|
|
{
|
|
RawIndex index;
|
|
auto& symbol = index.get_symbol(1);
|
|
index.add_relation(symbol, Relation{.kind = RelationKind::Reference, .range = range});
|
|
base.merge("test.h", 1, index);
|
|
}
|
|
|
|
/// Same canonical context.
|
|
{
|
|
RawIndex index;
|
|
auto& symbol = index.get_symbol(1);
|
|
index.add_relation(symbol, Relation{.kind = RelationKind::Reference, .range = range});
|
|
auto context = base.merge("test2.h", 1, index);
|
|
expect(that % context.hctx_id == 1);
|
|
expect(that % context.cctx_id == 0);
|
|
expect(that % base.header_context_count() == 2);
|
|
expect(that % base.canonical_context_count() == 1);
|
|
expect(that % base.file_count() == 2);
|
|
}
|
|
|
|
/// New canonical context.
|
|
{
|
|
RawIndex index;
|
|
auto& symbol = index.get_symbol(1);
|
|
index.add_relation(symbol, Relation{.kind = RelationKind::Definition, .range = range});
|
|
|
|
auto context = base.merge("test3.h", 1, index);
|
|
expect(that % context.hctx_id == 2);
|
|
expect(that % context.cctx_id == 1);
|
|
expect(that % base.header_context_count() == 3);
|
|
expect(that % base.canonical_context_count() == 2);
|
|
expect(that % base.file_count() == 3);
|
|
}
|
|
|
|
/// New canonical context.
|
|
{
|
|
RawIndex index;
|
|
auto& symbol = index.get_symbol(1);
|
|
index.add_relation(symbol, Relation{.kind = RelationKind::Definition, .range = range});
|
|
index.add_relation(symbol, Relation{.kind = RelationKind::Declaration, .range = range});
|
|
|
|
auto context = base.merge("test4.h", 1, index);
|
|
expect(that % context.hctx_id == 3);
|
|
expect(that % context.cctx_id == 2);
|
|
expect(that % base.header_context_count() == 4);
|
|
expect(that % base.canonical_context_count() == 3);
|
|
expect(that % base.file_count() == 4);
|
|
}
|
|
};
|
|
|
|
test("MergeReuse") = [&] {
|
|
LocalSourceRange range = {0, 0};
|
|
HeaderIndex base;
|
|
|
|
RawIndex index;
|
|
index.add_occurrence(range, 1);
|
|
base.merge("test.h", 1, index);
|
|
|
|
/// Same context
|
|
RawIndex index2;
|
|
index2.add_occurrence(range, 1);
|
|
base.merge("test.h", 2, index2);
|
|
expect(that % base.canonical_context_count() == 1);
|
|
|
|
/// New Context
|
|
RawIndex index3;
|
|
index3.add_occurrence(range, 2);
|
|
base.merge("test.h", 3, index3);
|
|
expect(that % base.canonical_context_count() == 2);
|
|
|
|
/// Same Context
|
|
RawIndex index4;
|
|
index4.add_occurrence(range, 1);
|
|
base.merge("test.h", 4, index4);
|
|
expect(that % base.canonical_context_count() == 2);
|
|
};
|
|
|
|
test("MergeComplex") = [] {
|
|
RawIndex index1;
|
|
{
|
|
auto& symbol = index1.get_symbol(5617328926567294902ull);
|
|
symbol.name = "__need_wchar_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {1948, 1962},
|
|
.target_symbol = 8426725836700ull,
|
|
});
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4100, 4114},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index1.get_symbol(17660704465322401956ull);
|
|
symbol.name = "__need_offsetof";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4720, 4735},
|
|
.target_symbol = 0ull,
|
|
});
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3433, 3448},
|
|
.target_symbol = 14809047240041ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index1.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {1734, 1747},
|
|
.target_symbol = 7503307867846ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index1.get_symbol(447841485290421751ull);
|
|
symbol.name = "__need_max_align_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3399, 3417},
|
|
.target_symbol = 14675903253831ull,
|
|
});
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4592, 4610},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index1.get_symbol(3892980363519083943ull);
|
|
symbol.name = "__need_nullptr_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3138, 3154},
|
|
.target_symbol = 13546326854722ull,
|
|
});
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4328, 4344},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index1.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3005, 3016},
|
|
.target_symbol = 12953621367741ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index1.get_symbol(13138966718646481517ull);
|
|
symbol.name = "__cplusplus";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3367, 3378},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index1.get_symbol(4048786579988097027ull);
|
|
symbol.name = "__need_ptrdiff_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {1709, 1725},
|
|
.target_symbol = 7408818587309ull,
|
|
});
|
|
index1.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3747, 3763},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index2;
|
|
{
|
|
auto& symbol = index2.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index2.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index2.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index2.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index3;
|
|
|
|
{
|
|
auto& symbol = index3.get_symbol(5617328926567294902ull);
|
|
symbol.name = "__need_wchar_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index3.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4100, 4114},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index3.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index3.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index3.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index3.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index4;
|
|
{
|
|
auto& symbol = index4.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index4.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index4.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index4.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index5;
|
|
{
|
|
auto& symbol = index5.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index5.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index6;
|
|
{
|
|
auto& symbol = index6.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index6.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index6.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index6.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index7;
|
|
{
|
|
auto& symbol = index7.get_symbol(5617328926567294902ull);
|
|
symbol.name = "__need_wchar_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {1948, 1962},
|
|
.target_symbol = 8426725836700ull,
|
|
});
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4100, 4114},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index7.get_symbol(17660704465322401956ull);
|
|
symbol.name = "__need_offsetof";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4720, 4735},
|
|
.target_symbol = 0ull,
|
|
});
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3433, 3448},
|
|
.target_symbol = 14809047240041ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index7.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {1734, 1747},
|
|
.target_symbol = 7503307867846ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index7.get_symbol(447841485290421751ull);
|
|
symbol.name = "__need_max_align_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3399, 3417},
|
|
.target_symbol = 14675903253831ull,
|
|
});
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4592, 4610},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index7.get_symbol(3892980363519083943ull);
|
|
symbol.name = "__need_nullptr_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3138, 3154},
|
|
.target_symbol = 13546326854722ull,
|
|
});
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4328, 4344},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index7.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {3005, 3016},
|
|
.target_symbol = 12953621367741ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index7.get_symbol(13138966718646481517ull);
|
|
symbol.name = "__cplusplus";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3367, 3378},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index7.get_symbol(4048786579988097027ull);
|
|
symbol.name = "__need_ptrdiff_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Definition,
|
|
.range = {1709, 1725},
|
|
.target_symbol = 7408818587309ull,
|
|
});
|
|
index7.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3747, 3763},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index8;
|
|
{
|
|
auto& symbol = index8.get_symbol(5617328926567294902ull);
|
|
symbol.name = "__need_wchar_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index8.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4100, 4114},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index8.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index8.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
{
|
|
auto& symbol = index8.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index8.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index9;
|
|
{
|
|
auto& symbol = index9.get_symbol(6389328935281374692ull);
|
|
symbol.name = "__need_NULL";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index9.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {4212, 4223},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
RawIndex index10;
|
|
{
|
|
auto& symbol = index10.get_symbol(12199573421319547529ull);
|
|
symbol.name = "__need_size_t";
|
|
symbol.kind = SymbolKind::Macro;
|
|
|
|
index10.add_relation(symbol,
|
|
Relation{
|
|
.kind = RelationKind::Reference,
|
|
.range = {3867, 3880},
|
|
.target_symbol = 0ull,
|
|
});
|
|
}
|
|
|
|
{
|
|
HeaderIndex base;
|
|
auto context = base.merge("main.cpp", 56, index1);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{56, 0, 0}));
|
|
|
|
context = base.merge("main.cpp", 83, index2);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{83, 1, 1}));
|
|
|
|
context = base.merge("main.cpp", 87, index3);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{87, 2, 2}));
|
|
|
|
context = base.merge("main.cpp", 118, index4);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{118, 3, 1}));
|
|
|
|
context = base.merge("main.cpp", 135, index5);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{135, 4, 3}));
|
|
|
|
context = base.merge("main.cpp", 147, index6);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{147, 5, 1}));
|
|
|
|
context = base.merge("main.cpp", 150, index7);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{150, 6, 0}));
|
|
|
|
context = base.merge("main.cpp", 178, index8);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{178, 7, 2}));
|
|
|
|
context = base.merge("main.cpp", 212, index9);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{212, 8, 4}));
|
|
|
|
context = base.merge("main.cpp", 226, index10);
|
|
expect(refl::equal(context, HeaderIndex::HeaderContext{226, 9, 3}));
|
|
}
|
|
};
|
|
};
|
|
|
|
#if 0
|
|
|
|
#endif
|
|
} // namespace
|
|
|
|
} // namespace clice::testing
|