tests/nnapi/src/TestValidation.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright (C) 2017 The Android Open Source Project
   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 #include "NeuralNetworksWrapper.h"
  18 #if 0 // TODO-NNRT : Enable if we support OEM
  19 #include "NeuralNetworksOEM.h"
  20 #endif
  21 #include <gtest/gtest.h>
  22 #include <string>
  23 #include <sys/mman.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 // Note: onert is allow to set activation operand constant only,
  27 //       so we change test to set operand #2 to constant. (ANEURALNETWORKS_FUSED_NONE)
  28 //       And model's input is changed: [0, 1, 2] -> [0, 1]
  29 // This file tests all the validations done by the Neural Networks API.
  30 namespace {
  31
  32 #define PATH_MAX 256
  33
  34 static int shmem_num = 0;
  35 static int shmem_create_region(size_t size)
  36 {
  37     char temp[PATH_MAX];
  38     snprintf(temp, sizeof(temp), "/tmp/nn-shmem-%d-%d-XXXXXXXXX", getpid(), shmem_num++);
  39
  40     // Set umask and recover after generate temporary file to avoid security issue
  41     mode_t umaskPrev = umask(S_IRUSR|S_IWUSR);
  42     int fd = mkstemp(temp);
  43     umask(umaskPrev);
  44
  45     if (fd == -1) return -1;
  46
  47     unlink(temp);
  48
  49     if (TEMP_FAILURE_RETRY(ftruncate(fd, size)) == -1) {
  50       close(fd);
  51       return -1;
  52     }
  53
  54     return fd;
  55 }
  56
  57 class ValidationTest : public ::testing::Test {
  58 protected:
  59     virtual void SetUp() {}
  60 };
  61
  62 class ValidationTestModel : public ValidationTest {
  63 protected:
  64     virtual void SetUp() {
  65         ValidationTest::SetUp();
  66         ASSERT_EQ(ANeuralNetworksModel_create(&mModel), ANEURALNETWORKS_NO_ERROR);
  67     }
  68     virtual void TearDown() {
  69         ANeuralNetworksModel_free(mModel);
  70         ValidationTest::TearDown();
  71     }
  72     ANeuralNetworksModel* mModel = nullptr;
  73 };
  74
  75 class ValidationTestIdentify : public ValidationTestModel {
  76     virtual void SetUp() {
  77         ValidationTestModel::SetUp();
  78
  79         uint32_t dimensions[]{1};
  80         ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32,
  81                                               .dimensionCount = 1,
  82                                               .dimensions = dimensions};
  83         ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32,
  84                                               .dimensionCount = 0,
  85                                               .dimensions = nullptr};
  86         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
  87         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
  88         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR);
  89         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
  90         // onert is allow to set activation operand constant only
  91         int32_t act = ANEURALNETWORKS_FUSED_NONE;
  92         ASSERT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 2, &act, sizeof(act)), ANEURALNETWORKS_NO_ERROR);
  93         uint32_t inList[3]{0, 1, 2};
  94         uint32_t outList[1]{3};
  95         ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1,
  96                                                     outList),
  97                   ANEURALNETWORKS_NO_ERROR);
  98     }
  99     virtual void TearDown() {
 100         ValidationTestModel::TearDown();
 101     }
 102 };
 103
 104 class ValidationTestCompilation : public ValidationTestModel {
 105 protected:
 106     virtual void SetUp() {
 107         ValidationTestModel::SetUp();
 108
 109         uint32_t dimensions[]{1};
 110         ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32,
 111                                               .dimensionCount = 1,
 112                                               .dimensions = dimensions};
 113         ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32,
 114                                               .dimensionCount = 0,
 115                                               .dimensions = nullptr};
 116
 117         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
 118         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
 119         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR);
 120         ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR);
 121         // onert is allow to set activation operand constant only
 122         int32_t act = ANEURALNETWORKS_FUSED_NONE;
 123         ASSERT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 2, &act, sizeof(act)), ANEURALNETWORKS_NO_ERROR);
 124         uint32_t inList[3]{0, 1, 2};
 125         uint32_t outList[1]{3};
 126         ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1,
 127                                                     outList),
 128                   ANEURALNETWORKS_NO_ERROR);
 129         ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 2, inList, 1, outList),
 130                   ANEURALNETWORKS_NO_ERROR);
 131         ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
 132
 133         ASSERT_EQ(ANeuralNetworksCompilation_create(mModel, &mCompilation),
 134                   ANEURALNETWORKS_NO_ERROR);
 135     }
 136     virtual void TearDown() {
 137         ANeuralNetworksCompilation_free(mCompilation);
 138         ValidationTestModel::TearDown();
 139     }
 140     ANeuralNetworksCompilation* mCompilation = nullptr;
 141 };
 142
 143 class ValidationTestExecution : public ValidationTestCompilation {
 144 protected:
 145     virtual void SetUp() {
 146         ValidationTestCompilation::SetUp();
 147
 148         ASSERT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR);
 149
 150         ASSERT_EQ(ANeuralNetworksExecution_create(mCompilation, &mExecution),
 151                   ANEURALNETWORKS_NO_ERROR);
 152     }
 153     virtual void TearDown() {
 154         ANeuralNetworksExecution_free(mExecution);
 155         ValidationTestCompilation::TearDown();
 156     }
 157     ANeuralNetworksExecution* mExecution = nullptr;
 158 };
 159
 160 TEST_F(ValidationTest, CreateModel) {
 161     EXPECT_EQ(ANeuralNetworksModel_create(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
 162 }
 163
 164 TEST_F(ValidationTestModel, AddOperand) {
 165     ANeuralNetworksOperandType floatType{
 166                 .type = ANEURALNETWORKS_FLOAT32, .dimensionCount = 0, .dimensions = nullptr};
 167     EXPECT_EQ(ANeuralNetworksModel_addOperand(nullptr, &floatType),
 168               ANEURALNETWORKS_UNEXPECTED_NULL);
 169     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
 170
 171     ANeuralNetworksOperandType quant8TypeInvalidScale{
 172                 .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM,
 173                 .dimensionCount = 0,
 174                 .dimensions = nullptr,
 175                 // Scale has to be non-negative
 176                 .scale = -1.0f,
 177                 .zeroPoint = 0,
 178               };
 179     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidScale),
 180               ANEURALNETWORKS_BAD_DATA);
 181
 182     ANeuralNetworksOperandType quant8TypeInvalidZeroPoint{
 183                 .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM,
 184                 .dimensionCount = 0,
 185                 .dimensions = nullptr,
 186                 .scale = 1.0f,
 187                 // zeroPoint has to be in [0, 255]
 188                 .zeroPoint = -1,
 189               };
 190     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidZeroPoint),
 191               ANEURALNETWORKS_BAD_DATA);
 192
 193     uint32_t dim = 2;
 194     ANeuralNetworksOperandType invalidScalarType{
 195                 .type = ANEURALNETWORKS_INT32,
 196                 // scalar types can only 0 dimensions.
 197                 .dimensionCount = 1,
 198                 .dimensions = &dim,
 199               };
 200     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &invalidScalarType),
 201               ANEURALNETWORKS_BAD_DATA);
 202
 203     ANeuralNetworksModel_finish(mModel);
 204     // This should fail, as the model is already finished.
 205     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType),
 206               ANEURALNETWORKS_BAD_STATE);
 207 }
 208
 209 TEST_F(ValidationTestModel, SetOptionalOperand) {
 210     ANeuralNetworksOperandType floatType{
 211                 .type = ANEURALNETWORKS_FLOAT32, .dimensionCount = 0, .dimensions = nullptr};
 212     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR);
 213
 214     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, nullptr, 0),
 215               ANEURALNETWORKS_NO_ERROR);
 216 }
 217
 218 TEST_F(ValidationTestModel, SetOperandValue) {
 219     ANeuralNetworksOperandType floatType{
 220                 .type = ANEURALNETWORKS_FLOAT32, .dimensionCount = 0, .dimensions = nullptr};
 221     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR);
 222
 223     char buffer[20];
 224     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(nullptr, 0, buffer, sizeof(buffer)),
 225               ANEURALNETWORKS_UNEXPECTED_NULL);
 226     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, nullptr, sizeof(buffer)),
 227               ANEURALNETWORKS_UNEXPECTED_NULL);
 228
 229     // This should fail, since buffer is not the size of a float32.
 230     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(buffer)),
 231               ANEURALNETWORKS_BAD_DATA);
 232
 233     // This should succeed.
 234     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(float)),
 235               ANEURALNETWORKS_NO_ERROR);
 236
 237     // This should fail, as this operand does not exist.
 238     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, sizeof(float)),
 239               ANEURALNETWORKS_BAD_DATA);
 240
 241     ANeuralNetworksModel_finish(mModel);
 242     // This should fail, as the model is already finished.
 243     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(float)),
 244               ANEURALNETWORKS_BAD_STATE);
 245 }
 246
 247 TEST_F(ValidationTestModel, SetOperandValueFromMemory) {
 248     uint32_t dimensions[]{1};
 249     ANeuralNetworksOperandType floatType{
 250                 .type = ANEURALNETWORKS_TENSOR_FLOAT32,
 251                 .dimensionCount = 1,
 252                 .dimensions = dimensions};
 253     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR);
 254
 255     const size_t memorySize = 20;
 256     int memoryFd = shmem_create_region(memorySize);
 257     ASSERT_GT(memoryFd, 0);
 258
 259     ANeuralNetworksMemory* memory;
 260     EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE,
 261                                                  memoryFd, 0, &memory),
 262               ANEURALNETWORKS_NO_ERROR);
 263
 264     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(nullptr, 0,
 265                                                              memory, 0, sizeof(float)),
 266               ANEURALNETWORKS_UNEXPECTED_NULL);
 267     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
 268                                                              nullptr, 0, sizeof(float)),
 269               ANEURALNETWORKS_UNEXPECTED_NULL);
 270
 271     // This should fail, since the operand does not exist.
 272     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, -1,
 273                                                              memory, 0, sizeof(float)),
 274               ANEURALNETWORKS_BAD_DATA);
 275
 276     // This should fail, since memory is not the size of a float32.
 277     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
 278                                                              memory, 0, memorySize),
 279               ANEURALNETWORKS_BAD_DATA);
 280
 281     // This should fail, as this operand does not exist.
 282     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 1,
 283                                                              memory, 0, sizeof(float)),
 284               ANEURALNETWORKS_BAD_DATA);
 285
 286     // This should fail, since offset is larger than memorySize.
 287     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
 288                                                              memory, memorySize + 1,
 289                                                              sizeof(float)),
 290               ANEURALNETWORKS_BAD_DATA);
 291
 292     // This should fail, since requested size is larger than the memory.
 293     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
 294                                                              memory, memorySize - 3,
 295                                                              sizeof(float)),
 296               ANEURALNETWORKS_BAD_DATA);
 297
 298     ANeuralNetworksModel_finish(mModel);
 299     // This should fail, as the model is already finished.
 300     EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
 301                                                              memory, 0,
 302                                                              sizeof(float)),
 303               ANEURALNETWORKS_BAD_STATE);
 304 }
 305
 306
 307 #if 0 // TODO-NNRT : Enable if we support OEM OP.
 308 TEST_F(ValidationTestModel, AddOEMOperand) {
 309     ANeuralNetworksOperandType OEMScalarType{
 310                 .type = ANEURALNETWORKS_OEM_SCALAR, .dimensionCount = 0, .dimensions = nullptr};
 311     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMScalarType), ANEURALNETWORKS_NO_ERROR);
 312     char buffer[20];
 313     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(buffer)),
 314               ANEURALNETWORKS_NO_ERROR);
 315
 316     const size_t kByteSizeOfOEMTensor = 4;
 317     uint32_t dimensions[]{kByteSizeOfOEMTensor};
 318     ANeuralNetworksOperandType OEMTensorType{
 319                 .type = ANEURALNETWORKS_TENSOR_OEM_BYTE,
 320                 .dimensionCount = 1,
 321                 .dimensions = dimensions};
 322     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType), ANEURALNETWORKS_NO_ERROR);
 323     EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, kByteSizeOfOEMTensor),
 324               ANEURALNETWORKS_NO_ERROR);
 325
 326     ANeuralNetworksModel_finish(mModel);
 327     // This should fail, as the model is already finished.
 328     EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType), ANEURALNETWORKS_BAD_STATE);
 329 }
 330 #endif // TODO-NNRT
 331
 332 TEST_F(ValidationTestModel, AddOperation) {
 333     uint32_t input = 0;
 334     uint32_t output = 0;
 335     EXPECT_EQ(ANeuralNetworksModel_addOperation(nullptr, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input,
 336                                                 1, &output),
 337               ANEURALNETWORKS_UNEXPECTED_NULL);
 338     EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 0, nullptr,
 339                                                 1, &output),
 340               ANEURALNETWORKS_UNEXPECTED_NULL);
 341     EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input,
 342                                                 0, nullptr),
 343               ANEURALNETWORKS_UNEXPECTED_NULL);
 344
 345     ANeuralNetworksOperationType invalidOp = -1;
 346     EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, invalidOp, 1, &input,
 347                                                 1, &output),
 348               ANEURALNETWORKS_BAD_DATA);
 349
 350     ANeuralNetworksModel_finish(mModel);
 351     // This should fail, as the model is already finished.
 352     EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input,
 353                                                 1, &output),
 354               ANEURALNETWORKS_BAD_STATE);
 355 }
 356
 357 TEST_F(ValidationTestModel, IdentifyInputsAndOutputs) {
 358     uint32_t input = 0;
 359     uint32_t output = 0;
 360     EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(nullptr, 1, &input, 1, &output),
 361               ANEURALNETWORKS_UNEXPECTED_NULL);
 362     EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 0, nullptr, 1, &output),
 363               ANEURALNETWORKS_UNEXPECTED_NULL);
 364     EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 0, nullptr),
 365               ANEURALNETWORKS_UNEXPECTED_NULL);
 366
 367     ANeuralNetworksModel_finish(mModel);
 368     // This should fail, as the model is already finished.
 369     EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 1, &output),
 370               ANEURALNETWORKS_BAD_STATE);
 371 }
 372
 373 TEST_F(ValidationTestModel, RelaxComputationFloat32toFloat16) {
 374     EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(nullptr, true),
 375               ANEURALNETWORKS_UNEXPECTED_NULL);
 376
 377     ANeuralNetworksModel_finish(mModel);
 378     // This should fail, as the model is already finished.
 379     EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(mModel, true),
 380               ANEURALNETWORKS_BAD_STATE);
 381     EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(mModel, false),
 382               ANEURALNETWORKS_BAD_STATE);
 383 }
 384
 385 TEST_F(ValidationTestModel, Finish) {
 386     EXPECT_EQ(ANeuralNetworksModel_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
 387     EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
 388     EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_BAD_STATE);
 389 }
 390
 391 TEST_F(ValidationTestModel, CreateCompilation) {
 392     ANeuralNetworksCompilation* compilation = nullptr;
 393     EXPECT_EQ(ANeuralNetworksCompilation_create(nullptr, &compilation),
 394               ANEURALNETWORKS_UNEXPECTED_NULL);
 395     EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
 396     EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, &compilation), ANEURALNETWORKS_BAD_STATE);
 397 }
 398
 399 TEST_F(ValidationTestIdentify, Ok) {
 400     uint32_t inList[2]{0, 1};
 401     uint32_t outList[1]{3};
 402
 403     ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 2, inList, 1, outList),
 404               ANEURALNETWORKS_NO_ERROR);
 405
 406     ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
 407 }
 408
 409 TEST_F(ValidationTestIdentify, InputIsOutput) {
 410     uint32_t inList[2]{0, 1};
 411     uint32_t outList[2]{3, 0};
 412
 413     ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 2, inList, 2, outList),
 414               ANEURALNETWORKS_BAD_DATA);
 415 }
 416
 417 TEST_F(ValidationTestIdentify, OutputIsInput) {
 418     uint32_t inList[3]{0, 1, 3};
 419     uint32_t outList[1]{3};
 420
 421     ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList),
 422               ANEURALNETWORKS_BAD_DATA);
 423 }
 424
 425 TEST_F(ValidationTestIdentify, DuplicateInputs) {
 426     uint32_t inList[3]{0, 1, 0};
 427     uint32_t outList[1]{3};
 428
 429     ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList),
 430               ANEURALNETWORKS_BAD_DATA);
 431 }
 432
 433 TEST_F(ValidationTestIdentify, DuplicateOutputs) {
 434     uint32_t inList[2]{0, 1};
 435     uint32_t outList[2]{3, 3};
 436
 437     ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 2, inList, 2, outList),
 438               ANEURALNETWORKS_BAD_DATA);
 439 }
 440
 441 TEST_F(ValidationTestCompilation, SetPreference) {
 442     EXPECT_EQ(ANeuralNetworksCompilation_setPreference(nullptr, ANEURALNETWORKS_PREFER_LOW_POWER),
 443               ANEURALNETWORKS_UNEXPECTED_NULL);
 444
 445     EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation, 40), ANEURALNETWORKS_BAD_DATA);
 446 }
 447
 448 TEST_F(ValidationTestCompilation, CreateExecution) {
 449     ANeuralNetworksExecution* execution = nullptr;
 450     EXPECT_EQ(ANeuralNetworksExecution_create(nullptr, &execution),
 451               ANEURALNETWORKS_UNEXPECTED_NULL);
 452     EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, nullptr),
 453               ANEURALNETWORKS_UNEXPECTED_NULL);
 454     EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution),
 455               ANEURALNETWORKS_BAD_STATE);
 456 }
 457
 458 TEST_F(ValidationTestCompilation, Finish) {
 459     EXPECT_EQ(ANeuralNetworksCompilation_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
 460     EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR);
 461     EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation,
 462                                                        ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER),
 463               ANEURALNETWORKS_BAD_STATE);
 464     EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_BAD_STATE);
 465 }
 466
 467 TEST_F(ValidationTestExecution, SetInput) {
 468     ANeuralNetworksExecution* execution;
 469     EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
 470
 471     char buffer[20];
 472     EXPECT_EQ(ANeuralNetworksExecution_setInput(nullptr, 0, nullptr, buffer, sizeof(float)),
 473               ANEURALNETWORKS_UNEXPECTED_NULL);
 474     EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 0, nullptr, nullptr, sizeof(float)),
 475               ANEURALNETWORKS_UNEXPECTED_NULL);
 476
 477     // This should fail, since memory is not the size of a float32.
 478     EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 0, nullptr, buffer, 20),
 479               ANEURALNETWORKS_BAD_DATA);
 480
 481     // This should fail, as this operand does not exist.
 482     EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 999, nullptr, buffer, sizeof(float)),
 483               ANEURALNETWORKS_BAD_DATA);
 484
 485     // This should fail, as this operand does not exist.
 486     EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, -1, nullptr, buffer, sizeof(float)),
 487               ANEURALNETWORKS_BAD_DATA);
 488 }
 489
 490 TEST_F(ValidationTestExecution, SetOutput) {
 491     ANeuralNetworksExecution* execution;
 492     EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
 493
 494     char buffer[20];
 495     EXPECT_EQ(ANeuralNetworksExecution_setOutput(nullptr, 0, nullptr, buffer, sizeof(float)),
 496               ANEURALNETWORKS_UNEXPECTED_NULL);
 497     EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 0, nullptr, nullptr, sizeof(float)),
 498               ANEURALNETWORKS_UNEXPECTED_NULL);
 499
 500     // This should fail, since memory is not the size of a float32.
 501     EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 0, nullptr, buffer, 20),
 502               ANEURALNETWORKS_BAD_DATA);
 503
 504     // This should fail, as this operand does not exist.
 505     EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 999, nullptr, buffer, sizeof(float)),
 506               ANEURALNETWORKS_BAD_DATA);
 507
 508     // This should fail, as this operand does not exist.
 509     EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, -1, nullptr, buffer, sizeof(float)),
 510               ANEURALNETWORKS_BAD_DATA);
 511 }
 512
 513 TEST_F(ValidationTestExecution, SetInputFromMemory) {
 514     ANeuralNetworksExecution* execution;
 515     EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
 516
 517     const size_t memorySize = 20;
 518     int memoryFd = shmem_create_region(memorySize);
 519     ASSERT_GT(memoryFd, 0);
 520
 521     ANeuralNetworksMemory* memory;
 522     EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE,
 523                                                  memoryFd, 0, &memory),
 524               ANEURALNETWORKS_NO_ERROR);
 525
 526     EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(nullptr, 0, nullptr,
 527                                                           memory, 0, sizeof(float)),
 528               ANEURALNETWORKS_UNEXPECTED_NULL);
 529     EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr,
 530                                                           nullptr, 0, sizeof(float)),
 531               ANEURALNETWORKS_UNEXPECTED_NULL);
 532
 533     // This should fail, since the operand does not exist.
 534     EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 999, nullptr,
 535                                                           memory, 0, sizeof(float)),
 536               ANEURALNETWORKS_BAD_DATA);
 537
 538     // This should fail, since the operand does not exist.
 539     EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, -1, nullptr,
 540                                                           memory, 0, sizeof(float)),
 541               ANEURALNETWORKS_BAD_DATA);
 542
 543     // This should fail, since memory is not the size of a float32.
 544     EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr,
 545                                                           memory, 0, memorySize),
 546               ANEURALNETWORKS_BAD_DATA);
 547
 548     // This should fail, since offset is larger than memorySize.
 549     EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr,
 550                                                           memory, memorySize + 1, sizeof(float)),
 551               ANEURALNETWORKS_BAD_DATA);
 552
 553     // This should fail, since requested size is larger than the memory.
 554     EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr,
 555                                                           memory, memorySize - 3, sizeof(float)),
 556               ANEURALNETWORKS_BAD_DATA);
 557 }
 558
 559 TEST_F(ValidationTestExecution, SetOutputFromMemory) {
 560     ANeuralNetworksExecution* execution;
 561     EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
 562
 563     const size_t memorySize = 20;
 564     int memoryFd = shmem_create_region(memorySize);
 565     ASSERT_GT(memoryFd, 0);
 566
 567     ANeuralNetworksMemory* memory;
 568     EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE,
 569                                                  memoryFd, 0, &memory),
 570               ANEURALNETWORKS_NO_ERROR);
 571
 572     EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(nullptr, 0, nullptr,
 573                                                            memory, 0, sizeof(float)),
 574               ANEURALNETWORKS_UNEXPECTED_NULL);
 575     EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr,
 576                                                            nullptr, 0, sizeof(float)),
 577               ANEURALNETWORKS_UNEXPECTED_NULL);
 578
 579     // This should fail, since the operand does not exist.
 580     EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 999, nullptr,
 581                                                            memory, 0, sizeof(float)),
 582               ANEURALNETWORKS_BAD_DATA);
 583
 584     // This should fail, since the operand does not exist.
 585     EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, -1, nullptr,
 586                                                            memory, 0, sizeof(float)),
 587               ANEURALNETWORKS_BAD_DATA);
 588
 589     // This should fail, since memory is not the size of a float32.
 590     EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr,
 591                                                            memory, 0, memorySize),
 592               ANEURALNETWORKS_BAD_DATA);
 593
 594     // This should fail, since offset is larger than memorySize.
 595     EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr,
 596                                                            memory, memorySize + 1, sizeof(float)),
 597               ANEURALNETWORKS_BAD_DATA);
 598
 599     // This should fail, since requested size is larger than the memory.
 600     EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr,
 601                                                            memory, memorySize - 3, sizeof(float)),
 602               ANEURALNETWORKS_BAD_DATA);
 603 }
 604
 605 TEST_F(ValidationTestExecution, StartCompute) {
 606     ANeuralNetworksExecution* execution;
 607     EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
 608
 609     ANeuralNetworksEvent* event;
 610     EXPECT_EQ(ANeuralNetworksExecution_startCompute(nullptr, &event),
 611               ANEURALNETWORKS_UNEXPECTED_NULL);
 612     EXPECT_EQ(ANeuralNetworksExecution_startCompute(execution, nullptr),
 613               ANEURALNETWORKS_UNEXPECTED_NULL);
 614 }
 615
 616 TEST_F(ValidationTestExecution, EventWait) {
 617     EXPECT_EQ(ANeuralNetworksEvent_wait(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
 618 }
 619 }  // namespace