Change representation of char* from string to array

server/src/Tests.cpp

@@ -923,14 +923,17 @@ void KTestObjectParser::getTestParamView(const Tests::MethodDescription &methodD
                                          Tests::TestCaseDescription &testCaseDescription,
                                          const Tests::MethodParam& methodParam,
                                          std::shared_ptr<AbstractValueView> &testParamView) {
-    auto paramType = methodParam.type.maybeJustPointer() ? methodParam.type.baseTypeObj() : methodParam.type;
+    const auto usage = types::PointerUsage::PARAMETER;
+    types::Type paramType = methodParam.type.arrayCloneMultiDim(usage);
+    auto type = typesHandler.getReturnTypeToCheck(paramType);
+
     if (CollectionUtils::containsKey(methodDescription.functionPointers, methodParam.name)) {
         testParamView = testParameterView(
-                emptyKleeParam, { paramType, methodParam.name }, PointerUsage::PARAMETER, testCaseDescription.lazyAddressToName,
+                emptyKleeParam, { type, methodParam.name }, PointerUsage::PARAMETER, testCaseDescription.lazyAddressToName,
                 testCaseDescription.lazyReferences, methodDescription);
     } else {
         const auto kleeParam = getKleeParamOrThrow(rawKleeParams, methodParam.name);
-        testParamView = testParameterView(kleeParam, { paramType, methodParam.name }, PointerUsage::PARAMETER,
+        testParamView = testParameterView(kleeParam, { type, methodParam.name }, PointerUsage::PARAMETER,
                                           testCaseDescription.lazyAddressToName, testCaseDescription.lazyReferences,
                                           methodDescription);
     }

server/test/framework/Regression_Tests.cpp

@@ -244,8 +244,16 @@ namespace {
         auto predicate = [](const tests::Tests::MethodTestCase &testCase) {
             auto s = testCase.paramValues[0].view->getEntryValue(nullptr);
             s = s.substr(1, s.length() - 2);
+            size_t i = 0;
+            unsigned int sum = 0;
+            //Hash count of word`s letters
+            while (s.substr(i, 4) != "'\\0'"){
+                sum += s[i + 1];
+                i += 5;// Go to next letter
+            }
+
             auto actual = testCase.returnValue.view->getEntryValue(nullptr);
-            auto expected = std::to_string(std::accumulate(s.begin(), s.end(), 0));
+            auto expected = std::to_string(sum);
             return actual == expected;
         };
 
@@ -254,12 +262,12 @@ namespace {
             std::vector<TestCasePredicate>(
                 { [&predicate](const tests::Tests::MethodTestCase &testCase) {
                      // empty string
-                     return testCase.paramValues[0].view->getEntryValue(nullptr).length() == 2 &&
+                     return testCase.paramValues[0].view->getEntryValue(nullptr).substr(2, 2) == "\\0" &&
                             predicate(testCase);
                  },
                   [&predicate](const tests::Tests::MethodTestCase &testCase) {
                       // non-empty string
-                      return testCase.paramValues[0].view->getEntryValue(nullptr).length() > 2 &&
+                      return testCase.paramValues[0].view->getEntryValue(nullptr).substr(2, 2) != "\\0" &&
                              predicate(testCase);
                   } }),
             "hash");

server/test/framework/Syntax_Tests.cpp

@@ -416,7 +416,7 @@ namespace {
                 {[] (const tests::Tests::MethodTestCase& testCase) {
                 auto entryValue = testCase.paramValues[0].view->getEntryValue(nullptr);
                 auto returnValue = stoll(testCase.returnValue.view->getEntryValue(nullptr));
-                return static_cast<unsigned char>(entryValue[1]) ==
+                return static_cast<unsigned char>(entryValue[2]) ==
                        static_cast<unsigned char>(returnValue);
             }
                 }),
@@ -1187,10 +1187,14 @@ namespace {
             testGen.tests.at(qualifiers_c).methods.begin().value().testCases,
             std::vector<TestCasePredicate>(
                 {[] (const tests::Tests::MethodTestCase& testCase) {
-                  return testCase.paramValues[0].view->getEntryValue(nullptr) == "\"hello\"" && stoi(testCase.returnValue.view->getEntryValue(nullptr)) == 1;
+                  auto param_values = testCase.paramValues[0].view->getEntryValue(nullptr);
+                  const int word_end = 31; //End of word "hello" in param_values string
+                  return param_values == ("{'h', 'e', 'l', 'l', 'o', '\\0'," + param_values.substr(word_end))  && stoi(testCase.returnValue.view->getEntryValue(nullptr)) == 1;
                 },
                  [] (const tests::Tests::MethodTestCase& testCase) {
-                   return testCase.paramValues[0].view->getEntryValue(nullptr) !=  "\"hello\"" && stoi(testCase.returnValue.view->getEntryValue(nullptr)) == 0;
+                      auto param_values = testCase.paramValues[0].view->getEntryValue(nullptr);
+                      const int word_end = 31; //End of word "hello" in param_values string
+                      return param_values != ("{'h', 'e', 'l', 'l', 'o', '\\0'," + param_values.substr(word_end)) && stoi(testCase.returnValue.view->getEntryValue(nullptr)) == 0;
                  }
                 })
         );