Fix conan (#10)

* Fix debug conan build target

* Add viewcoverage and fix coverage generation

* Add more tests to cover new integrity checks

* Add tests to accomplish 100%

* Fix conan-create makefile target

tests/BinDisc_unittest.cpp

@@ -11,6 +11,16 @@
 #include <ArffFiles.hpp>
 #include "BinDisc.h"
 #include "Experiments.hpp"
+#include <cmath>
+
+#define EXPECT_THROW_WITH_MESSAGE(stmt, etype, whatstring) EXPECT_THROW( \
+try { \
+stmt; \
+} catch (const etype& ex) { \
+EXPECT_EQ(whatstring, std::string(ex.what())); \
+throw; \
+} \
+, etype)
 
 namespace mdlp {
     const float margin = 1e-4;
@@ -400,4 +410,64 @@ namespace mdlp {
         }
         // std::cout << "* Number of experiments tested: " << num << std::endl;
     }
+
+    TEST_F(TestBinDisc3U, FitDataSizeTooSmall)
+    {
+        // Test when data size is smaller than n_bins
+        samples_t X = { 1.0, 2.0 }; // Only 2 elements for 3 bins
+        EXPECT_THROW_WITH_MESSAGE(fit(X), std::invalid_argument, "Input data size must be at least equal to n_bins");
+    }
+
+    TEST_F(TestBinDisc3Q, FitDataSizeTooSmall)
+    {
+        // Test when data size is smaller than n_bins
+        samples_t X = { 1.0, 2.0 }; // Only 2 elements for 3 bins
+        EXPECT_THROW_WITH_MESSAGE(fit(X), std::invalid_argument, "Input data size must be at least equal to n_bins");
+    }
+
+    TEST_F(TestBinDisc3U, FitWithYEmptyX)
+    {
+        // Test fit(X, y) with empty X
+        samples_t X = {};
+        labels_t y = { 1, 2, 3 };
+        EXPECT_THROW_WITH_MESSAGE(fit(X, y), std::invalid_argument, "X cannot be empty");
+    }
+
+    TEST_F(TestBinDisc3U, LinspaceInvalidNumPoints)
+    {
+        // Test linspace with num < 2
+        EXPECT_THROW_WITH_MESSAGE(linspace(0.0f, 1.0f, 1), std::invalid_argument, "Number of points must be at least 2 for linspace");
+    }
+
+    TEST_F(TestBinDisc3U, LinspaceNaNValues)
+    {
+        // Test linspace with NaN values
+        float nan_val = std::numeric_limits<float>::quiet_NaN();
+        EXPECT_THROW_WITH_MESSAGE(linspace(nan_val, 1.0f, 3), std::invalid_argument, "Start and end values cannot be NaN");
+        EXPECT_THROW_WITH_MESSAGE(linspace(0.0f, nan_val, 3), std::invalid_argument, "Start and end values cannot be NaN");
+    }
+
+    TEST_F(TestBinDisc3U, LinspaceInfiniteValues)
+    {
+        // Test linspace with infinite values
+        float inf_val = std::numeric_limits<float>::infinity();
+        EXPECT_THROW_WITH_MESSAGE(linspace(inf_val, 1.0f, 3), std::invalid_argument, "Start and end values cannot be infinite");
+        EXPECT_THROW_WITH_MESSAGE(linspace(0.0f, inf_val, 3), std::invalid_argument, "Start and end values cannot be infinite");
+    }
+
+    TEST_F(TestBinDisc3U, PercentileEmptyData)
+    {
+        // Test percentile with empty data
+        samples_t empty_data = {};
+        std::vector<precision_t> percentiles = { 25.0f, 50.0f, 75.0f };
+        EXPECT_THROW_WITH_MESSAGE(percentile(empty_data, percentiles), std::invalid_argument, "Data cannot be empty for percentile calculation");
+    }
+
+    TEST_F(TestBinDisc3U, PercentileEmptyPercentiles)
+    {
+        // Test percentile with empty percentiles
+        samples_t data = { 1.0f, 2.0f, 3.0f };
+        std::vector<precision_t> empty_percentiles = {};
+        EXPECT_THROW_WITH_MESSAGE(percentile(data, empty_percentiles), std::invalid_argument, "Percentiles cannot be empty");
+    }
 }

tests/CMakeLists.txt

@@ -1,6 +1,7 @@
 
 find_package(arff-files REQUIRED)
 find_package(GTest REQUIRED)
