onert-micro/luci-interpreter/src/kernels/Sqrt.test.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright 2019 The TensorFlow Authors. All Rights Reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *    http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include "kernels/Sqrt.h"
  19 #include "kernels/TestUtils.h"
  20 #include "luci_interpreter/TestMemoryManager.h"
  21
  22 namespace luci_interpreter
  23 {
  24 namespace kernels
  25 {
  26 namespace
  27 {
  28
  29 using namespace testing;
  30
  31 void Check(std::initializer_list<int32_t> input_shape, std::initializer_list<int32_t> output_shape,
  32            std::initializer_list<float> input_data, std::initializer_list<float> output_data)
  33 {
  34   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  35
  36   Tensor input_tensor =
  37     makeInputTensor<DataType::FLOAT32>(input_shape, input_data, memory_manager.get());
  38   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  39
  40   Sqrt kernel(&input_tensor, &output_tensor);
  41   kernel.configure();
  42   memory_manager->allocate_memory(output_tensor);
  43   kernel.execute();
  44
  45   EXPECT_THAT(extractTensorData<float>(output_tensor), FloatArrayNear(output_data));
  46   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(output_shape));
  47 }
  48
  49 TEST(SqrtTest, SimpleSqrt)
  50 {
  51   Check(
  52     /*input_shape=*/{1, 2, 4, 1}, /*output_shape=*/{1, 2, 4, 1},
  53     /*input_data=*/
  54     {
  55       0, 8, 2, 4,    //
  56       3, 7, 10, 0.3, //
  57     },
  58     /*output_data=*/
  59     {
  60       0.0, 2.8284271, 1.4142136, 2,                //
  61       1.7320508, 2.6457513, 3.1622777, 0.54772256, //
  62     });
  63 }
  64
  65 TEST(SqrtTest, Input_Output_Type_NEG)
  66 {
  67   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  68
  69   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, memory_manager.get());
  70   Tensor output_tensor = makeOutputTensor(DataType::S32);
  71
  72   Sqrt kernel(&input_tensor, &output_tensor);
  73   EXPECT_ANY_THROW(kernel.configure());
  74 }
  75
  76 TEST(SqrtTest, Invalid_Input_Type_NEG)
  77 {
  78   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  79
  80   Tensor input_tensor = makeInputTensor<DataType::S64>({1}, {1}, memory_manager.get());
  81   Tensor output_tensor = makeOutputTensor(DataType::S64);
  82
  83   Sqrt kernel(&input_tensor, &output_tensor);
  84   kernel.configure();
  85   memory_manager->allocate_memory(output_tensor);
  86   EXPECT_ANY_THROW(kernel.execute());
  87 }
  88
  89 } // namespace
  90 } // namespace kernels
  91 } // namespace luci_interpreter