External variables support (closes #514) (#522)

Add support for external variables

Author: Lana243

server/src/Tests.cpp

@@ -1163,4 +1163,9 @@ bool isUnnamed(char *name) {
 bool Tests::MethodTestCase::isError() const {
     return suiteName == ERROR_SUITE_NAME;
 }
+
+bool Tests::TypeAndVarName::operator<(const Tests::TypeAndVarName &other) const {
+    return varName < other.varName || (varName == other.varName && type.mTypeName() < other.type.mTypeName());
+}
+
 }

server/src/Tests.h

@@ -336,6 +336,8 @@ namespace tests {
             TypeAndVarName(types::Type type, std::string varName)
                 : type(std::move(type)), varName(std::move(varName)) {
             }
+
+            bool operator<(const TypeAndVarName &) const;
         };
 
         struct MethodParam {
@@ -558,6 +560,7 @@ namespace tests {
         fs::path testHeaderFilePath;
         fs::path testSourceFilePath;
 
+        std::set<TypeAndVarName> externVariables;
         std::vector<Include> srcFileHeaders;
         std::vector<Include> headersBeforeMainHeader;
         std::optional<Include> mainHeader;

server/src/coverage/TestRunner.cpp

@@ -1,3 +1,4 @@
+#include <utils/stats/TestsExecutionStats.h>
 #include "TestRunner.h"
 
 #include "printers/DefaultMakefilePrinter.h"

server/src/fetchers/GlobalVariableUsageMatchCallback.cpp

@@ -20,7 +20,7 @@ void GlobalVariableUsageMatchCallback::checkUsage(const MatchFinder::MatchResult
             Result.Nodes.getNodeAs<clang::VarDecl>(Matchers::GLOBAL_VARIABLE_USAGE)) {
         clang::QualType varType = pVarDecl->getType();
         std::string name = pVarDecl->getNameAsString();
-        if (!pVarDecl->isKnownToBeDefined()) {
+        if (!pVarDecl->isKnownToBeDefined() && !pVarDecl->isExternC()) {
             LOG_S(DEBUG) << "Variable \"" << name << "\" was skipped - it has no definition.";
             return;
         }
@@ -62,12 +62,15 @@ void GlobalVariableUsageMatchCallback::handleUsage(const clang::FunctionDecl *fu
         return;
     }
 
-    auto &methods = (*parent->projectTests).at(sourceFilePath).methods;
-    auto &method = methods[usage.functionName];
+    auto &tests = (*parent->projectTests).at(sourceFilePath);
+    auto &method = tests.methods[usage.functionName];
     const clang::QualType realParamType = varDecl->getType().getCanonicalType();
     const std::string usedParamTypeString = varDecl->getType().getAsString();
     types::Type paramType = types::Type(realParamType, usedParamTypeString, sourceManager);
     method.globalParams.emplace_back(paramType, usage.variableName, AlignmentFetcher::fetch(varDecl));
+    if (varDecl->isExternC() && !varDecl->isKnownToBeDefined()) {
+        tests.externVariables.insert({paramType, usage.variableName});
+    }
 }
 
 GlobalVariableUsageMatchCallback::Usage::Usage(std::string variableName, std::string functionName)

server/src/printers/KleePrinter.cpp

@@ -113,7 +113,7 @@ fs::path KleePrinter::writeTmpKleeFile(
     LOG_S(DEBUG) << "Writing tmpKleeFile for " << testedMethod << " inside " << tests.sourceFilePath;
 
     bool hasMethod = false;
-    for (const auto &[methodName,testMethod ]: tests.methods) {
+    for (const auto &[methodName, testMethod]: tests.methods) {
         if (methodFilter(testMethod)) {
             hasMethod = true;
         }
@@ -143,6 +143,9 @@ fs::path KleePrinter::writeTmpKleeFile(
 
     writeAccessPrivateMacros(typesHandler, tests, false);
 
+    strDeclareSetOfVars(tests.externVariables);
+    ss << NL;
+
     for (const auto &[methodName, testMethod] : tests.methods) {
         if (!methodFilter(testMethod)) {
             continue;

server/src/printers/Printer.cpp

@@ -674,4 +674,15 @@ namespace printer {
     void Printer::writeCopyrightHeader() {
         ss << Copyright::GENERATED_C_CPP_FILE_HEADER << NL;
     }
+
+    Printer::Stream Printer::strDeclareSetOfVars(const std::set<Tests::TypeAndVarName> &vars) {
+        for (const auto &var : vars) {
+            if (var.type.isArray()) {
+                strDeclareArrayVar(var.type, var.varName, types::PointerUsage::KNOWN_SIZE);
+            } else {
+                strDeclareVar(var.type.mTypeName(), var.varName);
+            }
+        }
+        return ss;
+    }
 }

server/src/printers/Printer.h

@@ -88,6 +88,8 @@ namespace printer {
                                   std::optional<uint64_t> alignment = std::nullopt,
                                   bool complete = true);
 
+        Stream strDeclareSetOfVars(const std::set<Tests::TypeAndVarName> &vars);
+
         Stream strAssignVar(std::string_view name, std::string_view value);
 
         std::stringstream& checkOverflowStubArray(const std::string &cntCall);

server/src/printers/TestsPrinter.cpp

@@ -61,6 +61,10 @@ void TestsPrinter::joinToFinalCode(Tests &tests, const fs::path& generatedHeader
     resetStream();
     writeCopyrightHeader();
     genHeaders(tests, generatedHeaderPath);
+    ss << NL;
+
+    strDeclareSetOfVars(tests.externVariables);
+
     ss << "namespace " << PrinterUtils::TEST_NAMESPACE << " {\n";
 
     for (const auto &commentBlock : tests.commentBlocks) {

server/test/framework/Regression_Tests.cpp

@@ -367,4 +367,12 @@ namespace {
         ASSERT_TRUE(status.ok()) << status.error_message();
         testUtils::checkMinNumberOfTests(testGen.tests, 1);
     }
+
+    TEST_F(Regression_Test, Extern_Variables) {
+        fs::path source = getTestFilePath("issue-514.c");
+        auto [testGen, status] = createTestForFunction(source, 5);
+        ASSERT_TRUE(status.ok()) << status.error_message();
+        testUtils::checkMinNumberOfTests(testGen.tests, 2);
+    }
+
 }

server/test/framework/Server_Tests.cpp

@@ -535,7 +535,7 @@ namespace {
                             } }));
                 } else if (md.name == "use_globals") {
                     EXPECT_GE(md.testCases.size(), 3);
-                    EXPECT_EQ(md.globalParams.size(), 2);
+                    EXPECT_EQ(md.globalParams.size(), 3);
                 } else if (md.name == "use_global_array") {
                     EXPECT_GE(md.testCases.size(), 3);
                     EXPECT_EQ(md.globalParams.size(), 1);