compiler/luci-interpreter/src/kernels/Pack.test.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd. All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "kernels/Pack.h"
  18 #include "kernels/TestUtils.h"
  19 #include "luci_interpreter/TestMemoryManager.h"
  20
  21 namespace luci_interpreter
  22 {
  23 namespace kernels
  24 {
  25 namespace
  26 {
  27
  28 using namespace testing;
  29
  30 template <typename T>
  31 void Check(std::vector<std::initializer_list<int32_t>> input_shapes,
  32            std::initializer_list<int32_t> output_shape, std::vector<std::vector<T>> input_datas,
  33            std::initializer_list<T> output_data, int32_t axis)
  34 {
  35   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  36   constexpr DataType element_type = getElementType<T>();
  37   std::vector<const Tensor *> inputs(input_datas.size());
  38   std::vector<Tensor> tmp_inputs;
  39   for (int i = 0; i < input_datas.size(); i++)
  40   {
  41     if (std::is_same<T, float>::value)
  42     {
  43       tmp_inputs.push_back(Tensor(element_type, input_shapes[i], {}, ""));
  44       memory_manager->allocate_memory(tmp_inputs[i]);
  45       tmp_inputs[i].writeData(input_datas[i].data(), input_datas[i].size() * sizeof(T));
  46     }
  47     else
  48     {
  49       tmp_inputs.push_back(Tensor(element_type, input_shapes[i], {{1.0f / 255}, {128}}, ""));
  50       memory_manager->allocate_memory(tmp_inputs[i]);
  51       tmp_inputs[i].writeData(input_datas[i].data(), input_datas[i].size() * sizeof(T));
  52     }
  53   }
  54   for (int i = 0; i < input_datas.size(); i++)
  55   {
  56     inputs[i] = &tmp_inputs[i];
  57   }
  58
  59   Tensor output_tensor = makeOutputTensor(element_type);
  60   if (!std::is_same<T, float>::value)
  61   {
  62     output_tensor = makeOutputTensor(element_type, 1.0f / 255, 128);
  63   }
  64
  65   PackParams params{};
  66   params.axis = axis;
  67   params.values_count = input_datas.size();
  68   Pack kernel(inputs, &output_tensor, params);
  69
  70   kernel.configure();
  71   memory_manager->allocate_memory(output_tensor);
  72   kernel.execute();
  73
  74   EXPECT_THAT(extractTensorData<T>(output_tensor), ::testing::ElementsAreArray(output_data));
  75   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(output_shape));
  76 }
  77
  78 template <typename T> class PackTest : public ::testing::Test
  79 {
  80 };
  81
  82 using DataTypes = ::testing::Types<uint8_t, float>;
  83 TYPED_TEST_CASE(PackTest, DataTypes);
  84
  85 TYPED_TEST(PackTest, ThreeInputs)
  86 {
  87   Check<TypeParam>(/*input_shapes=*/{{2}, {2}, {2}},
  88                    /*output_shape=*/{3, 2},
  89                    /*input_datas=*/
  90                    {{1, 4}, {2, 5}, {3, 6}},
  91                    /*output_data=*/
  92                    {1, 4, 2, 5, 3, 6}, /*axis=*/0);
  93
  94   SUCCEED();
  95 }
  96
  97 TYPED_TEST(PackTest, NegAxis)
  98 {
  99   Check<TypeParam>(/*input_shapes=*/{{2}, {2}, {2}},
 100                    /*output_shape=*/{2, 3},
 101                    /*input_datas=*/
 102                    {{1, 4}, {2, 5}, {3, 6}},
 103                    /*output_data=*/
 104                    {1, 2, 3, 4, 5, 6}, /*axis=*/-1);
 105
 106   SUCCEED();
 107 }
 108
 109 TEST(Pack, MismatchingInputValuesCount_NEG)
 110 {
 111   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
 112   std::vector<float> input1_data{1, 4};
 113   std::vector<float> input2_data{2, 5};
 114   std::vector<float> input3_data{3, 6};
 115   Tensor input1_tensor = makeInputTensor<DataType::FLOAT32>({2}, input1_data, memory_manager.get());
 116   Tensor input2_tensor = makeInputTensor<DataType::FLOAT32>({2}, input2_data, memory_manager.get());
 117   Tensor input3_tensor = makeInputTensor<DataType::FLOAT32>({2}, input3_data, memory_manager.get());
 118   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 119   PackParams params{};
 120   {
 121     params.axis = 0;
 122     params.values_count = 2;
 123
 124     Pack kernel({&input1_tensor, &input2_tensor, &input3_tensor}, &output_tensor, params);
 125     EXPECT_ANY_THROW(kernel.configure());
 126   }
 127 }
 128
 129 TEST(Pack, InvalidInputAxis_NEG)
 130 {
 131   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
 132   std::vector<float> input1_data{1, 4};
 133   std::vector<float> input2_data{2, 5};
 134   std::vector<float> input3_data{3, 6};
 135   Tensor input1_tensor = makeInputTensor<DataType::FLOAT32>({2}, input1_data, memory_manager.get());
 136   Tensor input2_tensor = makeInputTensor<DataType::FLOAT32>({2}, input2_data, memory_manager.get());
 137   Tensor input3_tensor = makeInputTensor<DataType::FLOAT32>({2}, input3_data, memory_manager.get());
 138   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 139   PackParams params{};
 140   {
 141     params.axis = 2;
 142     params.values_count = 3;
 143
 144     Pack kernel({&input1_tensor, &input2_tensor, &input3_tensor}, &output_tensor, params);
 145     EXPECT_ANY_THROW(kernel.configure());
 146   }
 147 }
 148
 149 } // namespace
 150 } // namespace kernels
 151 } // namespace luci_interpreter