add conv and flatten tests

Author: Semyon1104

test/single_layer/test_convlayer.cpp

@@ -607,3 +607,123 @@ TEST(ConvolutionalLayerTest, Conv4DSTLViaConvolutionalLayer) {
     ASSERT_NEAR(result[i], expected_value, 1e-5f);
   }
 }
+
+TEST(ConvolutionalLayerTest, Conv4DLegacyFloatBasic) {
+  std::vector<float> image(48, 1.0f);
+  Shape input_shape({1, 3, 4, 4});
+  Tensor input = make_tensor(image, input_shape);
+
+  std::vector<float> kernelvec(54, 1.0f);
+  Shape kernel_shape({3, 3, 3, 2});
+  Tensor kernel = make_tensor(kernelvec, kernel_shape);
+
+  std::vector<float> biasvec = {0.5f, 1.0f};
+  Tensor bias = make_tensor(biasvec, Shape({2}));
+
+  size_t out_height = (4 + 2 * 0 - 1 * (3 - 1) - 1) / 1 + 1;
+  size_t out_width = (4 + 2 * 0 - 1 * (3 - 1) - 1) / 1 + 1;
+  Shape output_shape({1, 2, out_height, out_width});
+  std::vector<float> output_vec(8, 0.0f);
+  Tensor output = make_tensor(output_vec, output_shape);
+
+  Conv4D_Legacy<float>(input, kernel, bias, output, 1, 0, 1);
+
+  std::vector<float> result = *output.as<float>();
+
+  float expected_value_ch1 = 27.0f + 0.5f;
+  float expected_value_ch2 = 27.0f + 1.0f;
+
+  ASSERT_EQ(result.size(), 8);
+  ASSERT_NEAR(result[0], expected_value_ch1, 1e-5f);
+  ASSERT_NEAR(result[1], expected_value_ch1, 1e-5f);
+  ASSERT_NEAR(result[4], expected_value_ch2, 1e-5f);
+  ASSERT_NEAR(result[5], expected_value_ch2, 1e-5f);
+}
+
+TEST(ConvolutionalLayerTest, Conv4DLegacyFloatMultiOutput) {
+  std::vector<float> image(32, 1.0f);
+  Shape input_shape({1, 2, 4, 4});
+  Tensor input = make_tensor(image, input_shape);
+
+  std::vector<float> kernelvec(72, 0.5f);
+  Shape kernel_shape({3, 3, 2, 4});
+  Tensor kernel = make_tensor(kernelvec, kernel_shape);
+
+  std::vector<float> biasvec = {0.1f, 0.2f, 0.3f, 0.4f};
+  Tensor bias = make_tensor(biasvec, Shape({4}));
+
+  size_t out_height = (4 + 2 * 0 - 1 * (3 - 1) - 1) / 1 + 1;
+  size_t out_width = (4 + 2 * 0 - 1 * (3 - 1) - 1) / 1 + 1;
+  Shape output_shape({1, 4, out_height, out_width});
+  std::vector<float> output_vec(16, 0.0f);
+  Tensor output = make_tensor(output_vec, output_shape);
+
+  Conv4D_Legacy<float>(input, kernel, bias, output, 1, 0, 1);
+
+  std::vector<float> result = *output.as<float>();
+
+  ASSERT_EQ(result.size(), 16);
+  ASSERT_NEAR(result[0], 9.0f + 0.1f, 1e-5f);
+  ASSERT_NEAR(result[4], 9.0f + 0.2f, 1e-5f);
+  ASSERT_NEAR(result[8], 9.0f + 0.3f, 1e-5f);
+  ASSERT_NEAR(result[12], 9.0f + 0.4f, 1e-5f);
+}
+
+TEST(ConvolutionalLayerTest, Conv4DLegacyViaConvolutionalLayer) {
+  std::vector<float> image(48, 1.0f);
+  Shape input_shape({1, 3, 4, 4});
+  Tensor input = make_tensor(image, input_shape);
+
+  std::vector<float> kernelvec(54, 1.0f);
+  Shape kernel_shape({3, 3, 3, 2});
+  Tensor kernel = make_tensor(kernelvec, kernel_shape);
+
+  size_t out_height = (4 + 2 * 0 - 1 * (3 - 1) - 1) / 1 + 1;
+  size_t out_width = (4 + 2 * 0 - 1 * (3 - 1) - 1) / 1 + 1;
+  Shape output_shape({1, 2, out_height, out_width});
+  std::vector<float> output_vec(8, 0.0f);
+  Tensor output = make_tensor(output_vec, output_shape);
+
+  ConvolutionalLayer layer(1, 0, 1, kernel, Tensor(), kDefault, 1, true);
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  layer.run(in, out);
+
+  std::vector<float> result = *out[0].as<float>();
+
+  ASSERT_EQ(result.size(), 8);
+  float expected_value = 27.0f;
+  for (size_t i = 0; i < result.size(); ++i) {
+    ASSERT_NEAR(result[i], expected_value, 1e-5f);
+  }
+}
+
+TEST(ConvolutionalLayerTest, Conv4DLegacyFloatEdgeCase) {
+  std::vector<float> image = {1.0f, 2.0f, 3.0f, 4.0f};
+  Shape input_shape({1, 1, 2, 2});
+  Tensor input = make_tensor(image, input_shape);
+
+  std::vector<float> kernelvec = {0.5f};
+  Shape kernel_shape({1, 1, 1, 1});
+  Tensor kernel = make_tensor(kernelvec, kernel_shape);
+
+  std::vector<float> biasvec = {1.0f};
+  Tensor bias = make_tensor(biasvec, Shape({1}));
+
+  size_t out_height = (2 + 2 * 0 - 1 * (1 - 1) - 1) / 1 + 1;
+  size_t out_width = (2 + 2 * 0 - 1 * (1 - 1) - 1) / 1 + 1;
+  Shape output_shape({1, 1, out_height, out_width});
+  std::vector<float> output_vec(4, 0.0f);
+  Tensor output = make_tensor(output_vec, output_shape);
+
+  Conv4D_Legacy<float>(input, kernel, bias, output, 1, 0, 1);
+
+  std::vector<float> result = *output.as<float>();
+
+  ASSERT_EQ(result.size(), 4);
+  ASSERT_NEAR(result[0], 1.0f * 0.5f + 1.0f, 1e-5f);
+  ASSERT_NEAR(result[1], 2.0f * 0.5f + 1.0f, 1e-5f);
+  ASSERT_NEAR(result[2], 3.0f * 0.5f + 1.0f, 1e-5f);
+  ASSERT_NEAR(result[3], 4.0f * 0.5f + 1.0f, 1e-5f);
+}

