Fixed unit test

unit_tests/operator/Test_Squeeze_Op.cpp

@@ -42,7 +42,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
   std::mt19937 gen(random_seed());
 
   // Random float distribution between 0 and 1
-  constexpr int8_t max_nb_dims = 7;
+  constexpr int64_t max_nb_dims = 7;
   std::uniform_real_distribution<float> tensor_value_dist(0.1f, 1.1f);
   std::uniform_int_distribution<std::size_t> tensor_nb_dims_dist(
       std::size_t(1), std::size_t(max_nb_dims));
@@ -64,7 +64,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
 
     SECTION("empty tensor") {
       // Create the Squeeze Operator
-      std::shared_ptr<Node> squeeze_node = Squeeze(std::vector<int8_t>({0}));
+      std::shared_ptr<Node> squeeze_node = Squeeze(std::vector<int64_t>({0}));
       auto op =
           std::static_pointer_cast<OperatorTensor>(squeeze_node->getOperator());
       op->associateInput(0, input_T);
@@ -75,7 +75,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
   SECTION("ERROR : nb_dims_to_squeeze>input.size()") {
     constexpr size_t nb_dims_to_squeeze = 100;
 
-    std::vector<std::int8_t> dims_to_squeeze(nb_dims_to_squeeze);
+    std::vector<std::int64_t> dims_to_squeeze(nb_dims_to_squeeze);
     std::generate(dims_to_squeeze.begin(), dims_to_squeeze.end(),
                   [&gen, &idx_dims_to_squeeze_dist]() {
                     return idx_dims_to_squeeze_dist(gen);
@@ -102,8 +102,8 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
   SECTION("Compare with reference output") {
     SECTION("axes is given via attribute") {
       SECTION("Squeeze a 1-sized-axis") {
-        int8_t nb_dims = 4;
-        std::shared_ptr<Node> squeeze_node = Squeeze(std::vector<std::int8_t>({0}));
+        int64_t nb_dims = 4;
+        std::shared_ptr<Node> squeeze_node = Squeeze(std::vector<std::int64_t>({0}));
         auto op = std::static_pointer_cast<OperatorTensor>(
             squeeze_node->getOperator());
         op->associateInput(0, input_T);
@@ -118,7 +118,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
       SECTION("Squeeze multiple 1-sized axes") {
         // test should be successful
         std::shared_ptr<Node> squeeze_node =
-            Squeeze(std::vector<int8_t>({1, -4}));
+            Squeeze(std::vector<int64_t>({1, -4}));
         auto op = std::static_pointer_cast<OperatorTensor>(
             squeeze_node->getOperator());
         op->associateInput(0, input_T);
@@ -131,8 +131,8 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
         CHECK((op->getOutput(0)->dims().size()) == 2);
       }
       SECTION("Squeeze a non-1-Sized axis") {
-        int8_t nb_dims = 4;
-        std::shared_ptr<Node> squeeze_node = Squeeze(std::vector<std::int8_t>({3}));
+        int64_t nb_dims = 4;
+        std::shared_ptr<Node> squeeze_node = Squeeze(std::vector<std::int64_t>({3}));
         auto op = std::static_pointer_cast<OperatorTensor>(
             squeeze_node->getOperator());
         op->associateInput(0, input_T);
@@ -144,7 +144,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
       }
       SECTION("Squeeze multiple non-sized-axes") {
         std::shared_ptr<Node> squeeze_node =
-            Squeeze(std::vector<int8_t>({1, -2}));
+            Squeeze(std::vector<int64_t>({1, -2}));
         auto op = std::static_pointer_cast<OperatorTensor>(
             squeeze_node->getOperator());
         op->associateInput(0, input_T);
@@ -159,7 +159,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
       SECTION("tensor is empty") {
         // arguments here should be overridden by axes_T values
         std::shared_ptr<Node> myUnsqueeze =
-            Squeeze(std::vector<std::int8_t>({0, 4}));
+            Squeeze(std::vector<std::int64_t>({0, 4}));
         auto op = std::static_pointer_cast<OperatorTensor>(
             myUnsqueeze->getOperator());
         op->associateInput(0, input_T);
@@ -180,13 +180,13 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
       SECTION("tensor not empty") {
         // arguments here should be overridden by axes_T values
         std::shared_ptr<Node> myUnsqueeze =
-            Squeeze(std::vector<std::int8_t>({3, 1}));
+            Squeeze(std::vector<std::int64_t>({3, 1}));
         auto op = std::static_pointer_cast<OperatorTensor>(
             myUnsqueeze->getOperator());
         op->associateInput(0, input_T);
 
         auto axes_T =
-            std::make_shared<Aidge::Tensor>(Aidge::Array1D<int8_t, 2>({0, 3}));
+            std::make_shared<Aidge::Tensor>(Aidge::Array1D<int64_t, 2>({0, 3}));
         axes_T->setDataType(Aidge::DataType::Int8);
         axes_T->setBackend("cpu");
 
@@ -229,7 +229,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
       CHECK(op->getOutput(0)->dims() == dims_out);
 
       int nb_ones = std::count_if(dims_in.begin(), dims_in.end(),
-                                  [](std::int8_t dim) { return dim == 1; });
+                                  [](std::int64_t dim) { return dim == 1; });
       CHECK((op->getInput(0)->dims().size() -
              op->getOutput(0)->dims().size()) == nb_ones);
     }
@@ -239,7 +239,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
     for (uint16_t trial = 0; trial < NB_TRIALS; ++trial) {
       // Create the Operator
       size_t nb_dims_to_squeeze = nb_dims_to_squeeze_dist(gen);
-      std::vector<int8_t> dims_to_squeeze(nb_dims_to_squeeze);
+      std::vector<int64_t> dims_to_squeeze(nb_dims_to_squeeze);
       std::generate(dims_to_squeeze.begin(), dims_to_squeeze.end(),
                     [&gen, &idx_dims_to_squeeze_dist]() {
                       return idx_dims_to_squeeze_dist(gen);
@@ -262,7 +262,7 @@ TEST_CASE("[core/operator] Squeeze(forwardDims)", "[Squeeze][forwardDims]") {
       // rectifying indexes
       std::transform(dims_to_squeeze.begin(), dims_to_squeeze.end(),
                      dims_to_squeeze.begin(),
-                     [&nb_dims_tensor](int8_t dim_to_squeeze) {
+                     [&nb_dims_tensor](int64_t dim_to_squeeze) {
                        return dim_to_squeeze < 0
                                   ? dim_to_squeeze + nb_dims_tensor
                                   : dim_to_squeeze;
@@ -316,7 +316,7 @@ TEST_CASE("[core/operator] Squeeze(forward)", "[Squeeze][forward]") {
   auto random_seed = Catch::Generators::Detail::getSeed;
   std::mt19937 gen(random_seed());
 
-  constexpr int8_t max_nb_dims = 7;
+  constexpr int64_t max_nb_dims = 7;
   std::uniform_real_distribution<float> tensor_value_dist(0.1f, 1.1f);
   std::uniform_int_distribution<std::size_t> tensor_nb_dims_dist(
       std::size_t(1), std::size_t(max_nb_dims));
@@ -337,7 +337,7 @@ TEST_CASE("[core/operator] Squeeze(forward)", "[Squeeze][forward]") {
   for (uint16_t trial = 0; trial < NB_TRIALS; ++trial) {
     // Create the Operator
     size_t nb_dims_to_squeeze = nb_dims_to_squeeze_dist(gen);
-    std::vector<int8_t> dims_to_squeeze(nb_dims_to_squeeze);
+    std::vector<int64_t> dims_to_squeeze(nb_dims_to_squeeze);
     std::generate(dims_to_squeeze.begin(), dims_to_squeeze.end(),
                   [&gen, &idx_dims_to_squeeze_dist]() {
                     return idx_dims_to_squeeze_dist(gen);
@@ -361,7 +361,7 @@ TEST_CASE("[core/operator] Squeeze(forward)", "[Squeeze][forward]") {
     // rectifying indexes
     std::transform(dims_to_squeeze.begin(), dims_to_squeeze.end(),
                    dims_to_squeeze.begin(),
-                   [&nb_dims_tensor](int8_t dim_to_squeeze) {
+                   [&nb_dims_tensor](int64_t dim_to_squeeze) {
                      return dim_to_squeeze < 0 ? dim_to_squeeze + nb_dims_tensor
                                                : dim_to_squeeze;
                    });