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

   1 /*
   2  * Copyright (c) 2020 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/Pow.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 class PowTest : public ::testing::Test
  31 {
  32 protected:
  33   void SetUp() override { _memory_manager = std::make_unique<TestMemoryManager>(); }
  34
  35   std::unique_ptr<IMemoryManager> _memory_manager;
  36 };
  37
  38 TEST_F(PowTest, SimplePow)
  39 {
  40   std::initializer_list<int32_t> base_shape = {1, 1, 3, 2};
  41
  42   std::vector<float> input1_data{0.3f, 2.3f, 0.9f, 0.5f, 0.8f, 1.1f};
  43   std::vector<float> input2_data{0.2f, 0.3f, -0.4f, 0.5f, 1.0f, 0.9f};
  44   std::vector<float> test_outputs{0.786f, 1.2838f, 1.043f, 0.7071f, 0.8f, 1.08956f};
  45
  46   Tensor input1_tensor =
  47     makeInputTensor<DataType::FLOAT32>(base_shape, input1_data, _memory_manager.get());
  48   Tensor input2_tensor =
  49     makeInputTensor<DataType::FLOAT32>(base_shape, input2_data, _memory_manager.get());
  50   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  51
  52   Pow kernel(&input1_tensor, &input2_tensor, &output_tensor);
  53   kernel.configure();
  54   _memory_manager->allocate_memory(output_tensor);
  55   kernel.execute();
  56
  57   EXPECT_THAT(extractTensorData<float>(output_tensor), FloatArrayNear(test_outputs, 0.0001f));
  58   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(base_shape));
  59 }
  60
  61 TEST_F(PowTest, FloatBroadcastPow)
  62 {
  63   std::initializer_list<int32_t> input1_shape = {1, 3};
  64   std::initializer_list<int32_t> input2_shape = {3, 1};
  65
  66   std::vector<float> input1_data{0.3f, 2.3f, 0.9f};
  67   std::vector<float> input2_data{0.2f, 0.3f, 0.4f};
  68   std::vector<float> test_outputs{0.786f,   1.18126f, 0.9791f, 0.6968f, 1.28386f,
  69                                   0.96888f, 0.6178f,  1.3953f, 0.9587f};
  70
  71   Tensor input1_tensor =
  72     makeInputTensor<DataType::FLOAT32>(input1_shape, input1_data, _memory_manager.get());
  73   Tensor input2_tensor =
  74     makeInputTensor<DataType::FLOAT32>(input2_shape, input2_data, _memory_manager.get());
  75   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  76
  77   Pow kernel(&input1_tensor, &input2_tensor, &output_tensor);
  78   kernel.configure();
  79   _memory_manager->allocate_memory(output_tensor);
  80   kernel.execute();
  81
  82   EXPECT_THAT(extractTensorData<float>(output_tensor), FloatArrayNear(test_outputs, 0.0001f));
  83 }
  84
  85 TEST_F(PowTest, IntPow)
  86 {
  87   std::initializer_list<int32_t> base_shape = {1, 3};
  88
  89   std::vector<int32_t> input_data{2, 3, 4};
  90   std::vector<int32_t> test_outputs{4, 27, 256};
  91
  92   Tensor input1_tensor =
  93     makeInputTensor<DataType::S32>(base_shape, input_data, _memory_manager.get());
  94   Tensor input2_tensor =
  95     makeInputTensor<DataType::S32>(base_shape, input_data, _memory_manager.get());
  96   Tensor output_tensor = makeOutputTensor(DataType::S32);
  97
  98   Pow kernel(&input1_tensor, &input2_tensor, &output_tensor);
  99   kernel.configure();
 100   _memory_manager->allocate_memory(output_tensor);
 101   kernel.execute();
 102
 103   EXPECT_THAT(extractTensorData<int32_t>(output_tensor), ::testing::ElementsAreArray(test_outputs));
 104   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(base_shape));
 105 }
 106
 107 TEST_F(PowTest, Input_Output_Type_NEG)
 108 {
 109   Tensor input1_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.0f}, _memory_manager.get());
 110   Tensor input2_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.0f}, _memory_manager.get());
 111   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 112
 113   Pow kernel(&input1_tensor, &input2_tensor, &output_tensor);
 114   EXPECT_ANY_THROW(kernel.configure());
 115 }
 116
 117 TEST_F(PowTest, Input_Type_Mismatch_NEG)
 118 {
 119   Tensor input1_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.0f}, _memory_manager.get());
 120   Tensor input2_tensor = makeInputTensor<DataType::S32>({1}, {4}, _memory_manager.get());
 121   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 122
 123   Pow kernel(&input1_tensor, &input2_tensor, &output_tensor);
 124   EXPECT_ANY_THROW(kernel.configure());
 125 }
 126
 127 TEST_F(PowTest, Invalid_Input_Type_NEG)
 128 {
 129   Tensor input1_tensor = makeInputTensor<DataType::S64>({1}, {1}, _memory_manager.get());
 130   Tensor input2_tensor = makeInputTensor<DataType::S64>({1}, {1}, _memory_manager.get());
 131   Tensor output_tensor = makeOutputTensor(DataType::S64);
 132
 133   Pow kernel(&input1_tensor, &input2_tensor, &output_tensor);
 134   kernel.configure();
 135   EXPECT_ANY_THROW(kernel.execute());
 136 }
 137
 138 } // namespace
 139 } // namespace kernels
 140 } // namespace luci_interpreter