test/single_layer/test_flattenlayer.cpp

@@ -183,3 +183,89 @@ TEST(flattenlayer, new_flattenlayer_can_flatten_int_reorder) {
 TEST(flattenlayer, get_layer_name) {
   EXPECT_EQ(FlattenLayer::get_name(), "Flatten layer");
 }
+
+TEST(flattenlayer, MultipleInputTensorsThrowsError) {
+  FlattenLayer layer;
+  Shape sh({2, 3});
+  Tensor input1 =
+      make_tensor<float>({1.0F, -1.0F, 2.0F, -2.0F, 3.0F, -3.0F}, sh);
+  Tensor input2 =
+      make_tensor<float>({1.0F, -1.0F, 2.0F, -2.0F, 3.0F, -3.0F}, sh);
+  Tensor output;
+  std::vector<Tensor> in{input1, input2};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::runtime_error);
+}
+
+TEST(flattenlayer, InvalidAxisValueThrowsError) {
+  FlattenLayer layer(5);
+  Shape sh({2, 3});
+  Tensor input =
+      make_tensor<float>({1.0F, -1.0F, 2.0F, -2.0F, 3.0F, -3.0F}, sh);
+  Tensor output;
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::runtime_error);
+}
+
+TEST(flattenlayer, NegativeAxisOutOfRangeThrowsError) {
+  FlattenLayer layer(-5);
+  Shape sh({2, 3});
+  Tensor input =
+      make_tensor<float>({1.0F, -1.0F, 2.0F, -2.0F, 3.0F, -3.0F}, sh);
+  Tensor output;
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::runtime_error);
+}
+
+TEST(flattenlayer, AxisEqualToShapeDimsThrowsError) {
+  FlattenLayer layer(2);
+  Shape sh({2, 3});
+  Tensor input =
+      make_tensor<float>({1.0F, -1.0F, 2.0F, -2.0F, 3.0F, -3.0F}, sh);
+  Tensor output;
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::runtime_error);
+}
+
+TEST(flattenlayer, ValidAxisWithSupportedTypes) {
+  std::vector<int> axis_values = {0, 1, -1, -2};
+
+  for (int axis : axis_values) {
+    FlattenLayer layer(axis);
+    Shape sh({2, 3, 4});
+    size_t total_size = sh.count();
+
+    std::vector<float> float_data(total_size);
+    std::vector<int> int_data(total_size);
+    for (size_t i = 0; i < total_size; i++) {
+      float_data[i] = static_cast<float>(i);
+      int_data[i] = static_cast<int>(i);
+    }
+
+    Tensor float_input = make_tensor<float>(float_data, sh);
+    Tensor int_input = make_tensor<int>(int_data, sh);
+    Tensor output;
+
+    std::vector<Tensor> float_in{float_input};
+    std::vector<Tensor> int_in{int_input};
+    std::vector<Tensor> out{output};
+
+    EXPECT_NO_THROW(layer.run(float_in, out));
+    EXPECT_NO_THROW(layer.run(int_in, out));
+  }
+}
+
+TEST(flattenlayer, EmptyInputThrowsError) {
+  FlattenLayer layer;
+  std::vector<Tensor> in;
+  std::vector<Tensor> out(1);
+
+  EXPECT_THROW(layer.run(in, out), std::runtime_error);
+}