Fix generate by class

Author: ladisgin

docker/release_distribution_scripts/utbot_run_system.sh

@@ -50,7 +50,7 @@ IS_SUSE="$(grep '^NAME=' /etc/os-release | tr '[:upper:]' '[:lower:]' | grep sus
 # Setting environment variables for debian packages
 export PATH=$UTBOT_ALL/debs-install/usr/bin:$PATH
 export LD_LIBRARY_PATH=$UTBOT_ALL/install/lib:$UTBOT_ALL/debs-install/lib/x86_64-linux-gnu:$UTBOT_ALL/debs-install/usr/lib/x86_64-linux-gnu:$UTBOT_ALL/debs-install/usr/local/lib:$UTBOT_ALL/debs-install/lib:$UTBOT_ALL/debs-install/usr/lib:$LD_LIBRARY_PATH
-export CPATH=$UTBOT_ALL/debs-install/usr/include/x86_64-linux-gnu/9/include:$UTBOT_ALL/debs-install/usr/include/x86_64-linux-gnu:$UTBOT_ALL/debs-install/usr/include:$CPATH
+export CPATH=$UTBOT_ALL/debs-install/usr/lib/gcc/x86_64-linux-gnu/9/include:$UTBOT_ALL/debs-install/usr/local/include:$UTBOT_ALL/debs-install/usr/include/x86_64-linux-gnu:$UTBOT_ALL/debs-install/usr/include:$CPATH
 export CPLUS_INCLUDE_PATH=$UTBOT_ALL/debs-install/usr/include/c++/9:$UTBOT_ALL/debs-install/usr/include/x86_64-linux-gnu/c++/9:$UTBOT_ALL/debs-install/usr/include/c++/9/backward:$CPLUS_INCLUDE_PATH
 export LDFLAGS="-fuse-ld=gold $LDFLAGS"
 

server/CMakeLists.txt

@@ -157,6 +157,8 @@ target_link_libraries(
         UnitTestBotLib
 )
 
+add_test(UTBot_UnitTests UTBot_UnitTests)
+
 install(TARGETS utbot
         DESTINATION ${CMAKE_INSTALL_PREFIX}
         )

server/src/StmtBordersFinder.cpp server/src/BordersFinder.cppserver/src/StmtBordersFinder.cpp renamed to server/src/BordersFinder.cpp

@@ -2,7 +2,7 @@
  * Copyright (c) Huawei Technologies Co., Ltd. 2012-2021. All rights reserved.
  */
 
-#include "StmtBordersFinder.h"
+#include "BordersFinder.h"
 
 #include "Paths.h"
 #include "clang-utils/ASTPrinter.h"
@@ -17,23 +17,39 @@ using namespace llvm;
 using namespace clang::ast_matchers;
 using namespace clang::tooling;
 
