constexpr static bool print_results = false;

vector_map<cppm::scan_item_idx_t, depinfo::DepInfo> all_infos;

vector_map<cppm::scan_item_idx_t, char> is_ood;

std::size_t nr_results = 0;

DepInfoCollector(span_map<cppm::scan_item_idx_t, const cppm::ScanItemView> items) : items(items) {

all_infos.resize(items.size());

is_ood.resize(items.size());

}

span_map<cppm::scan_item_idx_t, const cppm::ScanItemView> items;

std::vector<depinfo::DataBlock> data_table;

depinfo::DepInfo* cur_info = nullptr;

cppm::scan_item_idx_t current_item_idx = {};

depinfo::DataBlock get_data(DataBlockView view) {

return std::visit(overloaded {

[&](std::string_view sv) -> depinfo::DataBlock {

return (std::string)sv;

}, [&](IndexedStringView isv) -> depinfo::DataBlock {

while (data_table.size() <= isv.idx) // todo:

data_table.emplace_back();

data_table[isv.idx] = (std::string)isv.sv;

return (std::string)isv.sv;

}, [&](std::size_t idx) -> depinfo::DataBlock {

if (idx >= data_table.size())

throw std::runtime_error("index out of range");

return data_table[idx];

}, [&](RawDataBlockView rdv) -> depinfo::DataBlock {

throw std::runtime_error("raw data blocks are not supported");

}, [&](IndexedRawDataBlockView irdv) -> depinfo::DataBlock {

throw std::runtime_error("raw data blocks are not supported");

} }, view);

}

std::string_view get_str(DataBlockView view) {

return std::get<std::string_view>(view);

}

template<typename T>

T& ens(std::optional<T>& opt) {

if (!opt.has_value())

opt = T {};

return opt.value();

}

void results_for_item(cppm::scan_item_idx_t item_idx, bool out_of_date) override {

current_item_idx = item_idx;

cur_info = &all_infos[current_item_idx];

//cur_info->input = (std::string)items[current_item_idx].path;

cur_info->input = (std::size_t)current_item_idx;

is_ood[current_item_idx] = out_of_date;

if (print_results) fmt::print("test: current item = {}\n", items[current_item_idx].path);

}

void export_module(DataBlockView name) override {

ens(ens(cur_info->future_compile).provide).push_back(

{ .logical_name = get_data(name) }

);

if (print_results) fmt::print("test: \texport module {}\n", get_str(name));

}

void import_module(DataBlockView name) override {

ens(ens(cur_info->future_compile).require).push_back(

{ .logical_name = get_data(name) }

);

if (print_results) fmt::print("test: \timport module {}\n", get_str(name));

}

void include_header(DataBlockView path) override {

ens(cur_info->depends).push_back(

get_data(path)

);

if (print_results) fmt::print("test: \tinclude {}\n", get_str(path));

}

void import_header(DataBlockView path) override {

ens(ens(cur_info->future_compile).require).push_back(

{ .source_path = get_data(path) }

);

if (print_results) fmt::print("test: \timport header {}\n", get_str(path));

}

void other_file_dep(DataBlockView path) override {

ens(cur_info->depends).push_back(

get_data(path)

);

if (print_results) fmt::print("test: \tdep {}\n", get_str(path));

}

void item_finished() override {

nr_results++;

}

timer t;

cppm::Scanner scanner;

auto item_set_owned_view = cppm::ScanItemSetOwnedView::from(item_set);

auto item_set_view = cppm::ScanItemSetView::from(item_set_owned_view);

//DepInfoCollector collector(item_set_view.items);

cppm::Scanner::ConfigView config;

config.tool_type = cppm::Scanner::Type::CLANG_SCAN_DEPS;

config.tool_path = clang_scan_deps_path;

config.db_path = single_db_path;

config.int_dir = config.db_path;

config.item_set = item_set_view;

config.concurrent_targets = false;

config.file_tracker_running = false;

//config.observer = &collector;

t.start();

scanner.scan(config);

t.stop();

if (str.size() < with.size())

return false;

return str.substr(str.size() - with.size(), with.size()) == with;

cppm::ScanItemSet item_set;

vector_map<cppm::scan_item_idx_t, depinfo::DepInfo> all_results;

vector_map<cppm::scan_item_idx_t, char> observer_result_is_ood;

std::size_t nr_results = 0;

vector_map<cppm::scan_item_idx_t, char> has_previous_result;

vector_map<cppm::scan_item_idx_t, cppm::Scanner::Result> scanner_results;

std::unique_ptr<cppm::ModuleVisitor> collated_results;

vector_map< cppm::scan_item_idx_t, char> expect_results;

vector_map<cppm::scan_item_idx_t, depinfo::DepInfo> all_expected;

// the set of scan item indices expected to be imported by each item

