Fixing generations for files that included in two targets

Author: ladisgin

server/src/Paths.cpp

@@ -32,7 +32,7 @@ namespace Paths {
         CollectionUtils::FileSet filtered =
             CollectionUtils::filterOut(paths, [&dirPaths, &filter](const fs::path &path) {
                 return !std::any_of(dirPaths.begin(), dirPaths.end(), [&](const fs::path &dirPath) {
-                    return path.parent_path() == dirPath && fs::exists(path) && filter(path);
+                    return isSubPathOf(dirPath, path) && fs::exists(path) && filter(path);
                 });
             });
         return filtered;

server/src/Server.cpp

@@ -213,10 +213,6 @@ Status Server::TestsGenServiceImpl::ProcessBaseTestRequest(BaseTestGen &testGen,
         Synchronizer synchronizer(&testGen, &stubGen, &sizeContext);
         synchronizer.synchronize(typesHandler);
 
-        if(testGen.settingsContext.useStubs) {
-            testsWriter->writeStubs(testGen.synchronizedStubs);
-        }
-
         std::shared_ptr<LineInfo> lineInfo = nullptr;
         auto lineTestGen = dynamic_cast<LineTestGen *>(&testGen);
 

server/src/Synchronizer.cpp

@@ -118,8 +118,10 @@ void Synchronizer::synchronize(const types::TypesHandler &typesHandler) {
         return;
     }
     auto outdatedSourcePaths = getOutdatedSourcePaths();
-    auto outdatedStubs = getStubSetFromSources(outdatedSourcePaths);
-    synchronizeStubs(outdatedStubs, typesHandler);
+    if (testGen->settingsContext.useStubs) {
+        auto outdatedStubs = getStubSetFromSources(outdatedSourcePaths);
+        synchronizeStubs(outdatedStubs, typesHandler);
+    }
     synchronizeWrappers(outdatedSourcePaths);
 }
 

server/src/building/BaseCommand.cpp

@@ -11,11 +11,11 @@
 #include "tasks/ShellExecTask.h"
 #include "utils/CollectionUtils.h"
 #include "utils/StringUtils.h"
+#include "utils/path/FileSystemPath.h"
 
 #include "loguru.h"
 
 #include <algorithm>
-#include "utils/path/FileSystemPath.h"
 #include <iterator>
 #include <set>
 #include <utility>
@@ -25,6 +25,7 @@ namespace utbot {
         : commandLine(std::move(commandLine)), directory(std::move(directory)) {
         initOptimizationLevel();
     }
+
     BaseCommand::BaseCommand(std::vector<std::string> commandLine, fs::path directory)
         : commandLine(commandLine.begin(), commandLine.end()), directory(std::move(directory)) {
         initOptimizationLevel();

server/src/building/Linker.cpp

@@ -155,16 +155,12 @@ Result<Linker::LinkResult> Linker::linkWholeTarget(const fs::path &target) {
                 insideFolder = false;
             }
         }
-        if (testGen.buildDatabase->isFirstObjectFileForSource(objectFile) &&
-            !CollectionUtils::contains(testedFiles, objectInfo->getSourcePath()) &&
-            insideFolder) {
-            filesToLink.insert(
-                { objectFile, objectInfo->kleeFilesInfo->getKleeBitcodeFile() });
+        if (!CollectionUtils::contains(testedFiles, objectInfo->getSourcePath()) && insideFolder) {
+            filesToLink.emplace(objectFile, objectInfo->kleeFilesInfo->getKleeBitcodeFile());
         } else {
             siblingObjectsToBuild.insert(objectInfo->getOutputFile());
-            fs::path bitcodeFile =
-                testGen.buildDatabase->getBitcodeForSource(objectInfo->getSourcePath());
-            filesToLink.emplace(objectFile, bitcodeFile);
+            filesToLink.emplace(objectFile, testGen.buildDatabase->getBitcodeForSource(
+                                                objectInfo->getSourcePath()));
         }
     }
 
@@ -673,7 +669,7 @@ Linker::getLinkActionsForExecutable(fs::path const &workingDir,
                                     CollectionUtils::MapFileTo<fs::path> const &dependencies,
                                     BuildDatabase::TargetInfo const &linkUnitInfo,
                                     fs::path const &output) {
-    
+
     using namespace DynamicLibraryUtils;
 
     auto commands = CollectionUtils::transform(

server/src/streams/tests/ServerTestsWriter.cpp

@@ -27,26 +27,15 @@ void ServerTestsWriter::writeTestsWithProgress(tests::TestsMap &testMap,
     writeCompleted(testMap, totalTestsCounter);
 }
 
-void ServerTestsWriter::writeStubs(const std::vector<Stubs> &synchronizedStubs) {
-    testsgen::TestsResponse response;
-    auto stubsResponse = std::make_unique<testsgen::StubsResponse>();
-    for (auto const &synchronizedStub : synchronizedStubs) {
-        auto sData = stubsResponse->add_stubsources();
-        sData->set_filepath(synchronizedStub.filePath);
-        if (synchronizeCode) {
-            sData->set_code(synchronizedStub.code);
-        }
-    }
-    response.set_allocated_stubs(stubsResponse.release());
-}
-
 bool ServerTestsWriter::writeFileAndSendResponse(const tests::Tests &tests,
                                                  const fs::path &testDirPath,
                                                  const std::string &message,
                                                  double percent,
                                                  bool isCompleted) const {
     fs::path testFilePath = testDirPath / tests.relativeFileDir / tests.testFilename;
-    FileSystemUtils::writeToFile(testFilePath, tests.code);
+    if (!tests.code.empty()) {
+        FileSystemUtils::writeToFile(testFilePath, tests.code);
+    }
     if (!hasStream()) {
         return false;
     }

server/src/streams/tests/ServerTestsWriter.h

@@ -22,8 +22,6 @@ class ServerTestsWriter : public TestsWriter {
                                 const fs::path &testDirPath,
                                 std::function<void(tests::Tests &)> &&functor) override;
 
-    void writeStubs(const std::vector<Stubs> &synchronizedStubs) override;
-
 private:
     [[nodiscard]] virtual bool writeFileAndSendResponse(const tests::Tests &tests,
                                                         const fs::path &testDirPath,

server/src/streams/tests/TestsWriter.h

@@ -24,10 +24,6 @@ class TestsWriter : public utbot::ServerWriter<testsgen::TestsResponse> {
                                         const fs::path &testDirPath,
                                         std::function<void(tests::Tests &)> &&functor) = 0;
 
-    virtual void writeStubs(const std::vector<Stubs> &synchronizedStubs) {
-        // Default implementation is empty.
-    }
-
 protected:
     void writeCompleted(tests::TestsMap const &testMap, int totalTestsCounter);
 

server/test/framework/Server_Tests.cpp

@@ -1524,10 +1524,10 @@ namespace {
         }
     };
 
-    const std::vector<ProjectInfo> testRelativeDirs = { { fs::path("executable"), 3 },
-                                                        { fs::path("static_library"), 3 },
-                                                        { fs::path("shared_library"), 3 },
-                                                        { fs::path("timeout"), 1 } };
+    const std::vector<ProjectInfo> testRelativeDirs = { { fs::path("executable"), 6 },
+                                                        { fs::path("static_library"), 6 },
+                                                        { fs::path("shared_library"), 6 },
+                                                        { fs::path("timeout"), 2 } };
 
     INSTANTIATE_TEST_SUITE_P(
         DifferentCompilersAndSuites,