-StmtBordersFinder::StmtBordersFinder(const fs::path &filePath,
-                                     unsigned line,
-                                     const shared_ptr<CompilationDatabase> &compilationDatabase,
-                                     const fs::path &compileCommandsJsonPath)
-: line(line), clangToolRunner(compilationDatabase) {
+BordersFinder::BordersFinder(const fs::path &filePath,
+                             unsigned line,
+                             const shared_ptr<CompilationDatabase> &compilationDatabase,
+                             const fs::path &compileCommandsJsonPath)
+        : line(line), classBorder(std::nullopt), clangToolRunner(compilationDatabase) {
     buildRootPath = Paths::subtractPath(compileCommandsJsonPath.string(), CompilationUtils::MOUNTED_CC_JSON_DIR_NAME);
     lineInfo.filePath = filePath;
 }
 
-void StmtBordersFinder::run(const MatchFinder::MatchResult &Result) {
+void BordersFinder::run(const MatchFinder::MatchResult &Result) {
     LOG_SCOPE_FUNCTION(MAX);
-    if (const auto *FS = Result.Nodes.getNodeAs<FunctionDecl>(Matchers::FUNCTION_DEF)) {
+    if (const auto *ST = Result.Nodes.getNodeAs<clang::CXXRecordDecl>(Matchers::STRUCT_OR_CLASS_JUST_DECL)) {
+        SourceManager &sourceManager = Result.Context->getSourceManager();
+        fs::path path = sourceManager.getFileEntryForID(sourceManager.getMainFileID())
+                ->tryGetRealPathName()
+                .str();
+        auto borders = getBorders(sourceManager, ST->getSourceRange());
+        if (!containsLine(borders) || (classBorder.has_value() && !(borders < classBorder.value()))) {
+            return;
+        }
+        classBorder = borders;
+        lineInfo.begin = borders.start.line;
+        lineInfo.end = borders.end.line;
+        lineInfo.scopeName = ST->getNameAsString();
+        lineInfo.initialized = true;
+        LOG_S(MAX) << "Class name: " << ST->getNameAsString();
+        LOG_S(MAX) << "Class's borders: " << lineInfo.begin << ' ' << lineInfo.end;
+    } else if (const auto *FS = Result.Nodes.getNodeAs<FunctionDecl>(Matchers::FUNCTION_DEF)) {
         SourceManager &sourceManager = Result.Context->getSourceManager();
 
         fs::path path = sourceManager.getFileEntryForID(sourceManager.getMainFileID())
-                            ->tryGetRealPathName()
-                            .str();
+                ->tryGetRealPathName()
+                .str();
         Stmt *currentStmt = FS->getBody();
         if ((currentStmt == nullptr) || !containsLine(getFunctionBordersLines(sourceManager, FS))) {
             return;
@@ -51,24 +67,24 @@ void StmtBordersFinder::run(const MatchFinder::MatchResult &Result) {
                     hasInnerChild = true;
                     if (isa<IfStmt>(currentStmt) || isa<ForStmt>(currentStmt) ||
                         isa<WhileStmt>(currentStmt)) {
-                        if (line == borders.first) {
+                        if (line == borders.start.line) {
                             hasInnerChild = false;
                         } else {
                             lineInfo.wrapInBrackets = true;
                             lineInfo.insertAfter = false;
                         }
                     }
-                    if (line == borders.first && isa<ReturnStmt>(currentStmt)) {
+                    if (line == borders.start.line && isa<ReturnStmt>(currentStmt)) {
                         lineInfo.insertAfter = false;
                     }
                     break;
                 }
             }
         }
-        auto *nodeParent = (CXXRecordDecl *)FS->getParent();
+        auto *nodeParent = (CXXRecordDecl *) FS->getParent();
         auto borders = getStmtBordersLines(sourceManager, currentStmt);
-        lineInfo.begin = borders.first;
-        lineInfo.end = borders.second;
+        lineInfo.begin = borders.start.line;
+        lineInfo.end = borders.end.line;
         lineInfo.scopeName = nodeParent != nullptr ? nodeParent->getNameAsString() : path.stem().string();
         lineInfo.methodName = FS->getNameAsString();
         const clang::QualType realReturnType = FS->getReturnType().getCanonicalType();
@@ -84,8 +100,8 @@ void StmtBordersFinder::run(const MatchFinder::MatchResult &Result) {
                 break;
             }
             auto tempBorders = getStmtBordersLinesDynamic(sourceManager, parents[0]);
-            int from = tempBorders.first;
-            int to = tempBorders.second;
+            int from = tempBorders.start.line;
+            int to = tempBorders.end.line;
             if (to - from > 1) {
                 break;
             }
@@ -94,45 +110,52 @@ void StmtBordersFinder::run(const MatchFinder::MatchResult &Result) {
         }
         lineInfo.stmtString = strRepresentation;
         LOG_S(MAX) << "Method name: " << lineInfo.methodName << "\n"
-                   << "Method's borders: " << borders.first << ' ' << borders.second;
+                   << "Method's borders: " << borders.start.line << ' ' << borders.end.line;
         LOG_S(DEBUG) << "Statement string: " << lineInfo.stmtString;
     }
 }
 
-LineInfo StmtBordersFinder::getLineInfo() {
+LineInfo BordersFinder::getLineInfo() {
     return lineInfo;
 }
 
-std::pair<unsigned, unsigned> StmtBordersFinder::getFunctionBordersLines(const SourceManager &srcMng, const FunctionDecl *FS) {
+BordersFinder::Borders BordersFinder::getFunctionBordersLines(const SourceManager &srcMng, const FunctionDecl *FS) {
     auto currentStmt = FS->getBody();
-    auto bodyBorders = getStmtBordersLines(srcMng, currentStmt);
-    auto declBorders = getStmtBordersLines(srcMng, FS->getSourceRange());
-    return {declBorders.first, bodyBorders.second};
+    return getStmtBordersLines(srcMng, currentStmt);
 }
 
-std::pair<unsigned, unsigned> StmtBordersFinder::getStmtBordersLines(const SourceManager &srcMng, const Stmt *st) {
+BordersFinder::Borders BordersFinder::getStmtBordersLines(const SourceManager &srcMng, const Stmt *st) {
     return getStmtBordersLinesDynamic(srcMng, clang::ast_type_traits::DynTypedNode::create(*st));
 }
 
-std::pair<unsigned, unsigned> StmtBordersFinder::getStmtBordersLinesDynamic(const SourceManager &srcMng,
-                                                                            const clang::ast_type_traits::DynTypedNode st) {
+BordersFinder::Borders BordersFinder::getStmtBordersLinesDynamic(const SourceManager &srcMng,
+                                                                 const clang::ast_type_traits::DynTypedNode st) {
     auto sourceRange = st.getSourceRange();
-    return getStmtBordersLines(srcMng, sourceRange);
+    return getBorders(srcMng, sourceRange);
 }
 
-std::pair<unsigned int, unsigned int>
-StmtBordersFinder::getStmtBordersLines(const SourceManager &srcMng, const SourceRange &sourceRange) {
+BordersFinder::Borders BordersFinder::getBorders(const SourceManager &srcMng, const SourceRange &sourceRange) {
     auto beginLine = srcMng.getExpansionLineNumber(sourceRange.getBegin());
     auto endLine = srcMng.getExpansionLineNumber(sourceRange.getEnd());
-    return { beginLine, endLine };
+    auto beginColumn = srcMng.getExpansionColumnNumber(sourceRange.getBegin());
+    auto endColumn = srcMng.getExpansionColumnNumber(sourceRange.getEnd());
+    return {{beginLine, beginColumn},
+            {endLine,   endColumn}};
 }
 
-bool StmtBordersFinder::containsLine(std::pair<unsigned, unsigned> b) const {
-    return line >= b.first && line <= b.second;
+bool BordersFinder::containsLine(BordersFinder::Borders b) const {
+    return line >= b.start.line && line <= b.end.line;
 }
 
-void StmtBordersFinder::launch() {
+void BordersFinder::findFunction() {
     MatchFinder finder;
     finder.addMatcher(Matchers::functionDefinitionMatcher, this);
     clangToolRunner.run(lineInfo.filePath, newFrontendActionFactory(&finder).get());
 }
+
+void BordersFinder::findClass() {
+    MatchFinder finder;
+    finder.addMatcher(Matchers::classJustDeclMatcher, this);
+    finder.addMatcher(Matchers::structJustDeclMatcher, this);
+    clangToolRunner.run(lineInfo.filePath, newFrontendActionFactory(&finder).get(), false, std::nullopt, false);
+}

server/src/BordersFinder.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2012-2021. All rights reserved.
+ */
+
+#ifndef UNITTESTBOT_BORDERSFINDER_H
+#define UNITTESTBOT_BORDERSFINDER_H
+
+#include "fetchers/FetcherUtils.h"
+#include "LineInfo.h"
+
+#include <clang/ASTMatchers/ASTMatchFinder.h>
+#include <clang/ASTMatchers/ASTMatchers.h>
+#include <clang/Rewrite/Core/Rewriter.h>
+#include <clang/Rewrite/Frontend/Rewriters.h>
+#include <clang/Tooling/CommonOptionsParser.h>
+#include <clang/Tooling/Tooling.h>
+
+#include "utils/path/FileSystemPath.h"
+#include <string>
+#include <utility>
+
+using std::string;
+using std::unique_ptr;
+using std::shared_ptr;
+
+class BordersFinder : public clang::ast_matchers::MatchFinder::MatchCallback {
+public:
+    BordersFinder(const fs::path &filePath,
+                  unsigned line,
+                  const shared_ptr<clang::tooling::CompilationDatabase> &compilationDatabase,
+                  const fs::path &compileCommandsJsonPath);
+
+    void run(const clang::ast_matchers::MatchFinder::MatchResult &Result) override;
+
+    void findFunction();
+
+    void findClass();
+
+    LineInfo getLineInfo();
+
+private:
+    unsigned line;
+    LineInfo lineInfo{};
+    fs::path buildRootPath;
+    struct Borders {
+        struct Position {
+            unsigned line;
+            unsigned column;
+        };
+        Position start;
+        Position end;
+
+        friend bool operator<(const Borders& lhs, const Borders& rhs) {
+            return (rhs.start.line < lhs.start.line ||
+                   (rhs.start.line == lhs.start.line && rhs.start.column <= lhs.start.column)) &&
+                   (rhs.end.line > lhs.start.line ||
+                   (rhs.end.line == lhs.start.line && rhs.end.column >= lhs.start.column));
+        }
+    };
+    std::optional<Borders> classBorder;
+    ClangToolRunner clangToolRunner;
+
+    // TODO: use rewriter for insertion
+    clang::Rewriter rewrt;
+
+    Borders getStmtBordersLines(const clang::SourceManager &srcMng, const clang::Stmt *st);
+
+    Borders getStmtBordersLinesDynamic(const clang::SourceManager &srcMng, clang::ast_type_traits::DynTypedNode st);
+
+    [[nodiscard]] bool containsLine(Borders b) const;
+
+    static Borders getBorders(const clang::SourceManager &srcMng, const clang::SourceRange &sourceRange);
+
+    Borders getFunctionBordersLines(const clang::SourceManager &srcMng, const clang::FunctionDecl *FS);
+};
+
+
+#endif //UNITTESTBOT_BORDERSFINDER_H

server/src/KleeGenerator.h

@@ -9,7 +9,7 @@
 #include "ProjectContext.h"
 #include "Result.h"
 #include "SettingsContext.h"
-#include "StmtBordersFinder.h"
+#include "BordersFinder.h"
 #include "Tests.h"
 #include "building/BuildDatabase.h"
 #include "exceptions/CompilationDatabaseException.h"

server/src/Paths.cpp

@@ -319,6 +319,20 @@ namespace Paths {
         return makefileDir / makefileName;
     }
 
+    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) {
+                fs::path sourceFilePath = replaceExtension(source, extension);
+                if (fs::exists(sourceFilePath)) {
+                    return {sourceFilePath};
+                }
+            }
+        }
+        return std::nullopt;
+    }
+
+
     fs::path getRelativeDirPath(const utbot::ProjectContext &projectContext,
                                 const fs::path &source) {
         return fs::relative(source.parent_path(), projectContext.projectPath);

server/src/Paths.h

@@ -221,13 +221,13 @@ namespace Paths {
 
     static inline bool isCXXFile(const fs::path &path) {
         return path.extension() == ".cc" || path.extension() == ".cp" ||
-               path.extension() == ".cpp" || path.extension() == "c++" ||
+               path.extension() == ".cpp" || path.extension() == ".c++" ||
                path.extension() == ".cxx";
     }
 
     static inline bool isHppFile(const fs::path &path) {
         return path.extension() == ".hh" || path.extension() == ".hpp" ||
-               path.extension() == "hxx";
+               path.extension() == ".hxx";
     }
 
     static inline bool isHeaderFile(const fs::path &path) {
@@ -354,6 +354,8 @@ namespace Paths {
     fs::path getMakefilePathFromSourceFilePath(const utbot::ProjectContext &projectContext, const fs::path &sourceFilePath);
 
     fs::path getStubsMakefilePath(const utbot::ProjectContext &projectContext, const fs::path &sourceFilePath);
+
+    std::optional<fs::path> headerPathToSourcePath(const fs::path &source);
     //endregion
 
     //region stubs

server/src/Server.cpp

@@ -218,28 +218,39 @@ Status Server::TestsGenServiceImpl::ProcessBaseTestRequest(BaseTestGen &testGen,
         auto lineTestGen = dynamic_cast<LineTestGen *>(&testGen);
 
         if (lineTestGen != nullptr) {
-            lineInfo = getLineInfo(*lineTestGen);
-            CollectionUtils::erase_if(testGen.tests.at(lineInfo->filePath).methods,
-                                      [&lineInfo](const auto &methodDescription) {
-                                          return methodDescription.name != lineInfo->methodName;
-                                      });
+            if (isSameType<ClassTestGen>(testGen) && Paths::isHeaderFile(lineTestGen->filePath)) {
+                BordersFinder classFinder(lineTestGen->filePath, lineTestGen->line,
+                                          lineTestGen->compilationDatabase,
+                                          lineTestGen->compileCommandsJsonPath);
+                classFinder.findClass();
+                lineInfo = std::make_shared<LineInfo>(classFinder.getLineInfo());
+                lineInfo->filePath = lineTestGen->testingMethodsSourcePaths[0];
+                CollectionUtils::erase_if(testGen.tests.at(lineInfo->filePath).methods,
+                                          [&lineInfo](const auto &methodDescription) {
+                                              return methodDescription.className != lineInfo->scopeName;
+                                          });
+            } else {
+                lineInfo = getLineInfo(*lineTestGen);
+                CollectionUtils::erase_if(testGen.tests.at(lineInfo->filePath).methods,
+                                          [&lineInfo](const auto &methodDescription) {
+                                              return methodDescription.name != lineInfo->methodName;
+                                          });
+            }
         }
 
         FeaturesFilter::filter(testGen.settingsContext, typesHandler, testGen.tests);
         StubsCollector(typesHandler).collect(testGen.tests);
 
         PathSubstitution pathSubstitution = {};
         if (lineTestGen != nullptr) {
-            lineInfo = getLineInfo(*lineTestGen);
             lineInfo->forMethod = isSameType<FunctionTestGen>(testGen);
             lineInfo->forClass = isSameType<ClassTestGen>(testGen);
             lineInfo->forAssert = isSameType<AssertionTestGen>(testGen);
             if (lineTestGen->needToAddPathFlag()) {
                 LOG_S(DEBUG) << "Added test line flag for file " << lineInfo->filePath;
                 fs::path flagFilePath =
                     printer::KleePrinter(&typesHandler, nullptr, Paths::getSourceLanguage(lineInfo->filePath))
-                        .addTestLineFlag(lineInfo, isSameType<AssertionTestGen>(testGen),
-                                         testGen.projectContext);
+                        .addTestLineFlag(lineInfo, lineInfo->forAssert, testGen.projectContext);
                 pathSubstitution = { testGen.testingMethodsSourcePaths[0], flagFilePath };
             }
         }
@@ -290,10 +301,10 @@ Status Server::TestsGenServiceImpl::ProcessBaseTestRequest(BaseTestGen &testGen,
 }
 
 shared_ptr<LineInfo> Server::TestsGenServiceImpl::getLineInfo(LineTestGen &lineTestGen) {
-    StmtBordersFinder stmtFinder(lineTestGen.testingMethodsSourcePaths[0], lineTestGen.line,
-                                 lineTestGen.compilationDatabase,
-                                 lineTestGen.compileCommandsJsonPath);
-    stmtFinder.launch();
+    BordersFinder stmtFinder(lineTestGen.testingMethodsSourcePaths[0], lineTestGen.line,
+                             lineTestGen.compilationDatabase,
+                             lineTestGen.compileCommandsJsonPath);
+    stmtFinder.findFunction();
     if (!stmtFinder.getLineInfo().initialized) {
         throw NoTestGeneratedException(
             "Maybe you tried to generate tests placing cursor on invalid line.");

server/src/Server.h

@@ -6,7 +6,7 @@
 #define UNITTESTBOT_SERVER_H
 
 #include "KleeGenerator.h"
-#include "StmtBordersFinder.h"
+#include "BordersFinder.h"
 #include "ThreadSafeContainers.h"
 #include "TimeExecStatistics.h"
 #include "exceptions/CancellationException.h"