Test coverage increased due new malloc() interceptor.

Author: Gonzalo Diaz

src/tests/unit/lib/hackerrank/warmup/compare_triplets.test.cpp

@@ -1,7 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 
+#include "../../../../tools/memory_injector.hpp"
 #include <exercises/hackerrank/warmup/compare_triplets.h>
-#include <iostream>
 #include <vector>
 
 #include <filesystem>
@@ -11,34 +11,58 @@ using json = nlohmann::json;
 
 TEST_CASE("compareTriplets JSON Test Cases",
           "[hackerrank] [jsontestcase] [warmup]") {
-  std::filesystem::path cwd = std::filesystem::current_path();
-  std::string path =
-      cwd.string() +
-      "/unit/lib/hackerrank/warmup/compare_triplets.testcases.json";
+#ifdef __linux__
+  SECTION("compareTriplets: Failure handling during Out of Memory (OOM)") {
+    MemoryInjector::enable_oom_fault();
 
-  INFO("compareTriplets JSON test cases FILE: " << path);
-
-  std::ifstream f(path);
-  json data = json::parse(f);
-
-  for (auto testcase : data) {
-    auto a_size = static_cast<int>(testcase["a"].size());
-    std::vector<int> a_input_vector = testcase["a"];
+    std::vector<int> a_input_vector = {1, 2, 3, 4};
+    auto a_size = static_cast<int>(a_input_vector.size());
     const int *a_input_array = a_input_vector.data();
 
-    auto b_size = static_cast<int>(testcase["b"].size());
-    std::vector<int> b_input_vector = testcase["b"];
+    std::vector<int> b_input_vector = {4, 3, 2, 1};
+    auto b_size = static_cast<int>(b_input_vector.size());
     const int *b_input_array = b_input_vector.data();
     int result_count;
 
-    int *result = HACKERRANK_WARMUP_compareTriplets(
-        a_size, a_input_array, b_size, b_input_array, &result_count);
+    REQUIRE(HACKERRANK_WARMUP_compareTriplets(a_size, a_input_array, b_size,
+                                              b_input_array,
+                                              &result_count) == nullptr);
+
+    // Clean up the state after finishing the test section
+    MemoryInjector::disable_fault();
+  }
+#endif
+
+  SECTION("compareTriplets: Normal memory allocation succeeds") {
+    std::filesystem::path cwd = std::filesystem::current_path();
+    std::string path =
+        cwd.string() +
+        "/unit/lib/hackerrank/warmup/compare_triplets.testcases.json";
+
+    INFO("compareTriplets JSON test cases FILE: " << path);
+
+    std::ifstream f(path);
+    json data = json::parse(f);
+
+    for (auto testcase : data) {
+      auto a_size = static_cast<int>(testcase["a"].size());
+      std::vector<int> a_input_vector = testcase["a"];
+      const int *a_input_array = a_input_vector.data();
+
+      auto b_size = static_cast<int>(testcase["b"].size());
+      std::vector<int> b_input_vector = testcase["b"];
+      const int *b_input_array = b_input_vector.data();
+      int result_count;
+
+      int *result = HACKERRANK_WARMUP_compareTriplets(
+          a_size, a_input_array, b_size, b_input_array, &result_count);
 
-    // Crear un vector a partir del array en C
-    std::vector<int> result_as_vector(result, result + result_count);
+      // Crear un vector a partir del array en C
+      std::vector<int> result_as_vector(result, result + result_count);
 
-    CHECK(result_as_vector == testcase["expected"]);
+      CHECK(result_as_vector == testcase["expected"]);
 
-    free(result);
+      free(result);
+    }
   }
 }

src/tests/unit/lib/hackerrank/warmup/mini_max_sum.test.cpp

@@ -1,8 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 
+#include "../../../../tools/memory_injector.hpp"
 #include <exercises/hackerrank/warmup/mini_max_sum.h>
-#include <iostream>
-#include <stdexcept>
 #include <string>
 #include <vector>
 
@@ -16,36 +15,53 @@ using json = nlohmann::json;
 
 TEST_CASE("miniMaxSum JSON Test Cases",
           "[hackerrank] [jsontestcase] [warmup]") {
-  std::filesystem::path cwd = std::filesystem::current_path();
-  std::string path =
-      cwd.string() + "/unit/lib/hackerrank/warmup/mini_max_sum.testcases.json";
+#ifdef __linux__
+  SECTION("miniMaxSum: Failure handling during Out of Memory (OOM)") {
+    MemoryInjector::enable_oom_fault();
 
-  INFO("miniMaxSum JSON test cases FILE: " << path);
+    int input_size = 3;
+    int input_array[] = {1, -2, 0};
 
-  std::ifstream f(path);
-  json data = json::parse(f);
+    HACKERRANK_WARMUP_miniMaxSum(input_size, input_array);
 
-  for (auto testcase : data) {
-    auto input_size = static_cast<int>(testcase["input"].size());
-    std::vector<int> input_vector = testcase["input"];
-    const int *input_array = input_vector.data();
+    // Clean up the state after finishing the test section
+    MemoryInjector::disable_fault();
+  }
+#endif
 
-    char *result =
-        HACKERRANK_WARMUP_miniMaxSumCalculate(input_size, input_array);
-    HACKERRANK_WARMUP_miniMaxSum(input_size, input_array);
+  SECTION("miniMaxSum: Normal memory allocation succeeds") {
+    std::filesystem::path cwd = std::filesystem::current_path();
+    std::string path =
+        cwd.string() +
+        "/unit/lib/hackerrank/warmup/mini_max_sum.testcases.json";
+
+    INFO("miniMaxSum JSON test cases FILE: " << path);
+
+    std::ifstream f(path);
+    json data = json::parse(f);
 
-    std::string result_as_string(result);
+    for (auto testcase : data) {
+      auto input_size = static_cast<int>(testcase["input"].size());
+      std::vector<int> input_vector = testcase["input"];
+      const int *input_array = input_vector.data();
 
-    free(result);
+      char *result =
+          HACKERRANK_WARMUP_miniMaxSumCalculate(input_size, input_array);
+      HACKERRANK_WARMUP_miniMaxSum(input_size, input_array);
 
-    CHECK(result_as_string == testcase["expected"]);
+      std::string result_as_string(result);
+
+      free(result);
+
+      CHECK(result_as_string == testcase["expected"]);
+    }
   }
-}
 
-TEST_CASE("miniMaxSum Edge Cases", "[hackerrank] [warmup]") {
-  std::vector<int> empty({});
+  SECTION("miniMaxSum Edge Cases", "[hackerrank] [warmup]") {
+    std::vector<int> empty({});
 
-  const char *result = HACKERRANK_WARMUP_miniMaxSumCalculate(0, empty.data());
+    const char *result = HACKERRANK_WARMUP_miniMaxSumCalculate(0, empty.data());
 
-  CHECK(result == nullptr);
+    CHECK(result == nullptr);
+  }
 }

src/tests/unit/lib/hackerrank/warmup/plus_minus.test.cpp

@@ -1,8 +1,8 @@
 #include <catch2/catch_test_macros.hpp>
 
+#include "../../../../tools/memory_injector.hpp"
 #include <exercises/hackerrank/warmup/plus_minus.h>
-#include <iostream>
-#include <stdexcept>
+
 #include <vector>
 
 #include <filesystem>
@@ -11,34 +11,67 @@
 using json = nlohmann::json;
 
 TEST_CASE("plusMinus JSON Test Cases", "[hackerrank] [jsontestcase] [warmup]") {
-  std::filesystem::path cwd = std::filesystem::current_path();
-  std::string path =
-      cwd.string() + "/unit/lib/hackerrank/warmup/plus_minus.testcases.json";
+#ifdef __linux__
+  SECTION("Failure handling during Out of Memory (OOM)") {
+    // MemoryInjector::enable_oom_fault();
 
-  INFO("plusMinus JSON test cases FILE: " << path);
+    int input_size = 3;
+    int input_array[] = {1, -2, 0};
 
-  std::ifstream f(path);
-  json data = json::parse(f);
+    MemoryInjector::fail_on_allocation_number(1);
+    REQUIRE(HACKERRANK_WARMUP_plusMinusCalculate(input_size, input_array) ==
+            nullptr);
 
-  for (auto testcase : data) {
-    auto input_size = static_cast<int>(testcase["input"].size());
-    std::vector<int> input_vector = testcase["input"];
-    const int *input_array = input_vector.data();
+    MemoryInjector::fail_on_allocation_number(2);
+    REQUIRE(HACKERRANK_WARMUP_plusMinusCalculate(input_size, input_array) ==
+            nullptr);
 
-    char **result =
-        HACKERRANK_WARMUP_plusMinusCalculate(input_size, input_array);
+    MemoryInjector::fail_on_allocation_number(3);
+    REQUIRE(HACKERRANK_WARMUP_plusMinusCalculate(input_size, input_array) ==
+            nullptr);
 
-    std::vector<std::string> result_as_vector;
+    MemoryInjector::disable_fault();
+    MemoryInjector::enable_oom_fault();
+    REQUIRE_NOTHROW(HACKERRANK_WARMUP_plusMinus(input_size, input_array));
 
-    for (int i = 0; i < HACKERRANK_WARMUP_PLUSMINUS_LIMIT_ANSWERS; i++) {
-      result_as_vector.emplace_back(result[i]);
-    }
-    HACKERRANK_WARMUP_freePlusMinus(result,
-                                    HACKERRANK_WARMUP_PLUSMINUS_LIMIT_ANSWERS);
+    // Clean up the state after finishing the test section
+    MemoryInjector::disable_fault();
+  }
+#endif
+
+  SECTION("Normal memory allocation succeeds") {
+    // Reset the injector state before every section running
+    // MemoryInjector::disable_fault();
+
+    std::filesystem::path cwd = std::filesystem::current_path();
+    std::string path =
+        cwd.string() + "/unit/lib/hackerrank/warmup/plus_minus.testcases.json";
+
+    INFO("plusMinus JSON test cases FILE: " << path);
 
-    CHECK(result_as_vector == testcase["expected"]);
+    std::ifstream f(path);
+    json data = json::parse(f);
 
-    // Just call void function, to collect coverage
-    HACKERRANK_WARMUP_plusMinus(input_size, input_array);
+    for (auto testcase : data) {
+      auto input_size = static_cast<int>(testcase["input"].size());
+      std::vector<int> input_vector = testcase["input"];
+      const int *input_array = input_vector.data();
+
+      char **result =
+          HACKERRANK_WARMUP_plusMinusCalculate(input_size, input_array);
+
+      std::vector<std::string> result_as_vector;
+
+      for (int i = 0; i < HACKERRANK_WARMUP_PLUSMINUS_LIMIT_ANSWERS; i++) {
+        result_as_vector.emplace_back(result[i]);
+      }
+      HACKERRANK_WARMUP_freePlusMinus(
+          result, HACKERRANK_WARMUP_PLUSMINUS_LIMIT_ANSWERS);
+
+      CHECK(result_as_vector == testcase["expected"]);
+
+      // Just call void function, to collect coverage
+      HACKERRANK_WARMUP_plusMinus(input_size, input_array);
+    }
   }
 }

src/tests/unit/lib/hackerrank/warmup/staircase.test.cpp

@@ -1,39 +1,68 @@
+// 3rd party libs
 #include <catch2/catch_test_macros.hpp>
 
+#include <nlohmann/json.hpp>
+
+// local libs
+#if defined(__linux__)
+#include "../../../../tools/memory_injector.hpp"
+#endif
 #include <exercises/hackerrank/warmup/staircase.h>
+
+// std libs
 #include <filesystem>
 #include <fstream>
 #include <nlohmann/json.hpp>
 #include <vector>
 
 using json = nlohmann::json;
 
-TEST_CASE("staircase", "[warmup]") {
-  std::filesystem::path cwd = std::filesystem::current_path();
-  std::string path =
-      cwd.string() + "/unit/lib/hackerrank/warmup/staircase.testcases.json";
+TEST_CASE("staircase JSON Test Cases", "[hackerrank] [jsontestcase] [warmup]") {
+#if defined(__linux__)
+  SECTION("staircase: Failure handling during Out of Memory (OOM)") {
+    int input = 4;
 
-  INFO("staircase JSON test cases FILE: " << path);
+    MemoryInjector::enable_oom_fault();
+    REQUIRE(HACKERRANK_WARMUP_staircaseCalculate(input) == nullptr);
+    MemoryInjector::disable_fault();
 
-  std::ifstream f(path);
-  json data = json::parse(f);
+    MemoryInjector::fail_on_allocation_number(2);
+    REQUIRE(HACKERRANK_WARMUP_staircaseCalculate(input) == nullptr);
+    MemoryInjector::disable_fault();
 
-  for (auto testcase : data) {
-    auto input = static_cast<int>(testcase["input"]);
+    MemoryInjector::enable_oom_fault();
+    REQUIRE_NOTHROW(HACKERRANK_WARMUP_staircase(input));
+    MemoryInjector::disable_fault();
+  }
+#endif
 
-    char **result = HACKERRANK_WARMUP_staircaseCalculate(input);
+  SECTION("plusMinus: Normal memory allocation succeeds") {
+    std::filesystem::path cwd = std::filesystem::current_path();
+    std::string path =
+        cwd.string() + "/unit/lib/hackerrank/warmup/staircase.testcases.json";
 
-    std::vector<std::string> result_as_vector;
+    INFO("staircase JSON test cases FILE: " << path);
 
-    for (int i = 0; i < input; i++) {
-      result_as_vector.emplace_back(result[i]);
-    }
+    std::ifstream f(path);
+    json data = json::parse(f);
 
-    HACKERRANK_WARMUP_freeStaircase(result, input);
+    for (auto testcase : data) {
+      auto input = static_cast<int>(testcase["input"]);
 
-    CHECK(result_as_vector == testcase["expected"]);
+      char **result = HACKERRANK_WARMUP_staircaseCalculate(input);
 
-    // Just call void function, to collect coverage
-    HACKERRANK_WARMUP_staircase(input);
+      std::vector<std::string> result_as_vector;
+
+      for (int i = 0; i < input; i++) {
+        result_as_vector.emplace_back(result[i]);
+      }
+
+      HACKERRANK_WARMUP_freeStaircase(result, input);
+
+      CHECK(result_as_vector == testcase["expected"]);
+
+      // Just call void function, to collect coverage
+      HACKERRANK_WARMUP_staircase(input);
+    }
   }
 }