unsupported int128 tests (#452)

* int128 tests added

* fix utils_tests

* fixed template specialization UB, improved randomness

server/src/utils/StringUtils.cpp

@@ -158,7 +158,7 @@ namespace StringUtils {
  }
 
  template<>
- int stot<>(const std::string& s) {
+ int stot(const std::string& s) {
  return std::stoi(s);
  }
  template<>
@@ -203,6 +203,48 @@ namespace StringUtils {
  LOG_S(ERROR) << "Wrong bool value: " + s;
  throw std::invalid_argument("Wrong bool value: " + s);
  }
+ template<>
+ __int128 stot(const std::string& s) {
+ if (s.empty()) {
+ throw std::invalid_argument("Empty int128");
+ }
+ bool neg = s[0] == '-';
+ size_t pos = (s[0] == '+' || s[0] == '-') ? 1 : 0;
+ __int128 res = 0;
+ for (; pos < s.size(); ++pos) {
+ char d = s[pos];
+ if (d < '0' || d > '9') {
+ throw std::invalid_argument("Not an int128: " + s);
+ }
+ res *= 10;
+ if (neg) {
+ res -= d - '0';
+ } else {
+ res += d - '0';
+ }
+ }
+ return res;
+ }
+ template<>
+ unsigned __int128 stot(const std::string& s) {
+ if (s.empty()) {
+ throw std::invalid_argument("Empty unsigned int128");
+ }
+ if (s[0] == '-') {
+ throw std::invalid_argument("Signed unsigned int128: " + s);
+ }
+ size_t pos = s[0] == '+' ? 1 : 0;
+ unsigned __int128 res = 0;
+ for (; pos < s.size(); ++pos) {
+ char d = s[pos];
+ if (d < '0' || d > '9') {
+ throw std::invalid_argument("Not an int128: " + s);
+ }
+ res *= 10;
+ res += d - '0';
+ }
+ return res;
+ }
 
  std::string wrapQuotations(const std::string &s) {
  return "\"" + s + "\"";

server/src/utils/StringUtils.h

@@ -87,6 +87,18 @@ namespace StringUtils {
  T stot(const std::string&) {
  return T();
  }
+ template<> int stot(const std::string& s);
+ template<> long stot(const std::string& s);
+ template<> long long stot(const std::string& s);
+ template<> unsigned int stot(const std::string& s);
+ template<> unsigned long stot(const std::string& s);
+ template<> unsigned long long stot(const std::string& s);
+ template<> float stot(const std::string& s);
+ template<> double stot(const std::string& s);
+ template<> long double stot(const std::string& s);
+ template<> bool stot(const std::string& s);
+ template<> __int128 stot(const std::string& s);
+ template<> unsigned __int128 stot(const std::string& s);
 
  std::string wrapQuotations(const std::string &s);
 }

server/test/framework/Syntax_Tests.cpp

@@ -3658,7 +3658,7 @@ namespace {
  checkBitfieldFit<unsigned>(subViews[2], 15) &&
  testCase.returnValue.view->getEntryValue(nullptr) == "13";
  }
- })
+  })
  );
  }
 
@@ -3703,4 +3703,37 @@ namespace {
  return stoi(testCase.returnValue.view->getEntryValue(nullptr)) == 42;
  }}));
  }
