src/ml/ut/tensor_raw_data.cc

   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 "gmock/gmock.h"
  18 #include "gtest/gtest.h"
  19
  20 #include "ml/ml_tensors_data_manager.h"
  21 #include "ml/ml_tensors_info_manager.h"
  22
  23 #include "common/logger.h"
  24 #include "common/platform_result.h"
  25
  26 using testing::_;
  27
  28 using namespace extension::ml;
  29
  30 class MlTensorRawDataTest : public testing::Test {
  31  public:
  32   MlTensorRawDataTest() : tensors_info_manager_(&tensors_data_manager_) {
  33   }
  34   virtual void SetUp() override {
  35   }
  36
  37   virtual void TearDown() override {
  38   }
  39
  40   TensorsDataManager tensors_data_manager_;
  41   TensorsInfoManager tensors_info_manager_;
  42 };
  43
  44 TEST_F(MlTensorRawDataTest, GetTensorRawDataFull) {
  45   ScopeLogger("GetTensorRawDataFull");
  46   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
  47   unsigned int dim[] = {3, 2, 2, 1};
  48   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
  49   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
  50
  51   unsigned int location[] = {0, 0, 0, 0};
  52   TensorRawData raw_data;
  53   PlatformResult res = tensors_data->GetTensorRawData(0, location, dim, &raw_data);
  54   ASSERT_TRUE(res) << "GetTensorRawData failed";
  55
  56   unsigned int expected_dim[] = {3, 2, 2, 1};
  57   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
  58     EXPECT_EQ(raw_data.shape[i], expected_dim[i]) << "Invalid value on dim " << i;
  59   }
  60   size_t expected_size = 12;
  61   EXPECT_EQ(raw_data.size_in_bytes, expected_size);
  62   uint8_t expected_arr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  63   for (size_t i = 0; i < expected_size; i++) {
  64     EXPECT_EQ(raw_data.data[i], expected_arr[i]) << "Mismatch at pos " << i;
  65   }
  66 }
  67
  68 // Set:
  69 //  1,  2,  3
  70 //  4,  5,  6
  71 //
  72 //  7,  8,  9
  73 // 10, 11, 12
  74
  75 TEST_F(MlTensorRawDataTest, SetTensorRawDataFull) {
  76   ScopeLogger("SetTensorRawDataFull");
  77   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
  78   unsigned int dim[] = {3, 2, 2, 1};
  79   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
  80   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
  81
  82   unsigned int location[] = {0, 0, 0, 0};
  83   unsigned int size[] = {3, 2, 2, 1};
  84   uint8_t arr_in[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
  85   TensorRawData raw_data_set{arr_in, 12};
  86   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
  87   ASSERT_TRUE(res) << "SetTensorRawData failed";
  88
  89   TensorRawData raw_data_get;
  90   unsigned int location_get[] = {0, 0, 0, 0};
  91   res = tensors_data->GetTensorRawData(0, location_get, dim, &raw_data_get);
  92   ASSERT_TRUE(res) << "GetTensorRawData failed";
  93   unsigned int expected_dim[] = {3, 2, 2, 1};
  94
  95   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
  96     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value on dim " << i;
  97   }
  98   size_t expected_size = 12;
  99   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 100   uint8_t expected_arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 101   for (size_t i = 0; i < expected_size; i++) {
 102     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 103   }
 104 }
 105
 106 // Set:
 107 //  1,  2,  3
 108 //  4,  5,  6
 109 //
 110 //  0,  0,  0
 111 //  0,  0,  0
 112
 113 TEST_F(MlTensorRawDataTest, SetTensorRawData1) {
 114   ScopeLogger("SetTensorRawData1");
 115   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 116   unsigned int dim[] = {3, 2, 2, 1};
 117   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 118   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 119
 120   unsigned int location[] = {0, 0, 0, 0};
 121   unsigned int size[] = {3, 2, 1, 1};
 122   uint8_t arr_in[] = {1, 2, 3, 4, 5, 6};
 123   TensorRawData raw_data_set{arr_in, 6};
 124   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 125   ASSERT_TRUE(res) << "SetTensorRawData failed";
 126
 127   TensorRawData raw_data_get;
 128   unsigned int location_get[] = {0, 0, 0, 0};
 129   res = tensors_data->GetTensorRawData(0, location_get, dim, &raw_data_get);
 130
 131   ASSERT_TRUE(res) << "GetTensorRawData failed";
 132   unsigned int expected_dim[] = {3, 2, 2, 1};
 133
 134   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 135     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value on dim " << i;
 136   }
 137   size_t expected_size = 12;
 138   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 139   uint8_t expected_arr[] = {1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0};
 140   for (size_t i = 0; i < expected_size; i++) {
 141     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 142   }
 143 }
 144
 145 // Set:
 146 //  0,  0,  0
 147 //  0,  0,  0
 148 //
 149 //  1,  2,  3
 150 //  4,  5,  6
 151
 152 TEST_F(MlTensorRawDataTest, SetTensorRawData2) {
 153   ScopeLogger("SetTensorRawData2");
 154   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 155   unsigned int dim[] = {3, 2, 2, 1};
 156   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 157   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 158
 159   unsigned int location[] = {0, 0, 1, 0};
 160   unsigned int size[] = {3, 2, 1, 1};
 161   uint8_t arr_in[] = {1, 2, 3, 4, 5, 6};
 162   TensorRawData raw_data_set{arr_in, 6};
 163   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 164   ASSERT_TRUE(res) << "SetTensorRawData failed";
 165
 166   TensorRawData raw_data_get;
 167
 168   unsigned int location_get[] = {0, 0, 0, 0};
 169   res = tensors_data->GetTensorRawData(0, location_get, dim, &raw_data_get);
 170
 171   ASSERT_TRUE(res) << "GetTensorRawData failed";
 172   unsigned int expected_dim[] = {3, 2, 2, 1};
 173
 174   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 175     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value on dim " << i;
 176   }
 177   size_t expected_size = 12;
 178   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 179   uint8_t expected_arr[] = {0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6};
 180   for (size_t i = 0; i < expected_size; i++) {
 181     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 182   }
 183 }
 184
 185 // Set:
 186 //  0,  0,  0
 187 //  0,  1,  2
 188 //
 189 //  0,  0,  0
 190 //  0,  0,  0
 191
 192 TEST_F(MlTensorRawDataTest, SetTensorRawData3) {
 193   ScopeLogger("SetTensorRawData3");
 194   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 195   unsigned int dim[] = {3, 2, 2, 1};
 196   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 197   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 198
 199   unsigned int location[] = {1, 1, 0, 0};
 200   unsigned int size[] = {2, 1, 1, 1};
 201   uint8_t arr_in[] = {1, 2};
 202   TensorRawData raw_data_set{arr_in, 2};
 203   raw_data_set.data = arr_in;
 204   raw_data_set.size_in_bytes = 2;
 205   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 206   ASSERT_TRUE(res) << "SetTensorRawData failed";
 207
 208   TensorRawData raw_data_get;
 209   unsigned int location_get[] = {0, 0, 0, 0};
 210   res = tensors_data->GetTensorRawData(0, location_get, dim, &raw_data_get);
 211   ASSERT_TRUE(res) << "GetTensorRawData failed";
 212
 213   unsigned int expected_dim[] = {3, 2, 2, 1};
 214
 215   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 216     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value on dim " << i;
 217   }
 218   size_t expected_size = 12;
 219   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 220   uint8_t expected_arr[] = {0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0};
 221   for (size_t i = 0; i < expected_size; i++) {
 222     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 223   }
 224 }
 225
 226 // Set:
 227 //  0,  0,  0
 228 //  0,  0,  0
 229 //
 230 //  0,  0,  0
 231 //  0,  0,  0
 232 // ------------
 233 //  0,  0,  0
 234 //  0,  0,  0
 235 //
 236 //  0,  1,  0
 237 //  0,  2,  0
 238
 239 TEST_F(MlTensorRawDataTest, SetTensorRawData4) {
 240   ScopeLogger("SetTensorRawData4");
 241   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 242   unsigned int dim[] = {3, 2, 2, 2};
 243   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 244   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 245
 246   unsigned int location[] = {1, 0, 1, 1};
 247   unsigned int size[] = {1, 2, 1, 1};
 248   uint8_t arr_in[] = {1, 2};
 249   TensorRawData raw_data_set{arr_in, 2};
 250   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 251   ASSERT_TRUE(res) << "SetTensorRawData failed";
 252
 253   TensorRawData raw_data_get;
 254   unsigned int location_get[] = {0, 0, 0, 0};
 255   res = tensors_data->GetTensorRawData(0, location_get, dim, &raw_data_get);
 256   ASSERT_TRUE(res) << "GetTensorRawData failed";
 257
 258   unsigned int expected_dim[] = {3, 2, 2, 2};
 259
 260   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 261     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value on dim " << i;
 262   }
 263   size_t expected_size = 24;
 264   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 265   uint8_t expected_arr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0};
 266   for (size_t i = 0; i < expected_size; i++) {
 267     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 268   }
 269 }
 270
 271 // Set:
 272 //  0,  0,  0
 273 //  0,  0,  0
 274 //
 275 //  0,  0,  0
 276 //  0,  0,  0
 277 // ------------
 278 //  0,  0,  0
 279 //  0,  0,  0
 280 //
 281 //  0,  0,  0
 282 //  0,  0,  -34
 283
 284 TEST_F(MlTensorRawDataTest, SetTensorRawData5) {
 285   ScopeLogger("SetTensorRawData5");
 286   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 287   unsigned int dim[] = {3, 2, 2, 2};
 288   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_INT32, dim);
 289   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 290
 291   unsigned int location[] = {2, 1, 1, 1};
 292   unsigned int size[] = {1, 1, 1, 1};
 293   int arr_in[] = {-34};
 294   TensorRawData raw_data_set{(uint8_t*)arr_in, 4};
 295   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 296   ASSERT_TRUE(res) << "SetTensorRawData failed";
 297
 298   TensorRawData raw_data_get;
 299   unsigned int location_get[] = {0, 0, 0, 0};
 300   res = tensors_data->GetTensorRawData(0, location_get, dim, &raw_data_get);
 301   ASSERT_TRUE(res) << "GetTensorRawData failed";
 302
 303   unsigned int expected_dim[] = {3, 2, 2, 2};
 304
 305   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 306     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value on dim " << i;
 307   }
 308   size_t expected_size = 96;
 309   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 310   int expected_arr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -34};
 311   int intsize = 4;
 312   for (size_t i = 0; i < expected_size / intsize; i++) {
 313     int d = *((int*)&raw_data_get.data[intsize * i]);
 314     EXPECT_EQ(d, expected_arr[i]) << "Mismatch at pos " << i;
 315   }
 316 }
 317
 318 // Invalid location
 319 TEST_F(MlTensorRawDataTest, SetTensorRawData6) {
 320   ScopeLogger("SetTensorRawData6");
 321   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 322   unsigned int dim[] = {3, 2, 2, 2};
 323   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 324   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 325
 326   unsigned int location[] = {4, 0, 0, 0};
 327   unsigned int size[] = {1, 1, 1, 1};
 328   uint8_t arr_in[1] = {};
 329   TensorRawData raw_data_set{arr_in, 1};
 330   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 331   ASSERT_FALSE(res) << "SetTensorRawData should fail";
 332   ASSERT_EQ(res.error_code(), ErrorCode::INVALID_VALUES_ERR) << "Invalid error code";
 333 }
 334
 335 // Too few values
 336 TEST_F(MlTensorRawDataTest, SetTensorRawData7) {
 337   ScopeLogger("SetTensorRawData7");
 338   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 339   unsigned int dim[] = {3, 2, 2, 2};
 340   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 341   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 342
 343   unsigned int location[] = {0, 0, 0, 0};
 344   unsigned int size[] = {2, 1, 1, 1};
 345   uint8_t arr_in[1] = {};
 346   TensorRawData raw_data_set{arr_in, 1};
 347   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 348   ASSERT_FALSE(res) << "SetTensorRawData should fail";
 349   ASSERT_EQ(res.error_code(), ErrorCode::INVALID_VALUES_ERR) << "Invalid error code";
 350 }
 351
 352 // Too many values
 353 TEST_F(MlTensorRawDataTest, SetTensorRawData8) {
 354   ScopeLogger("SetTensorRawData8");
 355   auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 356   unsigned int dim[] = {3, 2, 2, 2};
 357   tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 358   auto tensors_data = tensors_info_manager_.CreateTensorsData(tensors_info);
 359
 360   unsigned int location[] = {0, 0, 0, 0};
 361   unsigned int size[] = {1, 1, 1, 1};
 362   uint8_t arr_in[400] = {};
 363   TensorRawData raw_data_set{arr_in, 400};
 364   PlatformResult res = tensors_data->SetTensorRawData(0, location, size, raw_data_set);
 365   ASSERT_FALSE(res) << "SetTensorRawData should fail";
 366   ASSERT_EQ(res.error_code(), ErrorCode::INVALID_VALUES_ERR) << "Invalid error code";
 367 }
 368
 369 class MlTensorRawDataTestGet : public testing::Test {
 370  public:
 371   MlTensorRawDataTestGet() : tensors_info_manager_(&tensors_data_manager_) {
 372   }
 373   virtual void SetUp() override {
 374     auto tensors_info = tensors_info_manager_.CreateTensorsInfo();
 375     unsigned int dim[] = {3, 2, 2, 2};
 376     tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim);
 377     unsigned int dim_big[] = {5, 4, 3, 2};
 378     tensors_info->AddTensorInfo("", ML_TENSOR_TYPE_UINT8, dim_big);
 379     tensors_data_ = tensors_info_manager_.CreateTensorsData(tensors_info);
 380
 381     unsigned int location[] = {0, 0, 0, 0};
 382     unsigned int size[] = {3, 2, 2, 2};
 383     uint8_t arr_in[] = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
 384                         13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
 385     TensorRawData raw_data_set{arr_in, 24};
 386     PlatformResult res = tensors_data_->SetTensorRawData(0, location, size, raw_data_set);
 387     ASSERT_TRUE(res) << "SetTensorRawData failed";
 388
 389     unsigned int location_big[] = {0, 0, 0, 0};
 390     unsigned int size_big[] = {5, 4, 3, 2};
 391
 392     uint8_t arr_in_big[120] = {};
 393     for (int i = 0; i < 120; i++) {
 394       arr_in_big[i] = i + 1;
 395     }
 396
 397     raw_data_set.data = arr_in_big;
 398     raw_data_set.size_in_bytes = 120;
 399     res = tensors_data_->SetTensorRawData(1, location_big, size_big, raw_data_set);
 400     ASSERT_TRUE(res) << "SetTensorRawData failed";
 401   }
 402
 403   virtual void TearDown() override {
 404   }
 405
 406   TensorsDataManager tensors_data_manager_;
 407   TensorsInfoManager tensors_info_manager_;
 408   TensorsData* tensors_data_;
 409 };
 410
 411 //  1,  2,  3
 412 //  4,  5,  6
 413 //
 414 //  7,  8,  9
 415 // 10, 11, 12
 416 // ------------
 417 // 13, 14, 15
 418 // 16, 17, 18
 419 //
 420 // 19, 20, 21
 421 // 22, 23, 24
 422
 423 TEST_F(MlTensorRawDataTestGet, GetTensorRawData1) {
 424   ScopeLogger("GetTensorRawData1");
 425
 426   unsigned int location_get[4] = {0, 0, 0, 0};
 427   unsigned int size_get[4] = {1, 1, 1, 1};
 428   unsigned int expected_dim[4] = {1, 1, 1, 1};
 429   size_t expected_size = 1;
 430   uint8_t expected_arr[1] = {1};
 431
 432   TensorRawData raw_data_get;
 433   PlatformResult res = tensors_data_->GetTensorRawData(0, location_get, size_get, &raw_data_get);
 434   ASSERT_TRUE(res) << "GetTensorRawData failed";
 435
 436   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 437     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value at dim " << i;
 438   }
 439   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 440   for (size_t i = 0; i < expected_size; i++) {
 441     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 442   }
 443 }
 444
 445 TEST_F(MlTensorRawDataTestGet, GetTensorRawData2) {
 446   ScopeLogger("GetTensorRawData2");
 447
 448   unsigned int location_get[4] = {0, 0, 1, 0};
 449   unsigned int size_get[4] = {3, 2, 2, 2};
 450   unsigned int expected_dim[4] = {3, 2, 1, 2};
 451   size_t expected_size = 12;
 452   uint8_t expected_arr[12] = {7, 8, 9, 10, 11, 12, 19, 20, 21, 22, 23, 24};
 453
 454   TensorRawData raw_data_get;
 455   PlatformResult res = tensors_data_->GetTensorRawData(0, location_get, size_get, &raw_data_get);
 456   ASSERT_TRUE(res) << "GetTensorRawData failed";
 457
 458   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 459     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value at dim " << i;
 460   }
 461   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 462   for (size_t i = 0; i < expected_size; i++) {
 463     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 464   }
 465 }
 466
 467 TEST_F(MlTensorRawDataTestGet, GetTensorRawData3) {
 468   ScopeLogger("GetTensorRawData3");
 469
 470   unsigned int location_get[4] = {1, 1, 1, 1};
 471   unsigned int size_get[4] = {2, 2, 2, 2};
 472   unsigned int expected_dim[4] = {2, 1, 1, 1};
 473   size_t expected_size = 2;
 474   uint8_t expected_arr[2] = {23, 24};
 475
 476   TensorRawData raw_data_get;
 477   PlatformResult res = tensors_data_->GetTensorRawData(0, location_get, size_get, &raw_data_get);
 478   ASSERT_TRUE(res) << "GetTensorRawData failed";
 479
 480   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 481     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value at dim " << i;
 482   }
 483   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 484   for (size_t i = 0; i < expected_size; i++) {
 485     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 486   }
 487 }
 488
 489 TEST_F(MlTensorRawDataTestGet, GetTensorRawData4) {
 490   ScopeLogger("GetTensorRawData4");
 491
 492   unsigned int location_get[4] = {2, 1, 0, 1};
 493   unsigned int size_get[4] = {3, 2, 2, 2};
 494   unsigned int expected_dim[4] = {1, 1, 2, 1};
 495   size_t expected_size = 2;
 496   uint8_t expected_arr[2] = {18, 24};
 497
 498   TensorRawData raw_data_get;
 499   PlatformResult res = tensors_data_->GetTensorRawData(0, location_get, size_get, &raw_data_get);
 500   ASSERT_TRUE(res) << "GetTensorRawData failed";
 501
 502   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 503     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value at dim " << i;
 504   }
 505   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 506   for (size_t i = 0; i < expected_size; i++) {
 507     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 508   }
 509 }
 510
 511 TEST_F(MlTensorRawDataTestGet, GetTensorRawData5) {
 512   ScopeLogger("GetTensorRawData5");
 513
 514   unsigned int location_get[4] = {3, 2, 1, 0};
 515   unsigned int size_get[4] = {1, 1, 2, 2};
 516   unsigned int expected_dim[4] = {1, 1, 2, 2};
 517   size_t expected_size = 4;
 518   uint8_t expected_arr[4] = {34, 54, 94, 114};
 519
 520   TensorRawData raw_data_get;
 521   PlatformResult res = tensors_data_->GetTensorRawData(1, location_get, size_get, &raw_data_get);
 522   ASSERT_TRUE(res) << "GetTensorRawData failed";
 523
 524   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 525     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value at dim " << i;
 526   }
 527   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 528   for (size_t i = 0; i < expected_size; i++) {
 529     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 530   }
 531 }
 532
 533 TEST_F(MlTensorRawDataTestGet, GetTensorRawData6) {
 534   ScopeLogger("GetTensorRawData6");
 535
 536   unsigned int location_get[4] = {4, 1, 0, 1};
 537   unsigned int size_get[4] = {5, 4, 3, 2};
 538   unsigned int expected_dim[4] = {1, 3, 3, 1};
 539   size_t expected_size = 9;
 540   uint8_t expected_arr[9] = {70, 75, 80, 90, 95, 100, 110, 115, 120};
 541
 542   TensorRawData raw_data_get;
 543   PlatformResult res = tensors_data_->GetTensorRawData(1, location_get, size_get, &raw_data_get);
 544   ASSERT_TRUE(res) << "GetTensorRawData failed";
 545
 546   for (int i = 0; i < ML_TENSOR_RANK_LIMIT; i++) {
 547     EXPECT_EQ(raw_data_get.shape[i], expected_dim[i]) << "Invalid value at dim " << i;
 548   }
 549   EXPECT_EQ(raw_data_get.size_in_bytes, expected_size);
 550   for (size_t i = 0; i < expected_size; i++) {
 551     EXPECT_EQ(raw_data_get.data[i], expected_arr[i]) << "Mismatch at pos " << i;
 552   }
 553 }
 554
 555 TEST_F(MlTensorRawDataTestGet, GetTensorRawData7) {
 556   ScopeLogger("GetTensorRawData7");
 557
 558   unsigned int location_get[4] = {4, 1, 0, 1};
 559   unsigned int size_get[4] = {5, 4, 3, 2};
 560
 561   TensorRawData raw_data_get;
 562   PlatformResult res = tensors_data_->GetTensorRawData(0, location_get, size_get, &raw_data_get);
 563   ASSERT_FALSE(res) << "GetTensorRawData should fail";
 564   ASSERT_EQ(res.error_code(), ErrorCode::INVALID_VALUES_ERR) << "Invalid error code";
 565 }