std::vector<std::vector<cppm::scan_item_idx_t>> expected_module_imports;

int scan_counter = 0;

int current_line = 0; // line from which the last test method was called

bool submit_previous_results = false;

void set_expected(depinfo::DepFormat expected, std::vector<std::vector<cppm::scan_item_idx_t>> expected_module_imports = {}) {

init_optionals(expected);

all_expected.clear();

// todo: this assumes expected.sources is ordered the same as item_set.items

for (auto& depinfo : expected.sources)

all_expected.push_back(std::move(depinfo));

this->expected_module_imports = std::move(expected_module_imports);

this->expected_module_imports.resize((std::size_t)all_expected.size());

has_previous_result.resize(all_expected.size());

}

TempFileScanTest() : TempFileTest() {

all_files_created.insert("scanner.mdb"); // todo: pass the names to scanner

all_files_created.insert("scanner.mdb-lock");

all_files_created.insert("pp_commands.json");

item_set.item_root_path = tmp_path_str;

item_set.commands_contain_item_path = false; // todo: test when this is true

}

void create_deps(std::string_view file_def) {

create_files(file_def, [&](const std::string&) {});

}

void add_item(const std::string& file, cppm::target_idx_t target_idx) {

item_set.items.push_back({

.path = file,

.command_idx = item_set.commands.size(),

.target_idx = target_idx,

.is_header_unit = ends_with(file, ".h")

});

std::string cmd = fmt::format("{} /Fo\"{}.{}.obj\" /D {}",

default_command, file, item_set.targets[target_idx], default_cmd_suffix);

item_set.commands.emplace_back(std::move(cmd));

}

void remove_item(cppm::scan_item_idx_t idx) {

item_set.items.erase(item_set.items.begin() + (std::size_t)idx);

item_set.commands.erase(item_set.commands.begin() + (std::size_t)idx);

}

void create_items(std::string_view target_name, std::string_view file_def,

std::vector<std::string> file_refs = {})

{

auto target_idx = item_set.targets.size();

item_set.targets.push_back((std::string)target_name);

create_files(file_def, [&](std::string file) {

add_item(file, target_idx);

});

for (auto& file : file_refs)

add_item(file, target_idx);

}

void set_command_suffix(cppm::scan_item_idx_t idx, std::string_view suffix) {

// by construction, cmd idx == item idx

std::string& cmd = item_set.commands[id_cast<cppm::cmd_idx_t>(idx)];

auto d_pos = cmd.rfind("/D ");

assert(d_pos != std::string::npos);

auto prev_suffix_pos = d_pos + 3;

auto prev_suffix_length = cmd.size() - prev_suffix_pos;

cmd.replace(prev_suffix_pos, prev_suffix_length, suffix);

}

void scan() {

auto item_set_owned_view = cppm::ScanItemSetOwnedView::from(item_set);

auto item_set_view = cppm::ScanItemSetView::from(item_set_owned_view);

collated_results = std::make_unique<cppm::ModuleVisitor>();

DepInfoCollector collector(item_set_view.items);

cppm::Scanner::ConfigView config;

config.tool_type = cppm::Scanner::Type::CLANG_SCAN_DEPS;

config.tool_path = clang_scan_deps_path;

config.db_path = tmp_path_str;

config.int_dir = config.db_path;

config.item_set = item_set_view;

config.concurrent_targets = false;

config.file_tracker_running = false;

config.observer = &collector;

config.submit_previous_results = submit_previous_results;

if(submit_previous_results)

config.collated_results = collated_results.get();

cppm::Scanner scanner;

auto what = fmt::format("scan {}", ++scan_counter);

timer t;

t.start();

scanner_results = scanner.scan(config);

t.stop(what);

all_results = std::move(collector.all_infos);

observer_result_is_ood = std::move(collector.is_ood);

nr_results = collector.nr_results;

}

void clean() {

auto item_set_owned_view = cppm::ScanItemSetOwnedView::from(item_set);

auto item_set_view = cppm::ScanItemSetView::from(item_set_owned_view);

cppm::Scanner::ConfigView config;

config.db_path = tmp_path_str;

config.item_set = item_set_view;

cppm::Scanner scanner;

scanner.clean(config);

for (auto& has : has_previous_result)

has = false;

}

using opt_db_vec = std::optional<std::vector<depinfo::DataBlock>>;

std::string tmp_relative_path(const depinfo::DataBlock& path) {

fs::path source_path = std::get<std::string>(path);

if (source_path.is_absolute())

source_path = fs::relative(source_path, tmp_path);

return source_path.string();

}

void canonicalize(opt_db_vec& result_opt, opt_db_vec& expected_opt) {

for (auto& file : result_opt.value())

file = fs::canonical(std::get<std::string>(file)).string();

for (auto& file : expected_opt.value())

file = fs::canonical(tmp_path / std::get<std::string>(file)).string();

}