+find_package(Torch CONFIG REQUIRED)
 
 include_directories(
         ${libtorch_INCLUDE_DIRS_DEBUG}

tests/Discretizer_unittest.cpp

@@ -13,6 +13,15 @@
 #include "BinDisc.h"
 #include "CPPFImdlp.h"
 
+#define EXPECT_THROW_WITH_MESSAGE(stmt, etype, whatstring) EXPECT_THROW( \
+try { \
+stmt; \
+} catch (const etype& ex) { \
+EXPECT_EQ(whatstring, std::string(ex.what())); \
+throw; \
+} \
+, etype)
+
 namespace mdlp {
     const float margin = 1e-4;
     static std::string set_data_path()
@@ -270,4 +279,110 @@ namespace mdlp {
             EXPECT_EQ(computed[i], expected[i]);
         }
     }
+
+    TEST(Discretizer, TransformEmptyData)
+    {
+        Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
+        samples_t empty_data = {};
+        EXPECT_THROW_WITH_MESSAGE(disc->transform(empty_data), std::invalid_argument, "Data for transformation cannot be empty");
+        delete disc;
+    }
+
+    TEST(Discretizer, TransformNotFitted)
+    {
+        Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
+        samples_t data = { 1.0f, 2.0f, 3.0f };
+        EXPECT_THROW_WITH_MESSAGE(disc->transform(data), std::runtime_error, "Discretizer not fitted yet or no valid cut points found");
+        delete disc;
+    }
+
+    TEST(Discretizer, TensorValidationFit)
+    {
+        Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
+
+        auto X = torch::tensor({ 1.0f, 2.0f, 3.0f }, torch::kFloat32);
+        auto y = torch::tensor({ 1, 2, 3 }, torch::kInt32);
+
+        // Test non-1D tensors
+        auto X_2d = torch::tensor({ {1.0f, 2.0f}, {3.0f, 4.0f} }, torch::kFloat32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_t(X_2d, y), std::invalid_argument, "Only 1D tensors supported");
+
+        auto y_2d = torch::tensor({ {1, 2}, {3, 4} }, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_t(X, y_2d), std::invalid_argument, "Only 1D tensors supported");
+
+        // Test wrong tensor types
+        auto X_int = torch::tensor({ 1, 2, 3 }, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_t(X_int, y), std::invalid_argument, "X tensor must be Float32 type");
+
+        auto y_float = torch::tensor({ 1.0f, 2.0f, 3.0f }, torch::kFloat32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_t(X, y_float), std::invalid_argument, "y tensor must be Int32 type");
+
+        // Test mismatched sizes
+        auto y_short = torch::tensor({ 1, 2 }, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_t(X, y_short), std::invalid_argument, "X and y tensors must have same number of elements");
+
+        // Test empty tensors
+        auto X_empty = torch::tensor({}, torch::kFloat32);
+        auto y_empty = torch::tensor({}, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_t(X_empty, y_empty), std::invalid_argument, "Tensors cannot be empty");
+
+        delete disc;
+    }
+
+    TEST(Discretizer, TensorValidationTransform)
+    {
+        Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
+
+        // First fit with valid data
+        auto X_fit = torch::tensor({ 1.0f, 2.0f, 3.0f, 4.0f }, torch::kFloat32);
+        auto y_fit = torch::tensor({ 1, 2, 3, 4 }, torch::kInt32);
+        disc->fit_t(X_fit, y_fit);
+
+        // Test non-1D tensor
+        auto X_2d = torch::tensor({ {1.0f, 2.0f}, {3.0f, 4.0f} }, torch::kFloat32);
+        EXPECT_THROW_WITH_MESSAGE(disc->transform_t(X_2d), std::invalid_argument, "Only 1D tensors supported");
+
+        // Test wrong tensor type
+        auto X_int = torch::tensor({ 1, 2, 3 }, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->transform_t(X_int), std::invalid_argument, "X tensor must be Float32 type");
+
+        // Test empty tensor
+        auto X_empty = torch::tensor({}, torch::kFloat32);
+        EXPECT_THROW_WITH_MESSAGE(disc->transform_t(X_empty), std::invalid_argument, "Tensor cannot be empty");
+
+        delete disc;
+    }
+
+    TEST(Discretizer, TensorValidationFitTransform)
+    {
+        Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
+
+        auto X = torch::tensor({ 1.0f, 2.0f, 3.0f }, torch::kFloat32);
+        auto y = torch::tensor({ 1, 2, 3 }, torch::kInt32);
+
+        // Test non-1D tensors
+        auto X_2d = torch::tensor({ {1.0f, 2.0f}, {3.0f, 4.0f} }, torch::kFloat32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_transform_t(X_2d, y), std::invalid_argument, "Only 1D tensors supported");
+
+        auto y_2d = torch::tensor({ {1, 2}, {3, 4} }, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_transform_t(X, y_2d), std::invalid_argument, "Only 1D tensors supported");
+
+        // Test wrong tensor types
+        auto X_int = torch::tensor({ 1, 2, 3 }, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_transform_t(X_int, y), std::invalid_argument, "X tensor must be Float32 type");
+
+        auto y_float = torch::tensor({ 1.0f, 2.0f, 3.0f }, torch::kFloat32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_transform_t(X, y_float), std::invalid_argument, "y tensor must be Int32 type");
+
+        // Test mismatched sizes
+        auto y_short = torch::tensor({ 1, 2 }, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_transform_t(X, y_short), std::invalid_argument, "X and y tensors must have same number of elements");
+
+        // Test empty tensors
+        auto X_empty = torch::tensor({}, torch::kFloat32);
+        auto y_empty = torch::tensor({}, torch::kInt32);
+        EXPECT_THROW_WITH_MESSAGE(disc->fit_transform_t(X_empty, y_empty), std::invalid_argument, "Tensors cannot be empty");
+
+        delete disc;
+    }
 }

