2 * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
3 * Copyright (C) 2017 The Android Open Source Project
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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include "NeuralNetworksWrapper.h"
18 #if 0 // TODO-NNRT : Enable if we support OEM
19 #include "NeuralNetworksOEM.h"
21 #include <gtest/gtest.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.
34 static int shmem_num = 0;
35 static int shmem_create_region(size_t size)
38 snprintf(temp, sizeof(temp), "/tmp/nn-shmem-%d-%d-XXXXXXXXX", getpid(), shmem_num++);
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);
45 if (fd == -1) return -1;
49 if (TEMP_FAILURE_RETRY(ftruncate(fd, size)) == -1) {
57 class ValidationTest : public ::testing::Test {
59 virtual void SetUp() {}
62 class ValidationTestModel : public ValidationTest {
64 virtual void SetUp() {
65 ValidationTest::SetUp();
66 ASSERT_EQ(ANeuralNetworksModel_create(&mModel), ANEURALNETWORKS_NO_ERROR);
68 virtual void TearDown() {
69 ANeuralNetworksModel_free(mModel);
70 ValidationTest::TearDown();
72 ANeuralNetworksModel* mModel = nullptr;
75 class ValidationTestIdentify : public ValidationTestModel {
76 virtual void SetUp() {
77 ValidationTestModel::SetUp();
79 uint32_t dimensions[]{1};
80 ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32,
82 .dimensions = dimensions};
83 ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32,
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,
97 ANEURALNETWORKS_NO_ERROR);
99 virtual void TearDown() {
100 ValidationTestModel::TearDown();
104 class ValidationTestCompilation : public ValidationTestModel {
106 virtual void SetUp() {
107 ValidationTestModel::SetUp();
109 uint32_t dimensions[]{1};
110 ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32,
112 .dimensions = dimensions};
113 ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32,
115 .dimensions = nullptr};
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,
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);
133 ASSERT_EQ(ANeuralNetworksCompilation_create(mModel, &mCompilation),
134 ANEURALNETWORKS_NO_ERROR);
136 virtual void TearDown() {
137 ANeuralNetworksCompilation_free(mCompilation);
138 ValidationTestModel::TearDown();
140 ANeuralNetworksCompilation* mCompilation = nullptr;
143 class ValidationTestExecution : public ValidationTestCompilation {
145 virtual void SetUp() {
146 ValidationTestCompilation::SetUp();
148 ASSERT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR);
150 ASSERT_EQ(ANeuralNetworksExecution_create(mCompilation, &mExecution),
151 ANEURALNETWORKS_NO_ERROR);
153 virtual void TearDown() {
154 ANeuralNetworksExecution_free(mExecution);
155 ValidationTestCompilation::TearDown();
157 ANeuralNetworksExecution* mExecution = nullptr;
160 TEST_F(ValidationTest, CreateModel) {
161 EXPECT_EQ(ANeuralNetworksModel_create(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);
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);
171 ANeuralNetworksOperandType quant8TypeInvalidScale{
172 .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM,
174 .dimensions = nullptr,
175 // Scale has to be non-negative
179 EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidScale),
180 ANEURALNETWORKS_BAD_DATA);
182 ANeuralNetworksOperandType quant8TypeInvalidZeroPoint{
183 .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM,
185 .dimensions = nullptr,
187 // zeroPoint has to be in [0, 255]
190 EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidZeroPoint),
191 ANEURALNETWORKS_BAD_DATA);
194 ANeuralNetworksOperandType invalidScalarType{
195 .type = ANEURALNETWORKS_INT32,
196 // scalar types can only 0 dimensions.
200 EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &invalidScalarType),
201 ANEURALNETWORKS_BAD_DATA);
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);
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);
214 EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, nullptr, 0),
215 ANEURALNETWORKS_NO_ERROR);
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);
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);
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);
233 // This should succeed.
234 EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(float)),
235 ANEURALNETWORKS_NO_ERROR);
237 // This should fail, as this operand does not exist.
238 EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, sizeof(float)),
239 ANEURALNETWORKS_BAD_DATA);
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);
247 TEST_F(ValidationTestModel, SetOperandValueFromMemory) {
248 uint32_t dimensions[]{1};
249 ANeuralNetworksOperandType floatType{
250 .type = ANEURALNETWORKS_TENSOR_FLOAT32,
252 .dimensions = dimensions};
253 EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR);
255 const size_t memorySize = 20;
256 int memoryFd = shmem_create_region(memorySize);
257 ASSERT_GT(memoryFd, 0);
259 ANeuralNetworksMemory* memory;
260 EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE,
261 memoryFd, 0, &memory),
262 ANEURALNETWORKS_NO_ERROR);
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);
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);
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);
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);
286 // This should fail, since offset is larger than memorySize.
287 EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
288 memory, memorySize + 1,
290 ANEURALNETWORKS_BAD_DATA);
292 // This should fail, since requested size is larger than the memory.
293 EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
294 memory, memorySize - 3,
296 ANEURALNETWORKS_BAD_DATA);
298 ANeuralNetworksModel_finish(mModel);
299 // This should fail, as the model is already finished.
300 EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0,
303 ANEURALNETWORKS_BAD_STATE);
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);
313 EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(buffer)),
314 ANEURALNETWORKS_NO_ERROR);
316 const size_t kByteSizeOfOEMTensor = 4;
317 uint32_t dimensions[]{kByteSizeOfOEMTensor};
318 ANeuralNetworksOperandType OEMTensorType{
319 .type = ANEURALNETWORKS_TENSOR_OEM_BYTE,
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);
326 ANeuralNetworksModel_finish(mModel);
327 // This should fail, as the model is already finished.
328 EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType), ANEURALNETWORKS_BAD_STATE);
332 TEST_F(ValidationTestModel, AddOperation) {
335 EXPECT_EQ(ANeuralNetworksModel_addOperation(nullptr, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input,
337 ANEURALNETWORKS_UNEXPECTED_NULL);
338 EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 0, nullptr,
340 ANEURALNETWORKS_UNEXPECTED_NULL);
341 EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input,
343 ANEURALNETWORKS_UNEXPECTED_NULL);
345 ANeuralNetworksOperationType invalidOp = -1;
346 EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, invalidOp, 1, &input,
348 ANEURALNETWORKS_BAD_DATA);
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,
354 ANEURALNETWORKS_BAD_STATE);
357 TEST_F(ValidationTestModel, IdentifyInputsAndOutputs) {
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);
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);
373 TEST_F(ValidationTestModel, RelaxComputationFloat32toFloat16) {
374 EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(nullptr, true),
375 ANEURALNETWORKS_UNEXPECTED_NULL);
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);
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);
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);
399 TEST_F(ValidationTestIdentify, Ok) {
400 uint32_t inList[2]{0, 1};
401 uint32_t outList[1]{3};
403 ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 2, inList, 1, outList),
404 ANEURALNETWORKS_NO_ERROR);
406 ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR);
409 TEST_F(ValidationTestIdentify, InputIsOutput) {
410 uint32_t inList[2]{0, 1};
411 uint32_t outList[2]{3, 0};
413 ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 2, inList, 2, outList),
414 ANEURALNETWORKS_BAD_DATA);
417 TEST_F(ValidationTestIdentify, OutputIsInput) {
418 uint32_t inList[3]{0, 1, 3};
419 uint32_t outList[1]{3};
421 ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList),
422 ANEURALNETWORKS_BAD_DATA);
425 TEST_F(ValidationTestIdentify, DuplicateInputs) {
426 uint32_t inList[3]{0, 1, 0};
427 uint32_t outList[1]{3};
429 ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList),
430 ANEURALNETWORKS_BAD_DATA);
433 TEST_F(ValidationTestIdentify, DuplicateOutputs) {
434 uint32_t inList[2]{0, 1};
435 uint32_t outList[2]{3, 3};
437 ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 2, inList, 2, outList),
438 ANEURALNETWORKS_BAD_DATA);
441 TEST_F(ValidationTestCompilation, SetPreference) {
442 EXPECT_EQ(ANeuralNetworksCompilation_setPreference(nullptr, ANEURALNETWORKS_PREFER_LOW_POWER),
443 ANEURALNETWORKS_UNEXPECTED_NULL);
445 EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation, 40), ANEURALNETWORKS_BAD_DATA);
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);
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);
467 TEST_F(ValidationTestExecution, SetInput) {
468 ANeuralNetworksExecution* execution;
469 EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
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);
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);
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);
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);
490 TEST_F(ValidationTestExecution, SetOutput) {
491 ANeuralNetworksExecution* execution;
492 EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
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);
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);
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);
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);
513 TEST_F(ValidationTestExecution, SetInputFromMemory) {
514 ANeuralNetworksExecution* execution;
515 EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
517 const size_t memorySize = 20;
518 int memoryFd = shmem_create_region(memorySize);
519 ASSERT_GT(memoryFd, 0);
521 ANeuralNetworksMemory* memory;
522 EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE,
523 memoryFd, 0, &memory),
524 ANEURALNETWORKS_NO_ERROR);
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);
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);
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);
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);
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);
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);
559 TEST_F(ValidationTestExecution, SetOutputFromMemory) {
560 ANeuralNetworksExecution* execution;
561 EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
563 const size_t memorySize = 20;
564 int memoryFd = shmem_create_region(memorySize);
565 ASSERT_GT(memoryFd, 0);
567 ANeuralNetworksMemory* memory;
568 EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE,
569 memoryFd, 0, &memory),
570 ANEURALNETWORKS_NO_ERROR);
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);
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);
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);
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);
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);
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);
605 TEST_F(ValidationTestExecution, StartCompute) {
606 ANeuralNetworksExecution* execution;
607 EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR);
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);
616 TEST_F(ValidationTestExecution, EventWait) {
617 EXPECT_EQ(ANeuralNetworksEvent_wait(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL);