fix: detect source paths from compile_commands.json by default

Samat · antipeon · commit ef3ce993aa11 · 2022-01-31T15:16:35.000+03:00
diff --git a/server/src/Paths.cpp b/server/src/Paths.cpp
@@ -24,14 +24,14 @@ namespace Paths {
 
     vector<fs::path> filterPathsByDirNames(const vector<fs::path> &paths,
                                            const vector<fs::path> &dirPaths,
-                                           const vector<string> &allowedExt) {
+                                           const std::function<bool(const fs::path &path)> &filter) {
         std::vector<fs::path> filtered;
         std::copy_if(paths.begin(), paths.end(), std::back_inserter(filtered),
-                     [&dirPaths, &allowedExt](const fs::path &path) {
+                     [&dirPaths, &filter](const fs::path &path) {
                          return std::any_of(
                              dirPaths.begin(), dirPaths.end(), [&](const auto &dirPath) {
                                  return path.parent_path() == dirPath && fs::exists(path) &&
-                                        CollectionUtils::contains(allowedExt, path.extension());
+                                        filter(path);
                              });
                      });
         return filtered;
@@ -320,9 +320,8 @@ namespace Paths {
     }
 
     std::optional<fs::path> headerPathToSourcePath(const fs::path &source) {
-        std::vector<std::string> sourceExtensions({".cc", ".cp", ".cpp", ".c++", ".cxx"});
         if (Paths::isHeaderFile(source)) {
-            for (const std::string &extension : sourceExtensions) {
+            for (const std::string &extension : CXXFileExtensions) {
                 fs::path sourceFilePath = replaceExtension(source, extension);
                 if (fs::exists(sourceFilePath)) {
                     return {sourceFilePath};
@@ -355,4 +354,9 @@ namespace Paths {
 
     //endregion
 
+    const std::vector<std::string> CXXFileExtensions({".cc", ".cp", ".cpp", ".c++", ".cxx"});
+    const std::vector<std::string> HPPFileExtensions({".hh", ".hpp", ".hxx"});
+    const std::vector<std::string> CFileSourceExtensions({".c"});
+    const std::vector<std::string> CFileHeaderExtensions({".h"});
+
 }
diff --git a/server/src/Paths.h b/server/src/Paths.h
@@ -39,7 +39,7 @@ namespace Paths {
      */
     vector<fs::path> filterPathsByDirNames(const vector<fs::path> &path,
                                            const vector<fs::path> &dirNames,
-                                           const vector<string> &allowedExt);
+                                           const std::function<bool(const fs::path &path)> &filter);
 
     static inline void setOptPath(fs::path &path, const string &value) {
         path = fs::path(value);
@@ -211,23 +211,24 @@ namespace Paths {
     //endregion
 
     //region extensions
+    extern const std::vector<std::string> CFileHeaderExtensions;
     static inline bool isHFile(const fs::path &path) {
-        return path.extension() == ".h";
+        return CollectionUtils::contains(CFileHeaderExtensions, path.extension());
     }
 
+    extern const std::vector<std::string> CFileSourceExtensions;
     static inline bool isCFile(const fs::path &path) {
-        return path.extension() == ".c";
+        return CollectionUtils::contains(CFileSourceExtensions, path.extension());
     }
 
+    extern const std::vector<std::string> CXXFileExtensions;
     static inline bool isCXXFile(const fs::path &path) {
-        return path.extension() == ".cc" || path.extension() == ".cp" ||
-               path.extension() == ".cpp" || path.extension() == ".c++" ||
-               path.extension() == ".cxx";
+        return CollectionUtils::contains(CXXFileExtensions, path.extension());
     }
 
+    extern const std::vector<std::string> HPPFileExtensions;
     static inline bool isHppFile(const fs::path &path) {
-        return path.extension() == ".hh" || path.extension() == ".hpp" ||
-               path.extension() == ".hxx";
+        return CollectionUtils::contains(HPPFileExtensions, path.extension());
     }
 
     static inline bool isHeaderFile(const fs::path &path) {
diff --git a/server/src/building/Linker.cpp b/server/src/building/Linker.cpp
@@ -64,7 +64,6 @@ Result<Linker::LinkResult> Linker::linkForTarget(const fs::path &target, const f
     testGen.setTargetPath(target);
 
     auto siblings = testGen.buildDatabase->getArchiveObjectFiles(target);
-    checkSiblingsExist(siblings);
     auto stubSources = stubGen.getStubSources(target);
 
     CollectionUtils::MapFileTo<fs::path> filesToLink;
@@ -143,7 +142,6 @@ Result<Linker::LinkResult> Linker::linkWholeTarget(const fs::path &target) {
     auto targetUnitInfo = testGen.buildDatabase->getClientLinkUnitInfo(target);
     auto siblings = testGen.buildDatabase->getArchiveObjectFiles(target);
 
-    checkSiblingsExist(siblings);
     auto stubSources = stubGen.getStubSources(target);
 
     CollectionUtils::MapFileTo<fs::path> filesToLink;
@@ -242,20 +240,6 @@ void Linker::addToGenerated(const CollectionUtils::FileSet &objectFiles, const f
     }
 }
 
-void Linker::checkSiblingsExist(const CollectionUtils::FileSet &archivedFiles) const {
-    for (const auto &objectFile : archivedFiles) {
-        auto objectInfo = testGen.buildDatabase->getClientCompilationUnitInfo(objectFile);
-        const fs::path &sourcePath = objectInfo->getSourcePath();
-        if (!CollectionUtils::contains(testGen.sourcePaths, sourcePath)) {
-            throw CompilationDatabaseException(
-                "Source file is not registered: " + sourcePath.string() +
-                "\nPlease check if directory is in source directories in UTBot extension "
-                "settings: " +
-                sourcePath.parent_path().string());
-        }
-    }
-}
-
 void Linker::prepareArtifacts() {
     if (isForOneFile()) {
         fs::path sourceFilePath = getSourceFilePath();
diff --git a/server/src/testgens/FileTestGen.cpp b/server/src/testgens/FileTestGen.cpp
@@ -9,7 +9,7 @@
 FileTestGen::FileTestGen(const testsgen::FileRequest &request,
                          ProgressWriter *progressWriter,
                          bool testMode)
-    : ProjectTestGen(request.projectrequest(), progressWriter, testMode),
+    : ProjectTestGen(request.projectrequest(), progressWriter, testMode, false),
       filepath(request.filepath()) {
     testingMethodsSourcePaths = { filepath  };
     setInitializedTestsMap();
diff --git a/server/src/testgens/FolderTestGen.cpp b/server/src/testgens/FolderTestGen.cpp
@@ -9,7 +9,7 @@
 FolderTestGen::FolderTestGen(const testsgen::FolderRequest &request,
                              ProgressWriter *progressWriter,
                              bool testMode)
-    : ProjectTestGen(request.projectrequest(), progressWriter, testMode),
+    : ProjectTestGen(request.projectrequest(), progressWriter, testMode, false),
       folderPath(request.folderpath()) {
     testingMethodsSourcePaths = {};
     std::copy_if(sourcePaths.begin(), sourcePaths.end(),
diff --git a/server/src/testgens/LineTestGen.cpp b/server/src/testgens/LineTestGen.cpp
@@ -7,10 +7,10 @@
 LineTestGen::LineTestGen(const testsgen::LineRequest &request,
                          ProgressWriter *progressWriter,
                          bool testMode, bool forHeader)
-        : ProjectTestGen(request.projectrequest(), progressWriter, testMode) {
+        : ProjectTestGen(request.projectrequest(), progressWriter, testMode, false) {
     filePath = request.sourceinfo().filepath();
     line = request.sourceinfo().line();
-    std::optional sourcePath = Paths::headerPathToSourcePath(filePath);
+    std::optional<fs::path> sourcePath = Paths::headerPathToSourcePath(filePath);
     if (forHeader && sourcePath.has_value()) {
         testingMethodsSourcePaths = {sourcePath.value()};
     } else {
diff --git a/server/src/testgens/ProjectTestGen.cpp b/server/src/testgens/ProjectTestGen.cpp
@@ -11,7 +11,8 @@
 
 ProjectTestGen::ProjectTestGen(const testsgen::ProjectRequest &request,
                                ProgressWriter *progressWriter,
-                               bool testMode)
+                               bool testMode,
+                               bool autoDetect)
     : BaseTestGen(request.projectcontext(),
                   request.settingscontext(),
                   progressWriter,
@@ -22,20 +23,12 @@ ProjectTestGen::ProjectTestGen(const testsgen::ProjectRequest &request,
     buildDatabase =
         std::make_shared<BuildDatabase>(compileCommandsJsonPath, serverBuildDir, projectContext);
     compilationDatabase = CompilationUtils::getCompilationDatabase(compileCommandsJsonPath);
-    vector<fs::path> sourcePathsCandidates;
-    for (const auto &compileCommand : compilationDatabase->getAllCompileCommands()) {
-        try {
-            fs::path path = Paths::getCCJsonFileFullPath(compileCommand.Filename, compileCommand.Directory);
-            sourcePathsCandidates.push_back(path);
-        } catch (...) {
-            throw CompilationDatabaseException("Cannot detect file: " + compileCommand.Filename +
-                                               ". Maybe you need to rebuild the project.");
-        }
+    if (autoDetect) {
+        autoDetectSourcePathsIfNotEmpty();
+    } else {
+        vector<fs::path> sourcePathsCandidates = getSourcePathCandidates();
+        sourcePaths = sourcePathsCandidates;
     }
-    auto requestSourcePaths = CollectionUtils::transformTo<vector<fs::path>>(
-        request.sourcepaths(), [](std::string const &sourcePath) { return fs::path(sourcePath); });
-    sourcePaths =
-        Paths::filterPathsByDirNames(sourcePathsCandidates, requestSourcePaths, { ".c", ".cpp", ".cc" });
     testingMethodsSourcePaths = sourcePaths;
     setInitializedTestsMap();
 }
@@ -55,3 +48,36 @@ void ProjectTestGen::setTargetForSource(const fs::path &sourcePath) {
 const testsgen::ProjectRequest *ProjectTestGen::getRequest() const {
     return request;
 }
+
+vector<fs::path> ProjectTestGen::getRequestSourcePaths() const {
+    return CollectionUtils::transformTo<vector<fs::path>>(
+            request->sourcepaths(), [](std::string const &sourcePath) { return fs::path(sourcePath); });
+}
+
+vector<fs::path> ProjectTestGen::getSourcePathCandidates() const {
+    vector<fs::path> sourcePathsCandidates;
+    for (const auto &compileCommand : compilationDatabase->getAllCompileCommands()) {
+        try {
+            fs::path path = Paths::getCCJsonFileFullPath(compileCommand.Filename, compileCommand.Directory);
+            sourcePathsCandidates.push_back(path);
+        } catch (...) {
+            throw CompilationDatabaseException("Cannot detect file: " + compileCommand.Filename +
+            ". Maybe you need to rebuild the project.");
+        }
+    }
+    return sourcePathsCandidates;
+}
+void ProjectTestGen::autoDetectSourcePathsIfNotEmpty() {
+    // requestSourcePaths are from settings.json
+    auto requestSourcePaths = getRequestSourcePaths();
+    // sourcePathsCandidates are from compile_commands.json
+    auto sourcePathsCandidates = getSourcePathCandidates();
+    if (!requestSourcePaths.empty()) {
+        sourcePaths =
+                Paths::filterPathsByDirNames(sourcePathsCandidates, requestSourcePaths, Paths::isSourceFile);
+    } else {
+        sourcePaths = sourcePathsCandidates;
+    }
+}
+
+
diff --git a/server/src/testgens/ProjectTestGen.h b/server/src/testgens/ProjectTestGen.h
@@ -14,7 +14,8 @@ class ProjectTestGen : public BaseTestGen {
 public:
     ProjectTestGen(const testsgen::ProjectRequest &request,
                    ProgressWriter *progressWriter,
-                   bool testMode);
+                   bool testMode,
+                   bool autoDetect = true);
 
     ~ProjectTestGen() override = default;
 
@@ -26,6 +27,12 @@ class ProjectTestGen : public BaseTestGen {
 
 private:
     testsgen::ProjectRequest const *const request;
+
+    vector<fs::path> getSourcePathCandidates() const;
+
+    vector<fs::path> getRequestSourcePaths() const;
+
+    void autoDetectSourcePathsIfNotEmpty();
 };
 
 
diff --git a/server/test/framework/Server_Tests.cpp b/server/test/framework/Server_Tests.cpp
@@ -924,6 +924,54 @@ namespace {
         }
     }
 
+    TEST_P(Parameterized_Server_Test, Project_Test_Auto_Detect_Src_Paths) {
+        std::string suite = "small-project";
+        setSuite(suite);
+        srcPaths = {};
+        auto request = createProjectRequest(projectName, suitePath, buildDirRelativePath, srcPaths);
+        auto testGen = ProjectTestGen(*request, writer.get(), TESTMODE);
+        testGen.setTargetForSource(testGen.testingMethodsSourcePaths[0]);
+
+        Status status = Server::TestsGenServiceImpl::ProcessBaseTestRequest(testGen, writer.get());
+        ASSERT_TRUE(status.ok()) << status.error_message();
+
+        auto testFilePaths = CollectionUtils::getKeys(testGen.tests);
+        EXPECT_TRUE(!testFilePaths.empty()) << "Generated test files are missing.";
+
+        EXPECT_FALSE(testFilePaths.size() < 2) << "Not enough test files are generated";
+        EXPECT_FALSE(testFilePaths.size() > 2) << "More than needed test files are generated";
+
+        for (const auto &test : testGen.tests) {
+            for (const auto &[methodName, methodDescription] : test.second.methods) {
+                testUtils::checkMinNumberOfTests(methodDescription.testCases, 2);
+            }
+        }
+    }
+
+    TEST_P(Parameterized_Server_Test, Project_Test_Detect_Src_Paths_From_Request) {
+        std::string suite = "small-project";
+        setSuite(suite);
+        srcPaths = { suitePath / "lib"};
+        auto request = createProjectRequest(projectName, suitePath, buildDirRelativePath, srcPaths);
+        auto testGen = ProjectTestGen(*request, writer.get(), TESTMODE);
+        testGen.setTargetForSource(testGen.testingMethodsSourcePaths[0]);
+
+        Status status = Server::TestsGenServiceImpl::ProcessBaseTestRequest(testGen, writer.get());
+        ASSERT_TRUE(status.ok()) << status.error_message();
+
+        auto testFilePaths = CollectionUtils::getKeys(testGen.tests);
+        EXPECT_TRUE(!testFilePaths.empty()) << "Generated test files are missing.";
+
+        EXPECT_FALSE(testFilePaths.size() < 1) << "Not enough test files are generated";
+        EXPECT_FALSE(testFilePaths.size() > 1) << "More than needed test files are generated";
+
+        for (const auto &test : testGen.tests) {
+            for (const auto &[methodName, methodDescription] : test.second.methods) {
+                testUtils::checkMinNumberOfTests(methodDescription.testCases, 2);
+            }
+        }
+    }
+
     TEST_P(Parameterized_Server_Test, File_Test) {
         auto projectRequest =
             createProjectRequest(projectName, suitePath, buildDirRelativePath, srcPaths);
diff --git a/server/test/framework/Utils_Tests.cpp b/server/test/framework/Utils_Tests.cpp
@@ -72,7 +72,7 @@ namespace {
                                      projectPath / "zzz/snippet.c"
                              };
         vector<fs::path> dirNames{ projectPath };
-        auto filteredPaths = Paths::filterPathsByDirNames(paths, dirNames, { ".c" });
+        auto filteredPaths = Paths::filterPathsByDirNames(paths, dirNames, Paths::isCFile);
         EXPECT_EQ(vector<fs::path>({
                                            projectPath / "basic_functions.c",
                                            projectPath / "types.c"}),