template<typename T>

void init_opt(std::optional<T>& opt) {

if (!opt.has_value())

opt.emplace();

}

void init_optionals(depinfo::DepInfo& depinfo) {

init_opt(depinfo.outputs);

init_opt(depinfo.depends);

init_opt(depinfo.future_compile);

auto& fc = depinfo.future_compile.value();

init_opt(fc.output);

init_opt(fc.provide);

init_opt(fc.require);

for (auto& mod : fc.provide.value())

init_opt(mod.compiled_module_path);

for (auto& mod : fc.require.value())

init_opt(mod.compiled_module_path);

}

void init_optionals(depinfo::DepFormat& depformat) {

for (auto& depinfo : depformat.sources)

init_optionals(depinfo);

}

auto get_module_names(std::optional<std::vector<depinfo::ModuleDesc>>& from) {

std::vector<std::string> names;

for (auto& desc : from.value()) {

if (desc.source_path.has_value()) // header unit imports

names.push_back(tmp_relative_path(desc.source_path.value()));

else

names.push_back(std::get<std::string>(desc.logical_name));

}

return names;

}

void check(const std::vector<cppm::scan_item_idx_t>& ood_indices,

const std::vector<cppm::scan_item_idx_t>& fail_indices = {},

bool expect_collate_success = true)

{

auto to_id_map = [&](auto& vec) {

vector_map<cppm::scan_item_idx_t, char> id_map;

id_map.resize(item_set.items.size());

for (auto idx : vec)

id_map[idx] = true;

return id_map;

};

auto expect_is_ood = to_id_map(ood_indices);

auto expect_failed = to_id_map(fail_indices);

auto expect_result = [&](cppm::scan_item_idx_t idx) {

if (expect_failed[idx])

return false;

// if submit_previous_results then they should be available,

// unless this is the first scan or last time the scan failed

if (submit_previous_results && has_previous_result[idx])

return true;

// otherwise we only expect to get result for ood items that got scanned

return (bool)expect_is_ood[idx];

};

for (auto item_idx : all_results.indices()) {

depinfo::DepInfo& exp_info = all_expected[item_idx];

INFO("checking " << std::get<std::string>(exp_info.input) << " (" << (uint32_t)item_idx << ")");

cppm::Scanner::Result& res_ret = scanner_results[item_idx];

bool res_failed = (res_ret.scan == cppm::scan_state::failed);

bool res_is_ood = (res_ret.ood != cppm::ood_state::up_to_date &&

res_ret.ood != cppm::ood_state::unknown);

CHECK(res_failed == (bool)expect_failed[item_idx]);

CHECK(res_is_ood == (bool)expect_is_ood[item_idx]);

depinfo::DepInfo& res_info = all_results[item_idx];

bool got_result = std::holds_alternative<std::size_t>(res_info.input);

CHECK(got_result == expect_result(item_idx));

has_previous_result[item_idx] |= (char)got_result;

if (!got_result)

continue;

CHECK(observer_result_is_ood[item_idx] == expect_is_ood[item_idx]);

init_optionals(res_info);

//CHECK(std::get<std::string>(res_info.input) == input_file);

CHECK(std::get<std::size_t>(res_info.input) == (std::size_t)item_idx);

canonicalize(res_info.depends, exp_info.depends);

CHECK_THAT(res_info.depends.value(), UnorderedEquals(exp_info.depends.value()));

auto& res_fc = res_info.future_compile.value(), & exp_fc = exp_info.future_compile.value();

auto res_provides = get_module_names(res_fc.provide);

auto exp_provides = get_module_names(exp_fc.provide);

CHECK_THAT(res_provides, UnorderedEquals(exp_provides));

auto res_requires = get_module_names(res_fc.require);

auto exp_requires = get_module_names(exp_fc.require);

CHECK_THAT(res_requires, UnorderedEquals(exp_requires));

if (submit_previous_results) {

CHECK(collated_results->collate_success == expect_collate_success);

if (collated_results->collate_success) {

std::vector<cppm::scan_item_idx_t> res_imports;

for (auto imp_idx : collated_results->imports_item[item_idx])

res_imports.push_back(imp_idx);

//auto& res_imports = collated_results->imports_item[item_idx];

auto& exp_imports = expected_module_imports[(std::size_t)item_idx];

CHECK_THAT(res_imports, UnorderedEquals(exp_imports));

}

}

}

}

void scan_check(const std::vector<cppm::scan_item_idx_t>& ood_indices,

const std::vector<cppm::scan_item_idx_t>& fail_indices = {},

bool expect_collate_success = true)

{

INFO("line " << current_line);

scan();

check(ood_indices, fail_indices, expect_collate_success);

}

TempFileScanTest& set_line(int line) {

current_line = line;

return *this;

}