From 143b218e9e94f41b09633ddf38c542f708d9bab7 Mon Sep 17 00:00:00 2001 From: Stanislav Pankevich Date: Fri, 5 Mar 2021 00:23:24 +0100 Subject: [PATCH] White and black AST search: fix mutation locations for mutations in header files --- include/mull/AST/ASTMutationStorage.h | 11 +++-- include/mull/JunkDetection/CXX/ASTStorage.h | 2 +- include/mull/SourceLocation.h | 8 ++++ lib/AST/ASTFinder.cpp | 22 +++++++-- lib/AST/ASTMutationStorage.cpp | 24 +++++----- lib/AST/ASTVisitor.cpp | 10 ++-- lib/JunkDetection/CXX/ASTStorage.cpp | 2 +- lib/JunkDetection/CXX/CXXJunkDetector.cpp | 2 +- .../compile_commands.json.template | 16 +++++++ .../01_mutation_in_header_file/sample.cpp | 33 +++++++++++++ .../01_mutation_in_header_file/sum.h | 5 ++ .../ASTVisitor_ArithmeticAssignment_Tests.cpp | 40 ++++++++++------ .../ASTVisitor_Arithmetic_Tests.cpp | 40 ++++++++++------ .../ASTVisitor_BitwiseAssignment_Tests.cpp | 40 ++++++++++------ .../ASTVisitor/ASTVisitor_Bitwise_Tests.cpp | 40 ++++++++++------ .../ASTVisitor/ASTVisitor_Boundary_Tests.cpp | 32 ++++++++----- .../ASTVisitor_Comparison_Tests.cpp | 48 ++++++++++++------- .../ASTVisitor/ASTVisitor_Logical_Tests.cpp | 16 ++++--- .../ASTVisitor_RemoveVoid_Tests.cpp | 8 ++-- .../ASTVisitor_ReplaceCall_Tests.cpp | 8 ++-- .../Mutation_Arithmetic_Add_Test.cpp | 8 ++-- ...ation_Arithmetic_UnaryMinusToNoop_Test.cpp | 8 ++-- .../Mutation_ConstAssignment_AssignConst.cpp | 8 ++-- .../Mutation_ConstAssignment_InitConst.cpp | 10 ++-- .../Mutations-E2E/CXX/RemoveNegationTest.cpp | 8 ++-- .../01_Mutation_Scalar_ReturnValue_Test.cpp | 8 ++-- .../02_Mutation_Scalar_BinaryOperand_Test.cpp | 8 ++-- 27 files changed, 314 insertions(+), 151 deletions(-) create mode 100644 tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/compile_commands.json.template create mode 100644 tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sample.cpp create mode 100644 tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sum.h diff --git a/include/mull/AST/ASTMutationStorage.h b/include/mull/AST/ASTMutationStorage.h index 94f78c7bb..5fbb7aeaf 100644 --- a/include/mull/AST/ASTMutationStorage.h +++ b/include/mull/AST/ASTMutationStorage.h @@ -16,13 +16,16 @@ using LineColumnHash = int; using SourceFilePath = std::string; using SingleMutationTypeBucket = std::unordered_map; -using SingleASTUnitMutations = std::unordered_map; +using SingleFileMutations = std::unordered_map; +/// Single AST Unit consists of mutations found in its .c/.cpp file and mutations +/// found in the header files that are inlined by that AST unit. +using SingleASTUnitMutations = std::unordered_map; LineColumnHash lineColumnHash(int line, int column); class ASTMutationStorage { public: - std::unordered_map storage; + std::unordered_map storage; Diagnostics &diagnostics; ASTMutationStorage(Diagnostics &diagnostics); @@ -33,12 +36,12 @@ class ASTMutationStorage { int line, int column) const; bool mutationExists(const std::string &sourceFile, mull::MutatorKind mutatorKind, int line, - int column) const; + int column) const; void saveMutation(const std::string &sourceFile, mull::MutatorKind mutatorKind, const clang::Stmt *const expression, int line, int column); - void saveMutations(std::unordered_map &storage); + void saveMutations(std::unordered_map &storage); }; } // namespace mull diff --git a/include/mull/JunkDetection/CXX/ASTStorage.h b/include/mull/JunkDetection/CXX/ASTStorage.h index bee022fc3..ea8ab433e 100644 --- a/include/mull/JunkDetection/CXX/ASTStorage.h +++ b/include/mull/JunkDetection/CXX/ASTStorage.h @@ -56,7 +56,7 @@ class ASTStorage { void saveMutation(const std::string &sourceFile, mull::MutatorKind mutatorKind, const clang::Stmt *const expression, int line, int column); - void saveMutations(std::unordered_map &storage); + void saveMutations(std::unordered_map &storage); bool mutationExists(const std::string &sourceFile, mull::MutatorKind mutatorKind, int line, int column); diff --git a/include/mull/SourceLocation.h b/include/mull/SourceLocation.h index 0d5a7511c..b99f91865 100644 --- a/include/mull/SourceLocation.h +++ b/include/mull/SourceLocation.h @@ -10,6 +10,14 @@ class Function; namespace mull { struct SourceLocation { + /// The difference between (directory, filePath) and (unitDirectory, unitFilePath) + /// is as follows: + /// Both paths are the same when a mutation is located in the .c/.cpp file. + /// When a mutation is inlined into a preprocessed .c/.cpp file from a header file: + /// - the directory and filePath point to the location of the mutation in the + /// inlined header file. + /// - the unitDirectory and unitFilePath point to the location of the mutation + /// in the .c/.cpp file. std::string unitDirectory; std::string unitFilePath; std::string directory; diff --git a/lib/AST/ASTFinder.cpp b/lib/AST/ASTFinder.cpp index 675c41b0d..46747bd48 100644 --- a/lib/AST/ASTFinder.cpp +++ b/lib/AST/ASTFinder.cpp @@ -38,11 +38,25 @@ void ASTFinder::findMutations(Diagnostics &diagnostics, const Configuration &con tasks); finder.execute(); - std::unordered_map mutations; + std::unordered_map totalMutations; for (auto &unitMutationsPair : mutationsAsVector) { - mutations.emplace(unitMutationsPair.first, unitMutationsPair.second); + for (auto &singleFileMutations : unitMutationsPair.second) { + if (totalMutations.count(singleFileMutations.first) == 0) { + totalMutations.emplace(singleFileMutations.first, singleFileMutations.second); + continue; + } + SingleFileMutations &singleFileTotalMutations = totalMutations[singleFileMutations.first]; + for (const auto &oneMutationBucket : singleFileMutations.second) { + if (singleFileTotalMutations.count(oneMutationBucket.first) == 0) { + singleFileTotalMutations.emplace(oneMutationBucket.first, oneMutationBucket.second); + continue; + } + singleFileTotalMutations[oneMutationBucket.first].insert(oneMutationBucket.second.begin(), + oneMutationBucket.second.end()); + } + totalMutations.emplace(singleFileMutations.first, singleFileMutations.second); + } } - - storage.saveMutations(mutations); + storage.saveMutations(totalMutations); } diff --git a/lib/AST/ASTMutationStorage.cpp b/lib/AST/ASTMutationStorage.cpp index 1f9eb7db4..f57ec931b 100644 --- a/lib/AST/ASTMutationStorage.cpp +++ b/lib/AST/ASTMutationStorage.cpp @@ -20,10 +20,9 @@ ASTMutationStorage::ASTMutationStorage(Diagnostics &diagnostics) int ASTMutationStorage::count() const { int count = 0; - for (const auto &singleUnitMutations : storage) { - for (const auto &oneMutationBucket : - singleUnitMutations.second) { - count += singleUnitMutations.second.at(oneMutationBucket.first).size(); + for (const auto &singleFileMutations : storage) { + for (const auto &oneMutationBucket : singleFileMutations.second) { + count += singleFileMutations.second.at(oneMutationBucket.first).size(); } } return count; @@ -36,10 +35,10 @@ const ASTMutation &ASTMutationStorage::getMutation(const std::string &sourceFile assert(storage.count(sourceFile) > 0); - const SingleASTUnitMutations &astUnitMutations = storage.at(sourceFile); - assert(astUnitMutations.count(mutatorKind) > 0); + const SingleFileMutations &singleFileMutations = storage.at(sourceFile); + assert(singleFileMutations.count(mutatorKind) > 0); - const SingleMutationTypeBucket &oneMutationBucket = astUnitMutations.at(mutatorKind); + const SingleMutationTypeBucket &oneMutationBucket = singleFileMutations.at(mutatorKind); LineColumnHash hash = lineColumnHash(line, column); assert(oneMutationBucket.count(hash) > 0); @@ -56,12 +55,12 @@ bool ASTMutationStorage::mutationExists(const std::string &sourceFile, return false; } - const SingleASTUnitMutations &astUnitMutations = storage.at(sourceFile); - if (astUnitMutations.count(mutatorKind) == 0) { + const SingleFileMutations &singleFileMutations = storage.at(sourceFile); + if (singleFileMutations.count(mutatorKind) == 0) { return false; } - const SingleMutationTypeBucket &oneMutationBucket = astUnitMutations.at(mutatorKind); + const SingleMutationTypeBucket &oneMutationBucket = singleFileMutations.at(mutatorKind); LineColumnHash hash = lineColumnHash(line, column); return oneMutationBucket.count(hash) > 0; @@ -80,7 +79,7 @@ void ASTMutationStorage::saveMutation(const std::string &sourceFile, mull::Mutat int hash = mull::lineColumnHash(line, column); if (storage.count(sourceFile) == 0) { - storage.emplace(sourceFile, SingleASTUnitMutations()); + storage.emplace(sourceFile, SingleFileMutations()); } if (storage[sourceFile].count(mutatorKind) == 0) { @@ -91,6 +90,7 @@ void ASTMutationStorage::saveMutation(const std::string &sourceFile, mull::Mutat ASTMutation(mutatorKind, line, column, expression)); } -void ASTMutationStorage::saveMutations(std::unordered_map &mutations) { +void ASTMutationStorage::saveMutations( + std::unordered_map &mutations) { storage.swap(mutations); } diff --git a/lib/AST/ASTVisitor.cpp b/lib/AST/ASTVisitor.cpp index d928bbbfd..57f90c3a3 100644 --- a/lib/AST/ASTVisitor.cpp +++ b/lib/AST/ASTVisitor.cpp @@ -231,10 +231,14 @@ void ASTVisitor::saveMutationPoint(mull::MutatorKind mutatorKind, const clang::S int hash = mull::lineColumnHash(beginLine, beginColumn); - if (singleUnitMutations.count(mutatorKind) == 0) { - singleUnitMutations.emplace(mutatorKind, SingleMutationTypeBucket()); + if (singleUnitMutations.count(sourceFilePath) == 0) { + singleUnitMutations.emplace(sourceFilePath, SingleFileMutations()); + } + SingleFileMutations &singleFileMutations = singleUnitMutations[sourceFilePath]; + if (singleFileMutations.count(mutatorKind) == 0) { + singleFileMutations.emplace(mutatorKind, SingleMutationTypeBucket()); } - singleUnitMutations[mutatorKind].emplace(hash, + singleFileMutations[mutatorKind].emplace(hash, ASTMutation(mutatorKind, beginLine, beginColumn, stmt)); } diff --git a/lib/JunkDetection/CXX/ASTStorage.cpp b/lib/JunkDetection/CXX/ASTStorage.cpp index 6f40781c4..f7e42b2bf 100644 --- a/lib/JunkDetection/CXX/ASTStorage.cpp +++ b/lib/JunkDetection/CXX/ASTStorage.cpp @@ -254,7 +254,7 @@ void ASTStorage::saveMutation(const std::string &sourceFile, mull::MutatorKind m } void ASTStorage::saveMutations( - std::unordered_map &storage) { + std::unordered_map &storage) { mutations.saveMutations(storage); } diff --git a/lib/JunkDetection/CXX/CXXJunkDetector.cpp b/lib/JunkDetection/CXX/CXXJunkDetector.cpp index e7d7a255f..251bcced8 100755 --- a/lib/JunkDetection/CXX/CXXJunkDetector.cpp +++ b/lib/JunkDetection/CXX/CXXJunkDetector.cpp @@ -215,7 +215,7 @@ bool CXXJunkDetector::isJunk(MutationPoint *point) { return true; } - const std::string &sourceFile = point->getSourceLocation().unitFilePath; + const std::string &sourceFile = point->getSourceLocation().filePath; int beginLine = sourceManager.getExpansionLineNumber(location, nullptr); int beginColumn = sourceManager.getExpansionColumnNumber(location); diff --git a/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/compile_commands.json.template b/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/compile_commands.json.template new file mode 100644 index 000000000..60d1e4f33 --- /dev/null +++ b/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/compile_commands.json.template @@ -0,0 +1,16 @@ +[ + { + "arguments": [ + "cc", + "-c", + "-fembed-bitcode", + "-g", + "-O0", + "-o", + "%PWD/sample.cpp.exe", + "%PWD/sample.cpp" + ], + "directory": "/", + "file": "%PWD/sample.cpp" + } +] diff --git a/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sample.cpp b/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sample.cpp new file mode 100644 index 000000000..d3d3895fa --- /dev/null +++ b/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sample.cpp @@ -0,0 +1,33 @@ +#include "sum.h" + +int main() { + return sum(-2, 2); +} + +// clang-format off + +/** +RUN: cd / && %CLANG_EXEC -fembed-bitcode -g %s -o %s.exe +RUN: cd %CURRENT_DIR +RUN: sed -e "s:%PWD:%S:g" %S/compile_commands.json.template > %S/compile_commands.json +RUN: (unset TERM; %MULL_EXEC -linker=%clang_cxx -debug -enable-ast -mutators=cxx_add_to_sub -reporters=IDE -ide-reporter-show-killed -compdb-path %S/compile_commands.json %s.exe 2>&1; test $? = 0) | %FILECHECK_EXEC %s --dump-input=fail --strict-whitespace --match-full-lines +CHECK-NOT:{{^.*[Ee]rror.*$}} +CHECK-NOT:{{^.*[Ww]arning.*$}} + +CHECK:[info] AST Search: looking for mutations in the source files (threads: 1) +CHECK:[debug] AST Search: recording mutation "Add to Sub": {{.*}}sum.h:4:12 + +CHECK:[info] Applying filter: AST mutation filter (threads: 1) +CHECK:[debug] ASTMutationFilter: whitelisting mutation "Add to Sub": {{.*}}sum.h:4:12 + +CHECK:[info] Applying filter: junk (threads: 1) +CHECK:[debug] ASTMutationStorage: recording mutation "Add to Sub": {{.*}}sum.h:4:12 + +CHECK:[info] Killed mutants (1/1): +CHECK:{{^.*}}sum.h:4:12: warning: Killed: Replaced + with - [cxx_add_to_sub]{{$}} +CHECK: return a + b; +CHECK: ^ +CHECK:[info] Mutation score: 100% +CHECK:[info] Total execution time: {{.*}} +CHECK-EMPTY: +**/ diff --git a/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sum.h b/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sum.h new file mode 100644 index 000000000..6ae0aa56c --- /dev/null +++ b/tests-lit/tests/white-ast-search/_special_cases/01_mutation_in_header_file/sum.h @@ -0,0 +1,5 @@ +#pragma once + +static int sum(int a, int b) { + return a + b; +} diff --git a/tests/AST/ASTVisitor/ASTVisitor_ArithmeticAssignment_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_ArithmeticAssignment_Tests.cpp index 8182f7258..357f27d57 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_ArithmeticAssignment_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_ArithmeticAssignment_Tests.cpp @@ -43,10 +43,12 @@ int add_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_AddAssignToSubAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AddAssignToSubAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AddAssignToSubAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_AddAssignToSubAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AddAssignToSubAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AddAssignToSubAssign].count(locationHash), 1U); } TEST(ASTVisitor_ArithmeticAssignment, subAssignToAddAssign) { @@ -77,10 +79,12 @@ int sub_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_SubAssignToAddAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_SubAssignToAddAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_SubAssignToAddAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_SubAssignToAddAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_SubAssignToAddAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_SubAssignToAddAssign].count(locationHash), 1U); } TEST(ASTVisitor_ArithmeticAssignment, mulAssignToDivAssign) { @@ -111,10 +115,12 @@ int mul_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_MulAssignToDivAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_MulAssignToDivAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_MulAssignToDivAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_MulAssignToDivAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_MulAssignToDivAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_MulAssignToDivAssign].count(locationHash), 1U); } TEST(ASTVisitor_ArithmeticAssignment, divAssignToMulAssign) { @@ -145,10 +151,12 @@ int div_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_DivAssignToMulAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_DivAssignToMulAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_DivAssignToMulAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_DivAssignToMulAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_DivAssignToMulAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_DivAssignToMulAssign].count(locationHash), 1U); } TEST(ASTVisitor_ArithmeticAssignment, remAssignToDivAssign) { @@ -179,8 +187,10 @@ int div_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_RemAssignToDivAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RemAssignToDivAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RemAssignToDivAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_RemAssignToDivAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RemAssignToDivAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RemAssignToDivAssign].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_Arithmetic_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_Arithmetic_Tests.cpp index fdc5be382..613d3ab31 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_Arithmetic_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_Arithmetic_Tests.cpp @@ -42,10 +42,12 @@ int add(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_AddToSub), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AddToSub].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AddToSub].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_AddToSub), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AddToSub].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AddToSub].count(locationHash), 1U); } TEST(ASTVisitor_Arithmetic, subToAdd) { @@ -75,10 +77,12 @@ int sub(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_SubToAdd), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_SubToAdd].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_SubToAdd].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_SubToAdd), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_SubToAdd].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_SubToAdd].count(locationHash), 1U); } TEST(ASTVisitor_Arithmetic, mulToDiv) { @@ -108,10 +112,12 @@ int mul(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_MulToDiv), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_MulToDiv].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_MulToDiv].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_MulToDiv), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_MulToDiv].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_MulToDiv].count(locationHash), 1U); } TEST(ASTVisitor_Arithmetic, divToMul) { @@ -141,10 +147,12 @@ int mul(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_DivToMul), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_DivToMul].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_DivToMul].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_DivToMul), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_DivToMul].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_DivToMul].count(locationHash), 1U); } TEST(ASTVisitor_Arithmetic, remToDiv) { @@ -174,8 +182,10 @@ int rem(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_RemToDiv), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RemToDiv].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RemToDiv].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_RemToDiv), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RemToDiv].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RemToDiv].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_BitwiseAssignment_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_BitwiseAssignment_Tests.cpp index a56709744..4ef02e243 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_BitwiseAssignment_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_BitwiseAssignment_Tests.cpp @@ -44,10 +44,12 @@ int bitwise_and_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(4, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Bitwise_AndAssignToOrAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_AndAssignToOrAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_AndAssignToOrAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Bitwise_AndAssignToOrAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_AndAssignToOrAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_AndAssignToOrAssign].count(locationHash), 1U); } TEST(ASTVisitor_BitwiseAssignment, bitwiseOrAssignToAndAssign) { @@ -79,10 +81,12 @@ int bitwise_or_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(4, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Bitwise_OrAssignToAndAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_OrAssignToAndAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_OrAssignToAndAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Bitwise_OrAssignToAndAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_OrAssignToAndAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_OrAssignToAndAssign].count(locationHash), 1U); } TEST(ASTVisitor_BitwiseAssignment, bitwiseXorAssignToOrAssign) { @@ -114,10 +118,12 @@ int bitwise_xor_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(4, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Bitwise_XorAssignToOrAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_XorAssignToOrAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_XorAssignToOrAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Bitwise_XorAssignToOrAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_XorAssignToOrAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_XorAssignToOrAssign].count(locationHash), 1U); } TEST(ASTVisitor_BitwiseAssignment, bitwiseLeftShiftAssignToRightAssign) { @@ -149,10 +155,12 @@ int bitwise_left_shift_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(4, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_LShiftAssignToRShiftAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LShiftAssignToRShiftAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LShiftAssignToRShiftAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_LShiftAssignToRShiftAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LShiftAssignToRShiftAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LShiftAssignToRShiftAssign].count(locationHash), 1U); } TEST(ASTVisitor_BitwiseAssignment, bitwiseRightShiftAssignToLeftShiftAssign) { @@ -184,8 +192,10 @@ int bitwise_right_shift_assign(int a, int b) { LineColumnHash locationHash = lineColumnHash(4, 5); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_RShiftAssignToLShiftAssign), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RShiftAssignToLShiftAssign].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RShiftAssignToLShiftAssign].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_RShiftAssignToLShiftAssign), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RShiftAssignToLShiftAssign].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RShiftAssignToLShiftAssign].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_Bitwise_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_Bitwise_Tests.cpp index ee64a062d..28e71bed6 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_Bitwise_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_Bitwise_Tests.cpp @@ -42,10 +42,12 @@ int bitwise_and(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Bitwise_AndToOr), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_AndToOr].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_AndToOr].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Bitwise_AndToOr), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_AndToOr].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_AndToOr].count(locationHash), 1U); } TEST(ASTVisitor_Bitwise, bitwiseOrToAnd) { @@ -75,10 +77,12 @@ int bitwise_or(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Bitwise_OrToAnd), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_OrToAnd].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_OrToAnd].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Bitwise_OrToAnd), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_OrToAnd].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_OrToAnd].count(locationHash), 1U); } TEST(ASTVisitor_Bitwise, bitwiseXorToOr) { @@ -108,10 +112,12 @@ int bitwise_xor(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Bitwise_XorToOr), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_XorToOr].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Bitwise_XorToOr].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Bitwise_XorToOr), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_XorToOr].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Bitwise_XorToOr].count(locationHash), 1U); } TEST(ASTVisitor_Bitwise, bitwiseLeftShiftToRight) { @@ -141,10 +147,12 @@ int bitwise_left_shift(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_LShiftToRShift), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LShiftToRShift].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LShiftToRShift].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_LShiftToRShift), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LShiftToRShift].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LShiftToRShift].count(locationHash), 1U); } TEST(ASTVisitor_Bitwise, bitwiseRightShiftToLeft) { @@ -174,8 +182,10 @@ int bitwise_right_shift(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_RShiftToLShift), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RShiftToLShift].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RShiftToLShift].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_RShiftToLShift), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RShiftToLShift].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RShiftToLShift].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_Boundary_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_Boundary_Tests.cpp index 31818aa3f..6b8b9a21a 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_Boundary_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_Boundary_Tests.cpp @@ -42,10 +42,12 @@ int greater_than(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_GreaterThanToGreaterOrEqual), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterThanToGreaterOrEqual].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterThanToGreaterOrEqual].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_GreaterThanToGreaterOrEqual), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterThanToGreaterOrEqual].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterThanToGreaterOrEqual].count(locationHash), 1U); } TEST(ASTVisitor_Arithmetic, lessThanToLessThanOrEqual) { @@ -75,10 +77,12 @@ int less_than(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_LessThanToLessOrEqual), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessThanToLessOrEqual].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessThanToLessOrEqual].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_LessThanToLessOrEqual), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessThanToLessOrEqual].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessThanToLessOrEqual].count(locationHash), 1U); } TEST(ASTVisitor_Arithmetic, greaterThanOrEqualToGreaterThan) { @@ -108,10 +112,12 @@ int greater_than_or_equal(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_GreaterOrEqualToGreaterThan), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterOrEqualToGreaterThan].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterOrEqualToGreaterThan].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_GreaterOrEqualToGreaterThan), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterOrEqualToGreaterThan].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterOrEqualToGreaterThan].count(locationHash), 1U); } TEST(ASTVisitor_Arithmetic, lessThanOrEqualToLessThan) { @@ -141,8 +147,10 @@ int less_than_or_equal(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_LessOrEqualToLessThan), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessOrEqualToLessThan].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessOrEqualToLessThan].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_LessOrEqualToLessThan), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessOrEqualToLessThan].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessOrEqualToLessThan].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_Comparison_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_Comparison_Tests.cpp index 0eef61e8c..81eece870 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_Comparison_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_Comparison_Tests.cpp @@ -42,10 +42,12 @@ int eq(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_EqualToNotEqual), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_EqualToNotEqual].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_EqualToNotEqual].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_EqualToNotEqual), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_EqualToNotEqual].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_EqualToNotEqual].count(locationHash), 1U); } TEST(ASTVisitor_Comparison, notEqualToEqual) { @@ -75,10 +77,12 @@ int neq(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_NotEqualToEqual), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_NotEqualToEqual].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_NotEqualToEqual].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_NotEqualToEqual), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_NotEqualToEqual].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_NotEqualToEqual].count(locationHash), 1U); } TEST(ASTVisitor_Comparison, greaterThanToLessThanOrEqual) { @@ -108,10 +112,12 @@ int greater_than(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_GreaterThanToLessOrEqual), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterThanToLessOrEqual].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterThanToLessOrEqual].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_GreaterThanToLessOrEqual), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterThanToLessOrEqual].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterThanToLessOrEqual].count(locationHash), 1U); } TEST(ASTVisitor_Comparison, lessThanToGreaterThanOrEqual) { @@ -141,10 +147,12 @@ int less_than(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_LessThanToGreaterOrEqual), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessThanToGreaterOrEqual].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessThanToGreaterOrEqual].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_LessThanToGreaterOrEqual), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessThanToGreaterOrEqual].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessThanToGreaterOrEqual].count(locationHash), 1U); } TEST(ASTVisitor_Comparison, greaterOrEqualToLessThan) { @@ -174,10 +182,12 @@ int greater_than_or_equal(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_GreaterOrEqualToLessThan), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterOrEqualToLessThan].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_GreaterOrEqualToLessThan].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_GreaterOrEqualToLessThan), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterOrEqualToLessThan].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_GreaterOrEqualToLessThan].count(locationHash), 1U); } TEST(ASTVisitor_Comparison, lessOrEqualToGreaterThan) { @@ -207,8 +217,10 @@ int less_than_or_equal(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_LessOrEqualToGreaterThan), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessOrEqualToGreaterThan].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_LessOrEqualToGreaterThan].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_LessOrEqualToGreaterThan), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessOrEqualToGreaterThan].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_LessOrEqualToGreaterThan].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_Logical_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_Logical_Tests.cpp index 1653b42bf..53048ffad 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_Logical_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_Logical_Tests.cpp @@ -42,10 +42,12 @@ int logical_and(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Logical_AndToOr), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Logical_AndToOr].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Logical_AndToOr].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Logical_AndToOr), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Logical_AndToOr].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Logical_AndToOr].count(locationHash), 1U); } TEST(ASTVisitor_Logical, orToAnd) { @@ -75,8 +77,10 @@ int logical_or(int a, int b) { LineColumnHash locationHash = lineColumnHash(3, 12); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_Logical_OrToAnd), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Logical_OrToAnd].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_Logical_OrToAnd].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_Logical_OrToAnd), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Logical_OrToAnd].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_Logical_OrToAnd].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_RemoveVoid_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_RemoveVoid_Tests.cpp index 664cd0b5a..c6723e13f 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_RemoveVoid_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_RemoveVoid_Tests.cpp @@ -43,8 +43,10 @@ void foo() { LineColumnHash locationHash = lineColumnHash(4, 3); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::RemoveVoidFunctionMutator), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::RemoveVoidFunctionMutator].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::RemoveVoidFunctionMutator].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::RemoveVoidFunctionMutator), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::RemoveVoidFunctionMutator].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::RemoveVoidFunctionMutator].count(locationHash), 1U); } diff --git a/tests/AST/ASTVisitor/ASTVisitor_ReplaceCall_Tests.cpp b/tests/AST/ASTVisitor/ASTVisitor_ReplaceCall_Tests.cpp index 1f038ab60..1f55d5148 100644 --- a/tests/AST/ASTVisitor/ASTVisitor_ReplaceCall_Tests.cpp +++ b/tests/AST/ASTVisitor/ASTVisitor_ReplaceCall_Tests.cpp @@ -45,8 +45,10 @@ int caller(int a) { LineColumnHash locationHash = lineColumnHash(6, 10); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::ReplaceCallMutator), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::ReplaceCallMutator].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::ReplaceCallMutator].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations[fakeSourceFilePath]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::ReplaceCallMutator), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::ReplaceCallMutator].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::ReplaceCallMutator].count(locationHash), 1U); } diff --git a/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_Add_Test.cpp b/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_Add_Test.cpp index 18b47ff04..ab4047c50 100644 --- a/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_Add_Test.cpp +++ b/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_Add_Test.cpp @@ -31,10 +31,12 @@ TEST(Mutation_Arithmetic_AddToSub, End_2_End) { SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_AddToSub), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AddToSub].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AddToSub].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations["/in-memory-file.cc"]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_AddToSub), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AddToSub].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AddToSub].count(locationHash), 1U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); diff --git a/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_UnaryMinusToNoop_Test.cpp b/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_UnaryMinusToNoop_Test.cpp index 06e5b3b49..37e7ee864 100644 --- a/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_UnaryMinusToNoop_Test.cpp +++ b/tests/Mutations-E2E/CXX/Arithmetic/Mutation_Arithmetic_UnaryMinusToNoop_Test.cpp @@ -31,10 +31,12 @@ TEST(Mutation_Arithmetic_UnaryMinusToNoop, End_2_End) { SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_UnaryMinusToNoop), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_UnaryMinusToNoop].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_UnaryMinusToNoop].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations["/in-memory-file.cc"]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_UnaryMinusToNoop), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_UnaryMinusToNoop].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_UnaryMinusToNoop].count(locationHash), 1U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); diff --git a/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_AssignConst.cpp b/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_AssignConst.cpp index 0627c8f85..b8678e81b 100644 --- a/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_AssignConst.cpp +++ b/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_AssignConst.cpp @@ -39,10 +39,12 @@ TEST(Mutation_ConstAssignment_AssignConst, End_2_End) { SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_AssignConst), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AssignConst].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_AssignConst].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations["/in-memory-file.cc"]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_AssignConst), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AssignConst].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_AssignConst].count(locationHash), 1U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); diff --git a/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_InitConst.cpp b/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_InitConst.cpp index a9d4d3c46..e610297cb 100644 --- a/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_InitConst.cpp +++ b/tests/Mutations-E2E/CXX/ConstAssignment/Mutation_ConstAssignment_InitConst.cpp @@ -39,10 +39,12 @@ TEST(Mutation_ConstAssignment_InitConst, End_2_End) { SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_InitConst), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_InitConst].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_InitConst].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations["/in-memory-file.cc"]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_InitConst), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_InitConst].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_InitConst].count(locationHash), 1U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); @@ -77,7 +79,6 @@ int foo() { /// 1. AST Assertions SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 0U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_InitConst), 0U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); @@ -104,7 +105,6 @@ int foo() { /// 1. AST Assertions SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 0U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_InitConst), 0U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); diff --git a/tests/Mutations-E2E/CXX/RemoveNegationTest.cpp b/tests/Mutations-E2E/CXX/RemoveNegationTest.cpp index 2f53cb2cf..823beab97 100644 --- a/tests/Mutations-E2E/CXX/RemoveNegationTest.cpp +++ b/tests/Mutations-E2E/CXX/RemoveNegationTest.cpp @@ -31,10 +31,12 @@ TEST(RemoveNegation, End_2_End) { SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::CXX_RemoveNegation), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RemoveNegation].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::CXX_RemoveNegation].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations["/in-memory-file.cc"]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::CXX_RemoveNegation), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RemoveNegation].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::CXX_RemoveNegation].count(locationHash), 1U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); diff --git a/tests/Mutations-E2E/Scalar/01_Mutation_Scalar_ReturnValue_Test.cpp b/tests/Mutations-E2E/Scalar/01_Mutation_Scalar_ReturnValue_Test.cpp index 28f8d5fd4..694ea6686 100644 --- a/tests/Mutations-E2E/Scalar/01_Mutation_Scalar_ReturnValue_Test.cpp +++ b/tests/Mutations-E2E/Scalar/01_Mutation_Scalar_ReturnValue_Test.cpp @@ -36,10 +36,12 @@ TEST(Mutation_Scalar_Return_Value, End_2_End) { SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::ScalarValueMutator), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::ScalarValueMutator].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::ScalarValueMutator].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations["/in-memory-file.cc"]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::ScalarValueMutator), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::ScalarValueMutator].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::ScalarValueMutator].count(locationHash), 1U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints(); diff --git a/tests/Mutations-E2E/Scalar/02_Mutation_Scalar_BinaryOperand_Test.cpp b/tests/Mutations-E2E/Scalar/02_Mutation_Scalar_BinaryOperand_Test.cpp index 4c70cadaa..ce5630565 100644 --- a/tests/Mutations-E2E/Scalar/02_Mutation_Scalar_BinaryOperand_Test.cpp +++ b/tests/Mutations-E2E/Scalar/02_Mutation_Scalar_BinaryOperand_Test.cpp @@ -36,10 +36,12 @@ TEST(Mutation_Scalar_BinaryOperand, End_2_End) { SingleASTUnitMutations singleUnitMutations = artefact->getASTMutations(); ASSERT_EQ(singleUnitMutations.size(), 1U); - ASSERT_EQ(singleUnitMutations.count(MutatorKind::ScalarValueMutator), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::ScalarValueMutator].size(), 1U); - ASSERT_EQ(singleUnitMutations[MutatorKind::ScalarValueMutator].count(locationHash), 1U); + SingleFileMutations &singleFileMutations = singleUnitMutations["/in-memory-file.cc"]; + ASSERT_EQ(singleFileMutations.count(MutatorKind::ScalarValueMutator), 1U); + + ASSERT_EQ(singleFileMutations[MutatorKind::ScalarValueMutator].size(), 1U); + ASSERT_EQ(singleFileMutations[MutatorKind::ScalarValueMutator].count(locationHash), 1U); /// 2. IR and Junk Detection Assertions std::vector nonJunkMutationPoints = artefact->getNonJunkMutationPoints();