conv fc tests

Author: Semyon1104

test/single_layer/test_convlayer.cpp

@@ -992,4 +992,45 @@ TEST(ConvolutionalLayerTest, ConvImplInt2DKernelComplexPattern) {
   for (size_t i = 0; i < result.size(); ++i) {
     ASSERT_GT(result[i], 0);
   }
+}
+
+TEST(ConvolutionalLayerTest, Float2DKernelPathCoverage) {
+  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 = {1.0f, 0.0f, 1.0f, 0.0f};
+  Shape kernel_shape({2, 2});
+  Tensor kernel = make_tensor(kernelvec, kernel_shape);
+
+  std::vector<float> output_vec(1, 0.0f);
+  Tensor output = make_tensor(output_vec, Shape({1, 1, 1, 1}));
+
+  ConvolutionalLayer layer(1, 0, 0, kernel);
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::exception);
+}
+
+TEST(ConvolutionalLayerTest, Float4DKernelWorking) {
+  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 = {1.0f, 0.0f, 1.0f, 0.0f};
+  Shape kernel_shape({1, 1, 2, 2});
+  Tensor kernel = make_tensor(kernelvec, kernel_shape);
+
+  std::vector<float> output_vec(1, 0.0f);
+  Tensor output = make_tensor(output_vec, Shape({1, 1, 1, 1}));
+
+  ConvolutionalLayer layer(1, 0, 0, kernel);
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_NO_THROW(layer.run(in, out));
+
+  std::vector<float> result = *out[0].as<float>();
+  ASSERT_EQ(result.size(), 4);
 }

test/single_layer/test_fclayer.cpp

@@ -249,3 +249,86 @@ TEST(fclayer, new_fc_bias_and_weights_not_same) {
   std::vector<Tensor> out{output};
   EXPECT_THROW(layer.run(in, out), std::invalid_argument);
 }
+TEST(fclayer, VectorSizeNotDivisibleByMatrixRows) {
+  std::vector<float> weightsvec = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
+  Shape weights_shape({3, 2});
+  Tensor weights = make_tensor(weightsvec, weights_shape);
+
+  std::vector<float> biasvec = {0.1f, 0.2f};
+  Tensor bias = make_tensor(biasvec, Shape({2}));
+
+  std::vector<float> input_vec = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+  Tensor input = make_tensor(input_vec, Shape({5}));
+
+  std::vector<float> output_vec(4, 0.0f);
+  Tensor output = make_tensor(output_vec, Shape({2, 2}));
+
+  FCLayer layer(weights, bias);
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::invalid_argument);
+}
+
+TEST(fclayer, VectorSizeNotDivisibleByMatrixRowsInt) {
+  std::vector<int> weightsvec = {1, 2, 3, 4, 5, 6, 7, 8};
+  Shape weights_shape({4, 2});
+  Tensor weights = make_tensor(weightsvec, weights_shape);
+
+  std::vector<int> biasvec = {1, 2};
+  Tensor bias = make_tensor(biasvec, Shape({2}));
+
+  std::vector<int> input_vec = {1, 2, 3, 4, 5, 6, 7};
+  Tensor input = make_tensor(input_vec, Shape({7}));
+
+  std::vector<int> output_vec(4, 0);
+  Tensor output = make_tensor(output_vec, Shape({2, 2}));
+
+  FCLayer layer(weights, bias);
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::invalid_argument);
+}
+
+TEST(fclayer, VectorSizeDivisibleByMatrixRows) {
+  std::vector<float> weightsvec = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
+  Shape weights_shape({3, 2});
+  Tensor weights = make_tensor(weightsvec, weights_shape);
+
+  std::vector<float> biasvec = {0.1f, 0.2f};
+  Tensor bias = make_tensor(biasvec, Shape({2}));
+
+  std::vector<float> input_vec = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
+  Tensor input = make_tensor(input_vec, Shape({6}));
+
+  std::vector<float> output_vec(4, 0.0f);
+  Tensor output = make_tensor(output_vec, Shape({2, 2}));
+
+  FCLayer layer(weights, bias);
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_NO_THROW(layer.run(in, out));
+}
+
+TEST(fclayer, ZeroOutputNeuronsWithNonZeroInput) {
+  std::vector<float> weightsvec = {};
+  Shape weights_shape({5, 0});
+  Tensor weights = make_tensor(weightsvec, weights_shape);
+
+  std::vector<float> biasvec = {};
+  Tensor bias = make_tensor(biasvec, Shape({0}));
+
+  std::vector<float> input_vec = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+  Tensor input = make_tensor(input_vec, Shape({5}));
+
+  std::vector<float> output_vec = {};
+  Tensor output = make_tensor(output_vec, Shape({0}));
+
+  FCLayer layer(weights, bias);
+  std::vector<Tensor> in{input};
+  std::vector<Tensor> out{output};
+
+  EXPECT_THROW(layer.run(in, out), std::invalid_argument);
+}