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

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright 2018 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/FloorMod.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 class FloorModTest : public ::testing::Test
  32 {
  33 protected:
  34   void SetUp() override { _memory_manager = std::make_unique<TestMemoryManager>(); }
  35
  36   std::unique_ptr<IMemoryManager> _memory_manager;
  37 };
  38
  39 TEST_F(FloorModTest, Simple)
  40 {
  41   Shape input1_shape{1, 2, 2, 1};
  42   std::vector<int32_t> input1_data{10, 9, 11, 3};
  43
  44   Shape input2_shape = input1_shape;
  45   std::vector<int32_t> input2_data{2, 2, 3, 4};
  46
  47   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
  48   std::vector<int32_t> ref_output_data{0, 1, 2, 3};
  49
  50   Tensor input1_tensor =
  51     makeInputTensor<DataType::S32>(input1_shape, input1_data, _memory_manager.get());
  52   Tensor input2_tensor =
  53     makeInputTensor<DataType::S32>(input2_shape, input2_data, _memory_manager.get());
  54   Tensor output_tensor = makeOutputTensor(DataType::S32);
  55
  56   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
  57   kernel.configure();
  58   _memory_manager->allocate_memory(output_tensor);
  59   kernel.execute();
  60
  61   EXPECT_THAT(extractTensorData<int32_t>(output_tensor),
  62               ::testing::ElementsAreArray(ref_output_data));
  63   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
  64 }
  65
  66 TEST_F(FloorModTest, NegativeValue)
  67 {
  68   Shape input1_shape{1, 2, 2, 1};
  69   std::vector<int32_t> input1_data{10, -9, -11, 7};
  70
  71   Shape input2_shape = input1_shape;
  72   std::vector<int32_t> input2_data{2, 2, -3, -4};
  73
  74   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
  75   std::vector<int32_t> ref_output_data{0, 1, -2, -1};
  76
  77   Tensor input1_tensor =
  78     makeInputTensor<DataType::S32>(input1_shape, input1_data, _memory_manager.get());
  79   Tensor input2_tensor =
  80     makeInputTensor<DataType::S32>(input2_shape, input2_data, _memory_manager.get());
  81   Tensor output_tensor = makeOutputTensor(DataType::S32);
  82
  83   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
  84   kernel.configure();
  85   _memory_manager->allocate_memory(output_tensor);
  86   kernel.execute();
  87
  88   EXPECT_THAT(extractTensorData<int32_t>(output_tensor),
  89               ::testing::ElementsAreArray(ref_output_data));
  90   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
  91 }
  92
  93 TEST_F(FloorModTest, BroadcastFloorMod)
  94 {
  95   Shape input1_shape{1, 2, 2, 1};
  96   std::vector<int32_t> input1_data{
  97     10,
  98     -9,
  99     -11,
 100     7,
 101   };
 102
 103   Shape input2_shape{1};
 104   std::vector<int32_t> input2_data{-3};
 105
 106   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 107   std::vector<int32_t> ref_output_data{-2, 0, -2, -2};
 108
 109   Tensor input1_tensor =
 110     makeInputTensor<DataType::S32>(input1_shape, input1_data, _memory_manager.get());
 111   Tensor input2_tensor =
 112     makeInputTensor<DataType::S32>(input2_shape, input2_data, _memory_manager.get());
 113   Tensor output_tensor = makeOutputTensor(DataType::S32);
 114
 115   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 116   kernel.configure();
 117   _memory_manager->allocate_memory(output_tensor);
 118   kernel.execute();
 119
 120   EXPECT_THAT(extractTensorData<int32_t>(output_tensor),
 121               ::testing::ElementsAreArray(ref_output_data));
 122   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 123 }
 124
 125 TEST_F(FloorModTest, Int64WithBroadcast)
 126 {
 127   Shape input1_shape{1, 2, 2, 1};
 128   std::vector<int64_t> input1_data{10, -9, -11, (1LL << 34) + 9};
 129
 130   Shape input2_shape{1};
 131   std::vector<int64_t> input2_data{-(1LL << 33)};
 132
 133   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 134   std::vector<int64_t> ref_output_data{-8589934582, -9, -11, -8589934583};
 135
 136   Tensor input1_tensor =
 137     makeInputTensor<DataType::S64>(input1_shape, input1_data, _memory_manager.get());
 138   Tensor input2_tensor =
 139     makeInputTensor<DataType::S64>(input2_shape, input2_data, _memory_manager.get());
 140   Tensor output_tensor = makeOutputTensor(DataType::S64);
 141
 142   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 143   kernel.configure();
 144   _memory_manager->allocate_memory(output_tensor);
 145   kernel.execute();
 146
 147   EXPECT_THAT(extractTensorData<int64_t>(output_tensor),
 148               ::testing::ElementsAreArray(ref_output_data));
 149   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 150 }
 151
 152 TEST_F(FloorModTest, FloatSimple)
 153 {
 154   Shape input1_shape{1, 2, 2, 1};
 155   std::vector<float> input1_data{10.0, 9.0, 11.0, 3.0};
 156
 157   Shape input2_shape = input1_shape;
 158   std::vector<float> input2_data{2.0, 2.0, 3.0, 4.0};
 159
 160   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 161   std::vector<float> ref_output_data{0.0, 1.0, 2.0, 3.0};
 162
 163   Tensor input1_tensor =
 164     makeInputTensor<DataType::FLOAT32>(input1_shape, input1_data, _memory_manager.get());
 165   Tensor input2_tensor =
 166     makeInputTensor<DataType::FLOAT32>(input2_shape, input2_data, _memory_manager.get());
 167   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 168
 169   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 170   kernel.configure();
 171   _memory_manager->allocate_memory(output_tensor);
 172   kernel.execute();
 173
 174   EXPECT_THAT(extractTensorData<float>(output_tensor),
 175               ::testing::ElementsAreArray(ref_output_data));
 176   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 177 }
 178
 179 TEST_F(FloorModTest, FloatNegativeValue)
 180 {
 181   Shape input1_shape{1, 2, 2, 1};
 182   std::vector<float> input1_data{10.0, -9.0, -11.0, 7.0};
 183
 184   Shape input2_shape = input1_shape;
 185   std::vector<float> input2_data{2.0, 2.0, -3.0, -4.0};
 186
 187   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 188   std::vector<float> ref_output_data{0.0, 1.0, -2.0, -1.0};
 189
 190   Tensor input1_tensor =
 191     makeInputTensor<DataType::FLOAT32>(input1_shape, input1_data, _memory_manager.get());
 192   Tensor input2_tensor =
 193     makeInputTensor<DataType::FLOAT32>(input2_shape, input2_data, _memory_manager.get());
 194   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 195
 196   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 197   kernel.configure();
 198   _memory_manager->allocate_memory(output_tensor);
 199   kernel.execute();
 200
 201   EXPECT_THAT(extractTensorData<float>(output_tensor),
 202               ::testing::ElementsAreArray(ref_output_data));
 203   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 204 }
 205
 206 TEST_F(FloorModTest, FloatBroadcast)
 207 {
 208   Shape input1_shape{1, 2, 2, 1};
 209   std::vector<float> input1_data{
 210     10.0,
 211     -9.0,
 212     -11.0,
 213     7.0,
 214   };
 215
 216   Shape input2_shape{1};
 217   std::vector<float> input2_data{-3.0};
 218
 219   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 220   std::vector<float> ref_output_data{-2.0, 0.0, -2.0, -2.0};
 221
 222   Tensor input1_tensor =
 223     makeInputTensor<DataType::FLOAT32>(input1_shape, input1_data, _memory_manager.get());
 224   Tensor input2_tensor =
 225     makeInputTensor<DataType::FLOAT32>(input2_shape, input2_data, _memory_manager.get());
 226   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 227
 228   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 229   kernel.configure();
 230   _memory_manager->allocate_memory(output_tensor);
 231   kernel.execute();
 232
 233   EXPECT_THAT(extractTensorData<float>(output_tensor),
 234               ::testing::ElementsAreArray(ref_output_data));
 235   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 236 }
 237
 238 TEST_F(FloorModTest, SimpleInt16)
 239 {
 240   Shape input1_shape{1, 2, 2, 1};
 241   std::vector<int16_t> input1_data{10, 9, 11, 3};
 242
 243   Shape input2_shape = input1_shape;
 244   std::vector<int16_t> input2_data{2, 2, 3, 4};
 245
 246   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 247   std::vector<int16_t> ref_output_data{0, 1, 2, 3};
 248
 249   Tensor input1_tensor =
 250     makeInputTensor<DataType::S16>(input1_shape, input1_data, _memory_manager.get());
 251   Tensor input2_tensor =
 252     makeInputTensor<DataType::S16>(input2_shape, input2_data, _memory_manager.get());
 253   Tensor output_tensor = makeOutputTensor(DataType::S16);
 254
 255   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 256   kernel.configure();
 257   _memory_manager->allocate_memory(output_tensor);
 258   kernel.execute();
 259
 260   EXPECT_THAT(extractTensorData<int16_t>(output_tensor),
 261               ::testing::ElementsAreArray(ref_output_data));
 262   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 263 }
 264
 265 TEST_F(FloorModTest, NegativeValueInt16)
 266 {
 267   Shape input1_shape{1, 2, 2, 1};
 268   std::vector<int16_t> input1_data{110, -9, -11, 7};
 269
 270   Shape input2_shape = input1_shape;
 271   std::vector<int16_t> input2_data{2, 2, -3, -4};
 272
 273   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 274   std::vector<int16_t> ref_output_data{0, 1, -2, -1};
 275
 276   Tensor input1_tensor =
 277     makeInputTensor<DataType::S16>(input1_shape, input1_data, _memory_manager.get());
 278   Tensor input2_tensor =
 279     makeInputTensor<DataType::S16>(input2_shape, input2_data, _memory_manager.get());
 280   Tensor output_tensor = makeOutputTensor(DataType::S16);
 281
 282   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 283   kernel.configure();
 284   _memory_manager->allocate_memory(output_tensor);
 285   kernel.execute();
 286
 287   EXPECT_THAT(extractTensorData<int16_t>(output_tensor),
 288               ::testing::ElementsAreArray(ref_output_data));
 289   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 290 }
 291
 292 TEST_F(FloorModTest, BroadcastFloorModInt16)
 293 {
 294   Shape input1_shape{1, 2, 2, 1};
 295   std::vector<int16_t> input1_data{10, -9, -11, 7};
 296
 297   Shape input2_shape{1};
 298   std::vector<int16_t> input2_data{-3};
 299
 300   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 301   std::vector<int16_t> ref_output_data{-2, 0, -2, -2};
 302
 303   Tensor input1_tensor =
 304     makeInputTensor<DataType::S16>(input1_shape, input1_data, _memory_manager.get());
 305   Tensor input2_tensor =
 306     makeInputTensor<DataType::S16>(input2_shape, input2_data, _memory_manager.get());
 307   Tensor output_tensor = makeOutputTensor(DataType::S16);
 308
 309   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 310   kernel.configure();
 311   _memory_manager->allocate_memory(output_tensor);
 312   kernel.execute();
 313
 314   EXPECT_THAT(extractTensorData<int16_t>(output_tensor),
 315               ::testing::ElementsAreArray(ref_output_data));
 316   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 317 }
 318
 319 TEST_F(FloorModTest, DivByZero_NEG)
 320 {
 321   Shape shape{3};
 322   std::vector<int32_t> input1_data{1, 0, -1};
 323   std::vector<int32_t> input2_data{0, 0, 0};
 324
 325   Tensor input1_tensor = makeInputTensor<DataType::S32>(shape, input1_data, _memory_manager.get());
 326   Tensor input2_tensor = makeInputTensor<DataType::S32>(shape, input2_data, _memory_manager.get());
 327   Tensor output_tensor = makeOutputTensor(DataType::S32);
 328
 329   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 330   kernel.configure();
 331   _memory_manager->allocate_memory(output_tensor);
 332
 333   EXPECT_ANY_THROW(kernel.execute());
 334 }
 335
 336 TEST_F(FloorModTest, Int64DivByZero_NEG)
 337 {
 338   Shape shape{3};
 339   std::vector<int64_t> input1_data{1, 0, -1};
 340   std::vector<int64_t> input2_data{0, 0, 0};
 341
 342   Tensor input1_tensor = makeInputTensor<DataType::S64>(shape, input1_data, _memory_manager.get());
 343   Tensor input2_tensor = makeInputTensor<DataType::S64>(shape, input2_data, _memory_manager.get());
 344   Tensor output_tensor = makeOutputTensor(DataType::S64);
 345
 346   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 347   kernel.configure();
 348   _memory_manager->allocate_memory(output_tensor);
 349
 350   EXPECT_ANY_THROW(kernel.execute());
 351 }
 352
 353 TEST_F(FloorModTest, Int16DivByZero_NEG)
 354 {
 355   Shape shape{3};
 356   std::vector<int16_t> input1_data{1, 0, -1};
 357   std::vector<int16_t> input2_data{0, 0, 0};
 358
 359   Tensor input1_tensor = makeInputTensor<DataType::S16>(shape, input1_data, _memory_manager.get());
 360   Tensor input2_tensor = makeInputTensor<DataType::S16>(shape, input2_data, _memory_manager.get());
 361   Tensor output_tensor = makeOutputTensor(DataType::S16);
 362
 363   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 364   kernel.configure();
 365   _memory_manager->allocate_memory(output_tensor);
 366
 367   EXPECT_ANY_THROW(kernel.execute());
 368 }
 369
 370 TEST_F(FloorModTest, Input_Output_Type_Mismatch_NEG)
 371 {
 372   Tensor input1_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 373   Tensor input2_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 374   Tensor output_tensor = makeOutputTensor(DataType::S8);
 375
 376   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 377   EXPECT_ANY_THROW(kernel.configure());
 378 }
 379
 380 TEST_F(FloorModTest, Input_Type_Mismatch_NEG)
 381 {
 382   Tensor input1_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1}, _memory_manager.get());
 383   Tensor input2_tensor = makeInputTensor<DataType::S8>({1}, {1}, _memory_manager.get());
 384   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 385
 386   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 387   EXPECT_ANY_THROW(kernel.configure());
 388 }
 389
 390 TEST_F(FloorModTest, Float_Broadcast_NEG)
 391 {
 392   Tensor input1_tensor = makeInputTensor<DataType::FLOAT32>({2}, {1.f, 2.f}, _memory_manager.get());
 393   Tensor input2_tensor =
 394     makeInputTensor<DataType::FLOAT32>({3}, {1.f, 2.f, 3.f}, _memory_manager.get());
 395   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 396
 397   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 398   ASSERT_ANY_THROW(kernel.configure());
 399 }
 400
 401 TEST_F(FloorModTest, Int64_Broadcast_NEG)
 402 {
 403   Tensor input1_tensor = makeInputTensor<DataType::S64>({2}, {1, 2}, _memory_manager.get());
 404   Tensor input2_tensor = makeInputTensor<DataType::S64>({3}, {1, 2, 3}, _memory_manager.get());
 405   Tensor output_tensor = makeOutputTensor(DataType::S64);
 406
 407   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 408   ASSERT_ANY_THROW(kernel.configure());
 409 }
 410
 411 TEST_F(FloorModTest, Int32_Broadcast_NEG)
 412 {
 413   Tensor input1_tensor = makeInputTensor<DataType::S32>({2}, {1, 2}, _memory_manager.get());
 414   Tensor input2_tensor = makeInputTensor<DataType::S32>({3}, {1, 2, 3}, _memory_manager.get());
 415   Tensor output_tensor = makeOutputTensor(DataType::S32);
 416
 417   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 418   ASSERT_ANY_THROW(kernel.configure());
 419 }
 420
 421 TEST_F(FloorModTest, Int16_Broadcast_NEG)
 422 {
 423   Tensor input1_tensor = makeInputTensor<DataType::S16>({2}, {1, 2}, _memory_manager.get());
 424   Tensor input2_tensor = makeInputTensor<DataType::S16>({3}, {1, 2, 3}, _memory_manager.get());
 425   Tensor output_tensor = makeOutputTensor(DataType::S16);
 426
 427   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 428   ASSERT_ANY_THROW(kernel.configure());
 429 }
 430
 431 TEST_F(FloorModTest, UnsupportedType_NEG)
 432 {
 433   Tensor input1_tensor = makeInputTensor<DataType::U8>({1}, {1}, _memory_manager.get());
 434   Tensor input2_tensor = makeInputTensor<DataType::U8>({1}, {1}, _memory_manager.get());
 435   Tensor output_tensor = makeOutputTensor(DataType::U8);
 436
 437   FloorMod kernel(&input1_tensor, &input2_tensor, &output_tensor);
 438   kernel.configure();
 439
 440   _memory_manager->allocate_memory(output_tensor);
 441   ASSERT_ANY_THROW(kernel.execute());
 442 }
 443
 444 } // namespace
 445 } // namespace kernels
 446 } // namespace luci_interpreter