+
+ TEST_F(Syntax_Test, DISABLED_int128_mult) {
+ auto [testGen, status] = createTestForFunction(types_c, 120);
+
+ ASSERT_TRUE(status.ok()) << status.error_message();
+
+ for (const auto &testCase: testGen.tests.at(types_c).methods.begin().value().testCases) {
+ auto res = StringUtils::stot<unsigned __int128>(
+ testCase.returnValue.view->getEntryValue(nullptr));
+ auto a = StringUtils::stot<unsigned long long>(
+ testCase.paramValues[0].view->getEntryValue(nullptr));
+ auto b = StringUtils::stot<unsigned long long>(
+ testCase.paramValues[1].view->getEntryValue(nullptr));
+ ASSERT_TRUE(res == ~((unsigned __int128) 0) || res == static_cast<unsigned __int128>(a) * b);
+ }
+
+ checkTestCasePredicates(
+ testGen.tests.at(bitfields_c).methods.begin().value().testCases,
+ std::vector<TestCasePredicate>(
+ {
+ [](const tests::Tests::MethodTestCase &testCase) {
+ return StringUtils::stot<unsigned __int128>(
+ testCase.returnValue.view->getEntryValue(nullptr)) ==
+ ~((unsigned __int128) 0);
+ },
+ [](const tests::Tests::MethodTestCase &testCase) {
+ return StringUtils::stot<unsigned __int128>(
+ testCase.returnValue.view->getEntryValue(nullptr)) !=
+ ~((unsigned __int128) 0);
+ }
+ })
+ );
+ }
 }

server/test/framework/Utils_Tests.cpp

@@ -15,6 +15,25 @@
 namespace {
  auto projectPath = fs::current_path().parent_path() / testUtils::getRelativeTestSuitePath("server");
 
+ TEST(StringUtils_stotInt128, simple) {
+ __int128 val = 42;
+ auto res = StringUtils::stot<__int128>("42");
+ EXPECT_EQ(val, res);
+ }
+
+ TEST(StringUtils_stotInt128, simple_unsigned) {
+ unsigned __int128 val = 42;
+ auto res = StringUtils::stot<unsigned __int128>("42");
+ EXPECT_EQ(val, res);
+ }
+
+ TEST(StringUtils_stotInt128, INT128_MIN) {
+ __int128 val = 1;
+ val <<= 127;
+ auto res = StringUtils::stot<__int128>("-170141183460469231731687303715884105728");
+ EXPECT_EQ(val, res);
+ }
+
  TEST(ReadBytesAsValueTest, Unsigned1) {
  size_t const LEN = 4;
  std::vector<char> bytes(LEN);
@@ -307,12 +326,12 @@ namespace {
 
  template<typename T>
  void readBytesAsValueTestTemplate(T val) {
- srand(42);
+ size_t const len = sizeof(T);
+ std::default_random_engine gen(42);
  for (size_t tcount = 0; tcount < 5; ++tcount) {
- auto add = static_cast<size_t>(rand() % 10);
- auto start = static_cast<size_t>(rand() % add);
- size_t const len = sizeof(T);
- std::vector<char> bytes(len + add);
+ auto extra = static_cast<size_t>(std::uniform_int_distribution<unsigned>(1, 10)(gen));
+ auto start = static_cast<size_t>(std::uniform_int_distribution<unsigned>(0, extra)(gen));
+ std::vector<char> bytes(len + extra);
  for (size_t i = 1; i <= len; ++i) {
  bytes[start + i - 1] = (val >> (CHAR_BIT * (i - 1))) & ((1 << CHAR_BIT) - 1);
  }

server/test/suites/syntax/types.c

@@ -1,6 +1,7 @@
 #include "types.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <limits.h>
 
 char a_or_b(char a, char b) {
  if (a == 'a') {
@@ -114,3 +115,12 @@ int structWithConstPointerParam(struct SupportedStruct4 st) {
 struct IncompleteType {
  char c[100];
 };
+
+unsigned __int128 int128_mult(unsigned long long a, unsigned long long b) {
+ unsigned __int128 mult = a;
+ mult *= b;
+ if (mult > (unsigned __int128) LLONG_MAX) {
+ return ~((unsigned __int128)0);
+ }
+ return mult;
+}

server/test/suites/syntax/types.h

@@ -61,4 +61,6 @@ int void_pointer(void * a);
 // This function should be skipped, as structs with unions are not supported.
 struct UnsupportedStruct3 structWithUnion(int a);
 
+unsigned __int128 int128_mult(unsigned long long a, unsigned long long b);
+
 #endif //SIMPLE_TEST_PROJECT_OTHER_TYPES_h