tests/FImdlp_unittest.cpp

@@ -167,6 +167,15 @@ namespace mdlp {
         indices = { 1, 2, 0 };
     }
 
+    TEST_F(TestFImdlp, SortIndicesOutOfBounds)
+    {
+        // Test for out of bounds exception in sortIndices
+        samples_t X_long = { 1.0f, 2.0f, 3.0f };
+        labels_t y_short = { 1, 2 };
+        EXPECT_THROW_WITH_MESSAGE(sortIndices(X_long, y_short), std::out_of_range, "Index out of bounds in sort comparison");
+    }
+
+
     TEST_F(TestFImdlp, TestShortDatasets)
     {
         vector<precision_t> computed;
@@ -364,4 +373,55 @@ namespace mdlp {
             EXPECT_EQ(computed_ft[i], expected[i]);
         }
     }
+    TEST_F(TestFImdlp, SafeXAccessIndexOutOfBounds)
+    {
+        // Test safe_X_access with index out of bounds for indices array
+        X = { 1.0f, 2.0f, 3.0f };
+        y = { 1, 2, 3 };
+        indices = { 0, 1 }; // shorter than expected
+
+        // This should trigger the first exception in safe_X_access (idx >= indices.size())
+        EXPECT_THROW_WITH_MESSAGE(safe_X_access(2), std::out_of_range, "Index out of bounds for indices array");
+    }
+
+    TEST_F(TestFImdlp, SafeXAccessXOutOfBounds)
+    {
+        // Test safe_X_access with real_idx out of bounds for X array
+        X = { 1.0f, 2.0f }; // shorter array
+        y = { 1, 2, 3 };
+        indices = { 0, 1, 5 }; // indices[2] = 5 is out of bounds for X
+
+        // This should trigger the second exception in safe_X_access (real_idx >= X.size())
+        EXPECT_THROW_WITH_MESSAGE(safe_X_access(2), std::out_of_range, "Index out of bounds for X array");
+    }
+
+    TEST_F(TestFImdlp, SafeYAccessIndexOutOfBounds)
+    {
+        // Test safe_y_access with index out of bounds for indices array
+        X = { 1.0f, 2.0f, 3.0f };
+        y = { 1, 2, 3 };
+        indices = { 0, 1 }; // shorter than expected
+
+        // This should trigger the first exception in safe_y_access (idx >= indices.size())
+        EXPECT_THROW_WITH_MESSAGE(safe_y_access(2), std::out_of_range, "Index out of bounds for indices array");
+    }
+
+    TEST_F(TestFImdlp, SafeYAccessYOutOfBounds)
+    {
+        // Test safe_y_access with real_idx out of bounds for y array
+        X = { 1.0f, 2.0f, 3.0f };
+        y = { 1, 2 }; // shorter array
+        indices = { 0, 1, 5 }; // indices[2] = 5 is out of bounds for y
+
+        // This should trigger the second exception in safe_y_access (real_idx >= y.size())
+        EXPECT_THROW_WITH_MESSAGE(safe_y_access(2), std::out_of_range, "Index out of bounds for y array");
+    }
+
+    TEST_F(TestFImdlp, SafeSubtractUnderflow)
+    {
+        // Test safe_subtract with underflow condition (b > a)
+        EXPECT_THROW_WITH_MESSAGE(safe_subtract(3, 5), std::underflow_error, "Subtraction would cause underflow");
+    }
+
+
 }