From 85d7aadb68ec9dd4678e6528f1ea69f69540ac41 Mon Sep 17 00:00:00 2001 From: =?utf8?q?=EA=B9=80=EC=88=98=EC=A7=84/=EB=8F=99=EC=9E=91=EC=A0=9C?= =?utf8?q?=EC=96=B4Lab=28SR=29/Engineer/=EC=82=BC=EC=84=B1=EC=A0=84?= =?utf8?q?=EC=9E=90?= Date: Fri, 27 Apr 2018 09:02:41 +0900 Subject: [PATCH] Change TestValidation2.cpp to default NN Runtime test (#928) This commit changes TestValidation2.cpp to default NN Runtime test. Signed-off-by: sjsujinkim --- src/runtime/test/CMakeLists.txt | 7 +- src/runtime/test/TestValidation.cpp | 405 +++++++++++++++++++++++------ src/runtime/test/TestValidation2.cpp | 488 ----------------------------------- 3 files changed, 321 insertions(+), 579 deletions(-) delete mode 100644 src/runtime/test/TestValidation2.cpp diff --git a/src/runtime/test/CMakeLists.txt b/src/runtime/test/CMakeLists.txt index 2ded608..988ac34 100644 --- a/src/runtime/test/CMakeLists.txt +++ b/src/runtime/test/CMakeLists.txt @@ -1,11 +1,8 @@ # Executable `runtime_run` (Dummy runner executable using NN API) set(RUNTIME_ANDROID_NN_TEST runtime_run_android_nn_test) set(RUNTIME_ANDROID_NN_TEST_SRC TestMain.cpp - TestTrivialModel.cpp) - -# Switch it when the debugging of 'TestValidation2.cpp' is finished for passing the all test. -set(RUNTIME_ANDROID_NN_TEST_SRC ${RUNTIME_ANDROID_NN_TEST_SRC} TestValidation.cpp) -#set(RUNTIME_ANDROID_NN_TEST_SRC ${RUNTIME_ANDROID_NN_TEST_SRC} TestValidation2.cpp) + TestTrivialModel.cpp + TestValidation.cpp) # g++-6.3 can build TestGenerated.cpp. if (CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.3) diff --git a/src/runtime/test/TestValidation.cpp b/src/runtime/test/TestValidation.cpp index d7056c9..03ccef6 100644 --- a/src/runtime/test/TestValidation.cpp +++ b/src/runtime/test/TestValidation.cpp @@ -13,22 +13,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #include "NeuralNetworks.h" - -//#include +#if 0 // TODO-NNRT : Enable if we support OEM, shared memory +#include "NeuralNetworksOEM.h" +#include +#endif #include #include - - +#include // This file tests all the validations done by the Neural Networks API. - namespace { class ValidationTest : public ::testing::Test { protected: virtual void SetUp() {} }; - class ValidationTestModel : public ValidationTest { protected: virtual void SetUp() { @@ -41,26 +39,53 @@ protected: } ANeuralNetworksModel* mModel = nullptr; }; - +class ValidationTestIdentify : public ValidationTestModel { + virtual void SetUp() { + ValidationTestModel::SetUp(); + uint32_t dimensions[]{1}; + ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32, + .dimensionCount = 1, + .dimensions = dimensions}; + ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32, + .dimensionCount = 0, + .dimensions = nullptr}; + ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); + ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); + ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR); + ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); + uint32_t inList[3]{0, 1, 2}; + uint32_t outList[1]{3}; + ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1, + outList), + ANEURALNETWORKS_NO_ERROR); + } + virtual void TearDown() { + ValidationTestModel::TearDown(); + } +}; class ValidationTestCompilation : public ValidationTestModel { protected: virtual void SetUp() { ValidationTestModel::SetUp(); - uint32_t dimensions[]{1}; ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32, .dimensionCount = 1, .dimensions = dimensions}; + ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32, + .dimensionCount = 0, + .dimensions = nullptr}; ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); + ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR); ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); - uint32_t inList[2]{0, 1}; - uint32_t outList[1]{2}; - ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 2, inList, 1, + uint32_t inList[3]{0, 1, 2}; + uint32_t outList[1]{3}; + ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1, outList), ANEURALNETWORKS_NO_ERROR); + ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList), + ANEURALNETWORKS_NO_ERROR); ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksCompilation_create(mModel, &mCompilation), ANEURALNETWORKS_NO_ERROR); } @@ -70,14 +95,11 @@ protected: } ANeuralNetworksCompilation* mCompilation = nullptr; }; - class ValidationTestExecution : public ValidationTestCompilation { protected: virtual void SetUp() { ValidationTestCompilation::SetUp(); - ASSERT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksExecution_create(mCompilation, &mExecution), ANEURALNETWORKS_NO_ERROR); } @@ -87,43 +109,145 @@ protected: } ANeuralNetworksExecution* mExecution = nullptr; }; - TEST_F(ValidationTest, CreateModel) { EXPECT_EQ(ANeuralNetworksModel_create(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); } - TEST_F(ValidationTestModel, AddOperand) { ANeuralNetworksOperandType floatType{ .type = ANEURALNETWORKS_FLOAT32, .dimensionCount = 0, .dimensions = nullptr}; EXPECT_EQ(ANeuralNetworksModel_addOperand(nullptr, &floatType), ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); - // TODO more types, + ANeuralNetworksOperandType quant8TypeInvalidScale{ + .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, + .dimensionCount = 0, + .dimensions = nullptr, + // Scale has to be non-negative + .scale = -1.0f, + .zeroPoint = 0, + }; + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidScale), + ANEURALNETWORKS_BAD_DATA); + ANeuralNetworksOperandType quant8TypeInvalidZeroPoint{ + .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, + .dimensionCount = 0, + .dimensions = nullptr, + .scale = 1.0f, + // zeroPoint has to be in [0, 255] + .zeroPoint = -1, + }; + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidZeroPoint), + ANEURALNETWORKS_BAD_DATA); + uint32_t dim = 2; + ANeuralNetworksOperandType invalidScalarType{ + .type = ANEURALNETWORKS_INT32, + // scalar types can only 0 dimensions. + .dimensionCount = 1, + .dimensions = &dim, + }; + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &invalidScalarType), + ANEURALNETWORKS_BAD_DATA); + ANeuralNetworksModel_finish(mModel); + // This should fail, as the model is already finished. + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), + ANEURALNETWORKS_BAD_STATE); } - TEST_F(ValidationTestModel, SetOperandValue) { ANeuralNetworksOperandType floatType{ .type = ANEURALNETWORKS_FLOAT32, .dimensionCount = 0, .dimensions = nullptr}; EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR); - char buffer[20]; EXPECT_EQ(ANeuralNetworksModel_setOperandValue(nullptr, 0, buffer, sizeof(buffer)), ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, nullptr, sizeof(buffer)), ANEURALNETWORKS_UNEXPECTED_NULL); - // This should fail, since buffer is not the size of a float32. EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(buffer)), ANEURALNETWORKS_BAD_DATA); - + // This should succeed. + EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(float)), + ANEURALNETWORKS_NO_ERROR); + // This should fail, as this operand does not exist. + EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + ANeuralNetworksModel_finish(mModel); + // This should fail, as the model is already finished. + EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(float)), + ANEURALNETWORKS_BAD_STATE); +} +#if 0 // REF-ANN +TEST_F(ValidationTestModel, SetOperandValueFromMemory) { + uint32_t dimensions[]{1}; + ANeuralNetworksOperandType floatType{ + .type = ANEURALNETWORKS_TENSOR_FLOAT32, + .dimensionCount = 1, + .dimensions = dimensions}; + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR); + const size_t memorySize = 20; + int memoryFd = ASharedMemory_create("nnMemory", memorySize); + ASSERT_GT(memoryFd, 0); + ANeuralNetworksMemory* memory; + EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE, + memoryFd, 0, &memory), + ANEURALNETWORKS_NO_ERROR); + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(nullptr, 0, + memory, 0, sizeof(float)), + ANEURALNETWORKS_UNEXPECTED_NULL); + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, + nullptr, 0, sizeof(float)), + ANEURALNETWORKS_UNEXPECTED_NULL); + // This should fail, since the operand does not exist. + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, -1, + memory, 0, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since memory is not the size of a float32. + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, + memory, 0, memorySize), + ANEURALNETWORKS_BAD_DATA); // This should fail, as this operand does not exist. - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, 4), ANEURALNETWORKS_BAD_DATA); - - // TODO lots of validation of type - // EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, - // sizeof(buffer)), ANEURALNETWORKS_UNEXPECTED_NULL); + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 1, + memory, 0, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since offset is larger than memorySize. + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, + memory, memorySize + 1, + sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since requested size is larger than the memory. + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, + memory, memorySize - 3, + sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + ANeuralNetworksModel_finish(mModel); + // This should fail, as the model is already finished. + EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, + memory, 0, + sizeof(float)), + ANEURALNETWORKS_BAD_STATE); +} +#endif // TODO-NNRT +#if 0 // TODO-NNRT : Enable if we support OEM OP. +TEST_F(ValidationTestModel, AddOEMOperand) { + ANeuralNetworksOperandType OEMScalarType{ + .type = ANEURALNETWORKS_OEM_SCALAR, .dimensionCount = 0, .dimensions = nullptr}; + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMScalarType), ANEURALNETWORKS_NO_ERROR); + char buffer[20]; + EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(buffer)), + ANEURALNETWORKS_NO_ERROR); + const size_t kByteSizeOfOEMTensor = 4; + uint32_t dimensions[]{kByteSizeOfOEMTensor}; + ANeuralNetworksOperandType OEMTensorType{ + .type = ANEURALNETWORKS_TENSOR_OEM_BYTE, + .dimensionCount = 1, + .dimensions = dimensions}; + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType), ANEURALNETWORKS_NO_ERROR); + EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, kByteSizeOfOEMTensor), + ANEURALNETWORKS_NO_ERROR); + ANeuralNetworksModel_finish(mModel); + // This should fail, as the model is already finished. + EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType), ANEURALNETWORKS_BAD_STATE); } - +#endif // TODO-NNRT TEST_F(ValidationTestModel, AddOperation) { uint32_t input = 0; uint32_t output = 0; @@ -136,13 +260,17 @@ TEST_F(ValidationTestModel, AddOperation) { EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input, 0, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); - // EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, - // ANEURALNETWORKS_AVERAGE_POOL_2D, &inputs, - // &outputs), - // ANEURALNETWORKS_UNEXPECTED_NULL); + ANeuralNetworksOperationType invalidOp = -1; + EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, invalidOp, 1, &input, + 1, &output), + ANEURALNETWORKS_BAD_DATA); + ANeuralNetworksModel_finish(mModel); + // This should fail, as the model is already finished. + EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input, + 1, &output), + ANEURALNETWORKS_BAD_STATE); } - -TEST_F(ValidationTestModel, SetInputsAndOutputs) { +TEST_F(ValidationTestModel, IdentifyInputsAndOutputs) { uint32_t input = 0; uint32_t output = 0; EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(nullptr, 1, &input, 1, &output), @@ -151,33 +279,71 @@ TEST_F(ValidationTestModel, SetInputsAndOutputs) { ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 0, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); + ANeuralNetworksModel_finish(mModel); + // This should fail, as the model is already finished. + EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 1, &output), + ANEURALNETWORKS_BAD_STATE); +} +#if 0 // TODO-NNRT : Enable if we support 'RelaxComputationFloat32toFloat16' +TEST_F(ValidationTestModel, RelaxComputationFloat32toFloat16) { + EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(nullptr, true), + ANEURALNETWORKS_UNEXPECTED_NULL); + ANeuralNetworksModel_finish(mModel); + // This should fail, as the model is already finished. + EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(mModel, true), + ANEURALNETWORKS_BAD_STATE); + EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(mModel, false), + ANEURALNETWORKS_BAD_STATE); } - +#endif TEST_F(ValidationTestModel, Finish) { EXPECT_EQ(ANeuralNetworksModel_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR); EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_BAD_STATE); } - TEST_F(ValidationTestModel, CreateCompilation) { ANeuralNetworksCompilation* compilation = nullptr; EXPECT_EQ(ANeuralNetworksCompilation_create(nullptr, &compilation), ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, &compilation), ANEURALNETWORKS_BAD_STATE); - - // EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, ANeuralNetworksCompilation * - // *compilation), - // ANEURALNETWORKS_UNEXPECTED_NULL); } - +TEST_F(ValidationTestIdentify, Ok) { + uint32_t inList[3]{0, 1, 2}; + uint32_t outList[1]{3}; + ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList), + ANEURALNETWORKS_NO_ERROR); + ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR); +} +TEST_F(ValidationTestIdentify, InputIsOutput) { + uint32_t inList[3]{0, 1, 2}; + uint32_t outList[2]{3, 0}; + ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 2, outList), + ANEURALNETWORKS_BAD_DATA); +} +TEST_F(ValidationTestIdentify, OutputIsInput) { + uint32_t inList[4]{0, 1, 2, 3}; + uint32_t outList[1]{3}; + ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 4, inList, 1, outList), + ANEURALNETWORKS_BAD_DATA); +} +TEST_F(ValidationTestIdentify, DuplicateInputs) { + uint32_t inList[4]{0, 1, 2, 0}; + uint32_t outList[1]{3}; + ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 4, inList, 1, outList), + ANEURALNETWORKS_BAD_DATA); +} +TEST_F(ValidationTestIdentify, DuplicateOutputs) { + uint32_t inList[3]{0, 1, 2}; + uint32_t outList[2]{3, 3}; + ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 2, outList), + ANEURALNETWORKS_BAD_DATA); +} TEST_F(ValidationTestCompilation, SetPreference) { EXPECT_EQ(ANeuralNetworksCompilation_setPreference(nullptr, ANEURALNETWORKS_PREFER_LOW_POWER), ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation, 40), ANEURALNETWORKS_BAD_DATA); } - TEST_F(ValidationTestCompilation, CreateExecution) { ANeuralNetworksExecution* execution = nullptr; EXPECT_EQ(ANeuralNetworksExecution_create(nullptr, &execution), @@ -186,11 +352,7 @@ TEST_F(ValidationTestCompilation, CreateExecution) { ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_BAD_STATE); - // EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, ANeuralNetworksExecution * - // *execution), - // ANEURALNETWORKS_UNEXPECTED_NULL); } - TEST_F(ValidationTestCompilation, Finish) { EXPECT_EQ(ANeuralNetworksCompilation_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR); @@ -199,57 +361,128 @@ TEST_F(ValidationTestCompilation, Finish) { ANEURALNETWORKS_BAD_STATE); EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_BAD_STATE); } - -#if 0 -// TODO do more.. TEST_F(ValidationTestExecution, SetInput) { - EXPECT_EQ(ANeuralNetworksExecution_setInput(ANeuralNetworksExecution * execution, int32_t index, - const ANeuralNetworksOperandType* type, - const void* buffer, size_t length), + ANeuralNetworksExecution* execution; + EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); + char buffer[20]; + EXPECT_EQ(ANeuralNetworksExecution_setInput(nullptr, 0, nullptr, buffer, sizeof(float)), ANEURALNETWORKS_UNEXPECTED_NULL); -} - -TEST_F(ValidationTestExecution, SetInputFromMemory) { - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(ANeuralNetworksExecution * execution, - int32_t index, - const ANeuralNetworksOperandType* type, - const ANeuralNetworksMemory* buffer, - uint32_t offset), + EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 0, nullptr, nullptr, sizeof(float)), ANEURALNETWORKS_UNEXPECTED_NULL); + // This should fail, since memory is not the size of a float32. + EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 0, nullptr, buffer, 20), + ANEURALNETWORKS_BAD_DATA); + // This should fail, as this operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 999, nullptr, buffer, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, as this operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, -1, nullptr, buffer, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); } - TEST_F(ValidationTestExecution, SetOutput) { - EXPECT_EQ(ANeuralNetworksExecution_setOutput(ANeuralNetworksExecution * execution, - int32_t index, - const ANeuralNetworksOperandType* type, - void* buffer, size_t length), + ANeuralNetworksExecution* execution; + EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); + char buffer[20]; + EXPECT_EQ(ANeuralNetworksExecution_setOutput(nullptr, 0, nullptr, buffer, sizeof(float)), + ANEURALNETWORKS_UNEXPECTED_NULL); + EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 0, nullptr, nullptr, sizeof(float)), ANEURALNETWORKS_UNEXPECTED_NULL); + // This should fail, since memory is not the size of a float32. + EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 0, nullptr, buffer, 20), + ANEURALNETWORKS_BAD_DATA); + // This should fail, as this operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 999, nullptr, buffer, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, as this operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, -1, nullptr, buffer, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); +} +#if 0 // TODO-NNRT : Enable if we support 'ASharedMemory_create' +TEST_F(ValidationTestExecution, SetInputFromMemory) { + ANeuralNetworksExecution* execution; + EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); + const size_t memorySize = 20; + int memoryFd = ASharedMemory_create("nnMemory", memorySize); + ASSERT_GT(memoryFd, 0); + ANeuralNetworksMemory* memory; + EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE, + memoryFd, 0, &memory), + ANEURALNETWORKS_NO_ERROR); + EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(nullptr, 0, nullptr, + memory, 0, sizeof(float)), + ANEURALNETWORKS_UNEXPECTED_NULL); + EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, + nullptr, 0, sizeof(float)), + ANEURALNETWORKS_UNEXPECTED_NULL); + // This should fail, since the operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 999, nullptr, + memory, 0, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since the operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, -1, nullptr, + memory, 0, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since memory is not the size of a float32. + EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, + memory, 0, memorySize), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since offset is larger than memorySize. + EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, + memory, memorySize + 1, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since requested size is larger than the memory. + EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, + memory, memorySize - 3, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); } - TEST_F(ValidationTestExecution, SetOutputFromMemory) { - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(ANeuralNetworksExecution * execution, - int32_t index, - const ANeuralNetworksOperandType* type, - const ANeuralNetworksMemory* buffer, - uint32_t offset), + ANeuralNetworksExecution* execution; + EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); + const size_t memorySize = 20; + int memoryFd = ASharedMemory_create("nnMemory", memorySize); + ASSERT_GT(memoryFd, 0); + ANeuralNetworksMemory* memory; + EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE, + memoryFd, 0, &memory), + ANEURALNETWORKS_NO_ERROR); + EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(nullptr, 0, nullptr, + memory, 0, sizeof(float)), + ANEURALNETWORKS_UNEXPECTED_NULL); + EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, + nullptr, 0, sizeof(float)), ANEURALNETWORKS_UNEXPECTED_NULL); + // This should fail, since the operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 999, nullptr, + memory, 0, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since the operand does not exist. + EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, -1, nullptr, + memory, 0, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since memory is not the size of a float32. + EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, + memory, 0, memorySize), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since offset is larger than memorySize. + EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, + memory, memorySize + 1, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); + // This should fail, since requested size is larger than the memory. + EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, + memory, memorySize - 3, sizeof(float)), + ANEURALNETWORKS_BAD_DATA); } - +#endif // REF-ANN TEST_F(ValidationTestExecution, StartCompute) { - EXPECT_EQ(ANeuralNetworksExecution_startCompute(ANeuralNetworksExecution * execution, - ANeuralNetworksEvent * *event), + ANeuralNetworksExecution* execution; + EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); + ANeuralNetworksEvent* event; + EXPECT_EQ(ANeuralNetworksExecution_startCompute(nullptr, &event), ANEURALNETWORKS_UNEXPECTED_NULL); -} - -TEST_F(ValidationTestEvent, Wait) { - EXPECT_EQ(ANeuralNetworksEvent_wait(ANeuralNetworksEvent * event), + EXPECT_EQ(ANeuralNetworksExecution_startCompute(execution, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); } - -TEST_F(ValidationTestEvent, Free) { - EXPECT_EQ(d ANeuralNetworksEvent_free(ANeuralNetworksEvent * event), - ANEURALNETWORKS_UNEXPECTED_NULL); +TEST_F(ValidationTestExecution, EventWait) { + EXPECT_EQ(ANeuralNetworksEvent_wait(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); } -#endif - } // namespace diff --git a/src/runtime/test/TestValidation2.cpp b/src/runtime/test/TestValidation2.cpp deleted file mode 100644 index 03ccef6..0000000 --- a/src/runtime/test/TestValidation2.cpp +++ /dev/null @@ -1,488 +0,0 @@ -/* - * Copyright (C) 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "NeuralNetworks.h" -#if 0 // TODO-NNRT : Enable if we support OEM, shared memory -#include "NeuralNetworksOEM.h" -#include -#endif -#include -#include -#include -// This file tests all the validations done by the Neural Networks API. -namespace { -class ValidationTest : public ::testing::Test { -protected: - virtual void SetUp() {} -}; -class ValidationTestModel : public ValidationTest { -protected: - virtual void SetUp() { - ValidationTest::SetUp(); - ASSERT_EQ(ANeuralNetworksModel_create(&mModel), ANEURALNETWORKS_NO_ERROR); - } - virtual void TearDown() { - ANeuralNetworksModel_free(mModel); - ValidationTest::TearDown(); - } - ANeuralNetworksModel* mModel = nullptr; -}; -class ValidationTestIdentify : public ValidationTestModel { - virtual void SetUp() { - ValidationTestModel::SetUp(); - uint32_t dimensions[]{1}; - ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32, - .dimensionCount = 1, - .dimensions = dimensions}; - ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32, - .dimensionCount = 0, - .dimensions = nullptr}; - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); - uint32_t inList[3]{0, 1, 2}; - uint32_t outList[1]{3}; - ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1, - outList), - ANEURALNETWORKS_NO_ERROR); - } - virtual void TearDown() { - ValidationTestModel::TearDown(); - } -}; -class ValidationTestCompilation : public ValidationTestModel { -protected: - virtual void SetUp() { - ValidationTestModel::SetUp(); - uint32_t dimensions[]{1}; - ANeuralNetworksOperandType tensorType{.type = ANEURALNETWORKS_TENSOR_FLOAT32, - .dimensionCount = 1, - .dimensions = dimensions}; - ANeuralNetworksOperandType scalarType{.type = ANEURALNETWORKS_INT32, - .dimensionCount = 0, - .dimensions = nullptr}; - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &scalarType), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_addOperand(mModel, &tensorType), ANEURALNETWORKS_NO_ERROR); - uint32_t inList[3]{0, 1, 2}; - uint32_t outList[1]{3}; - ASSERT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_ADD, 3, inList, 1, - outList), - ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList), - ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksCompilation_create(mModel, &mCompilation), - ANEURALNETWORKS_NO_ERROR); - } - virtual void TearDown() { - ANeuralNetworksCompilation_free(mCompilation); - ValidationTestModel::TearDown(); - } - ANeuralNetworksCompilation* mCompilation = nullptr; -}; -class ValidationTestExecution : public ValidationTestCompilation { -protected: - virtual void SetUp() { - ValidationTestCompilation::SetUp(); - ASSERT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksExecution_create(mCompilation, &mExecution), - ANEURALNETWORKS_NO_ERROR); - } - virtual void TearDown() { - ANeuralNetworksExecution_free(mExecution); - ValidationTestCompilation::TearDown(); - } - ANeuralNetworksExecution* mExecution = nullptr; -}; -TEST_F(ValidationTest, CreateModel) { - EXPECT_EQ(ANeuralNetworksModel_create(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); -} -TEST_F(ValidationTestModel, AddOperand) { - ANeuralNetworksOperandType floatType{ - .type = ANEURALNETWORKS_FLOAT32, .dimensionCount = 0, .dimensions = nullptr}; - EXPECT_EQ(ANeuralNetworksModel_addOperand(nullptr, &floatType), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); - ANeuralNetworksOperandType quant8TypeInvalidScale{ - .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, - .dimensionCount = 0, - .dimensions = nullptr, - // Scale has to be non-negative - .scale = -1.0f, - .zeroPoint = 0, - }; - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidScale), - ANEURALNETWORKS_BAD_DATA); - ANeuralNetworksOperandType quant8TypeInvalidZeroPoint{ - .type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, - .dimensionCount = 0, - .dimensions = nullptr, - .scale = 1.0f, - // zeroPoint has to be in [0, 255] - .zeroPoint = -1, - }; - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &quant8TypeInvalidZeroPoint), - ANEURALNETWORKS_BAD_DATA); - uint32_t dim = 2; - ANeuralNetworksOperandType invalidScalarType{ - .type = ANEURALNETWORKS_INT32, - // scalar types can only 0 dimensions. - .dimensionCount = 1, - .dimensions = &dim, - }; - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &invalidScalarType), - ANEURALNETWORKS_BAD_DATA); - ANeuralNetworksModel_finish(mModel); - // This should fail, as the model is already finished. - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), - ANEURALNETWORKS_BAD_STATE); -} -TEST_F(ValidationTestModel, SetOperandValue) { - ANeuralNetworksOperandType floatType{ - .type = ANEURALNETWORKS_FLOAT32, .dimensionCount = 0, .dimensions = nullptr}; - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR); - char buffer[20]; - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(nullptr, 0, buffer, sizeof(buffer)), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, nullptr, sizeof(buffer)), - ANEURALNETWORKS_UNEXPECTED_NULL); - // This should fail, since buffer is not the size of a float32. - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(buffer)), - ANEURALNETWORKS_BAD_DATA); - // This should succeed. - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(float)), - ANEURALNETWORKS_NO_ERROR); - // This should fail, as this operand does not exist. - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - ANeuralNetworksModel_finish(mModel); - // This should fail, as the model is already finished. - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(float)), - ANEURALNETWORKS_BAD_STATE); -} -#if 0 // REF-ANN -TEST_F(ValidationTestModel, SetOperandValueFromMemory) { - uint32_t dimensions[]{1}; - ANeuralNetworksOperandType floatType{ - .type = ANEURALNETWORKS_TENSOR_FLOAT32, - .dimensionCount = 1, - .dimensions = dimensions}; - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &floatType), ANEURALNETWORKS_NO_ERROR); - const size_t memorySize = 20; - int memoryFd = ASharedMemory_create("nnMemory", memorySize); - ASSERT_GT(memoryFd, 0); - ANeuralNetworksMemory* memory; - EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE, - memoryFd, 0, &memory), - ANEURALNETWORKS_NO_ERROR); - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(nullptr, 0, - memory, 0, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, - nullptr, 0, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - // This should fail, since the operand does not exist. - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, -1, - memory, 0, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since memory is not the size of a float32. - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, - memory, 0, memorySize), - ANEURALNETWORKS_BAD_DATA); - // This should fail, as this operand does not exist. - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 1, - memory, 0, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since offset is larger than memorySize. - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, - memory, memorySize + 1, - sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since requested size is larger than the memory. - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, - memory, memorySize - 3, - sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - ANeuralNetworksModel_finish(mModel); - // This should fail, as the model is already finished. - EXPECT_EQ(ANeuralNetworksModel_setOperandValueFromMemory(mModel, 0, - memory, 0, - sizeof(float)), - ANEURALNETWORKS_BAD_STATE); -} -#endif // TODO-NNRT -#if 0 // TODO-NNRT : Enable if we support OEM OP. -TEST_F(ValidationTestModel, AddOEMOperand) { - ANeuralNetworksOperandType OEMScalarType{ - .type = ANEURALNETWORKS_OEM_SCALAR, .dimensionCount = 0, .dimensions = nullptr}; - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMScalarType), ANEURALNETWORKS_NO_ERROR); - char buffer[20]; - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 0, buffer, sizeof(buffer)), - ANEURALNETWORKS_NO_ERROR); - const size_t kByteSizeOfOEMTensor = 4; - uint32_t dimensions[]{kByteSizeOfOEMTensor}; - ANeuralNetworksOperandType OEMTensorType{ - .type = ANEURALNETWORKS_TENSOR_OEM_BYTE, - .dimensionCount = 1, - .dimensions = dimensions}; - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType), ANEURALNETWORKS_NO_ERROR); - EXPECT_EQ(ANeuralNetworksModel_setOperandValue(mModel, 1, buffer, kByteSizeOfOEMTensor), - ANEURALNETWORKS_NO_ERROR); - ANeuralNetworksModel_finish(mModel); - // This should fail, as the model is already finished. - EXPECT_EQ(ANeuralNetworksModel_addOperand(mModel, &OEMTensorType), ANEURALNETWORKS_BAD_STATE); -} -#endif // TODO-NNRT -TEST_F(ValidationTestModel, AddOperation) { - uint32_t input = 0; - uint32_t output = 0; - EXPECT_EQ(ANeuralNetworksModel_addOperation(nullptr, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input, - 1, &output), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 0, nullptr, - 1, &output), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input, - 0, nullptr), - ANEURALNETWORKS_UNEXPECTED_NULL); - ANeuralNetworksOperationType invalidOp = -1; - EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, invalidOp, 1, &input, - 1, &output), - ANEURALNETWORKS_BAD_DATA); - ANeuralNetworksModel_finish(mModel); - // This should fail, as the model is already finished. - EXPECT_EQ(ANeuralNetworksModel_addOperation(mModel, ANEURALNETWORKS_AVERAGE_POOL_2D, 1, &input, - 1, &output), - ANEURALNETWORKS_BAD_STATE); -} -TEST_F(ValidationTestModel, IdentifyInputsAndOutputs) { - uint32_t input = 0; - uint32_t output = 0; - EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(nullptr, 1, &input, 1, &output), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 0, nullptr, 1, &output), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 0, nullptr), - ANEURALNETWORKS_UNEXPECTED_NULL); - ANeuralNetworksModel_finish(mModel); - // This should fail, as the model is already finished. - EXPECT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 1, &input, 1, &output), - ANEURALNETWORKS_BAD_STATE); -} -#if 0 // TODO-NNRT : Enable if we support 'RelaxComputationFloat32toFloat16' -TEST_F(ValidationTestModel, RelaxComputationFloat32toFloat16) { - EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(nullptr, true), - ANEURALNETWORKS_UNEXPECTED_NULL); - ANeuralNetworksModel_finish(mModel); - // This should fail, as the model is already finished. - EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(mModel, true), - ANEURALNETWORKS_BAD_STATE); - EXPECT_EQ(ANeuralNetworksModel_relaxComputationFloat32toFloat16(mModel, false), - ANEURALNETWORKS_BAD_STATE); -} -#endif -TEST_F(ValidationTestModel, Finish) { - EXPECT_EQ(ANeuralNetworksModel_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR); - EXPECT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_BAD_STATE); -} -TEST_F(ValidationTestModel, CreateCompilation) { - ANeuralNetworksCompilation* compilation = nullptr; - EXPECT_EQ(ANeuralNetworksCompilation_create(nullptr, &compilation), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksCompilation_create(mModel, &compilation), ANEURALNETWORKS_BAD_STATE); -} -TEST_F(ValidationTestIdentify, Ok) { - uint32_t inList[3]{0, 1, 2}; - uint32_t outList[1]{3}; - ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 1, outList), - ANEURALNETWORKS_NO_ERROR); - ASSERT_EQ(ANeuralNetworksModel_finish(mModel), ANEURALNETWORKS_NO_ERROR); -} -TEST_F(ValidationTestIdentify, InputIsOutput) { - uint32_t inList[3]{0, 1, 2}; - uint32_t outList[2]{3, 0}; - ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 2, outList), - ANEURALNETWORKS_BAD_DATA); -} -TEST_F(ValidationTestIdentify, OutputIsInput) { - uint32_t inList[4]{0, 1, 2, 3}; - uint32_t outList[1]{3}; - ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 4, inList, 1, outList), - ANEURALNETWORKS_BAD_DATA); -} -TEST_F(ValidationTestIdentify, DuplicateInputs) { - uint32_t inList[4]{0, 1, 2, 0}; - uint32_t outList[1]{3}; - ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 4, inList, 1, outList), - ANEURALNETWORKS_BAD_DATA); -} -TEST_F(ValidationTestIdentify, DuplicateOutputs) { - uint32_t inList[3]{0, 1, 2}; - uint32_t outList[2]{3, 3}; - ASSERT_EQ(ANeuralNetworksModel_identifyInputsAndOutputs(mModel, 3, inList, 2, outList), - ANEURALNETWORKS_BAD_DATA); -} -TEST_F(ValidationTestCompilation, SetPreference) { - EXPECT_EQ(ANeuralNetworksCompilation_setPreference(nullptr, ANEURALNETWORKS_PREFER_LOW_POWER), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation, 40), ANEURALNETWORKS_BAD_DATA); -} -TEST_F(ValidationTestCompilation, CreateExecution) { - ANeuralNetworksExecution* execution = nullptr; - EXPECT_EQ(ANeuralNetworksExecution_create(nullptr, &execution), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, nullptr), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), - ANEURALNETWORKS_BAD_STATE); -} -TEST_F(ValidationTestCompilation, Finish) { - EXPECT_EQ(ANeuralNetworksCompilation_finish(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_NO_ERROR); - EXPECT_EQ(ANeuralNetworksCompilation_setPreference(mCompilation, - ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER), - ANEURALNETWORKS_BAD_STATE); - EXPECT_EQ(ANeuralNetworksCompilation_finish(mCompilation), ANEURALNETWORKS_BAD_STATE); -} -TEST_F(ValidationTestExecution, SetInput) { - ANeuralNetworksExecution* execution; - EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); - char buffer[20]; - EXPECT_EQ(ANeuralNetworksExecution_setInput(nullptr, 0, nullptr, buffer, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 0, nullptr, nullptr, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - // This should fail, since memory is not the size of a float32. - EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 0, nullptr, buffer, 20), - ANEURALNETWORKS_BAD_DATA); - // This should fail, as this operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, 999, nullptr, buffer, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, as this operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setInput(execution, -1, nullptr, buffer, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); -} -TEST_F(ValidationTestExecution, SetOutput) { - ANeuralNetworksExecution* execution; - EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); - char buffer[20]; - EXPECT_EQ(ANeuralNetworksExecution_setOutput(nullptr, 0, nullptr, buffer, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 0, nullptr, nullptr, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - // This should fail, since memory is not the size of a float32. - EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 0, nullptr, buffer, 20), - ANEURALNETWORKS_BAD_DATA); - // This should fail, as this operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, 999, nullptr, buffer, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, as this operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setOutput(execution, -1, nullptr, buffer, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); -} -#if 0 // TODO-NNRT : Enable if we support 'ASharedMemory_create' -TEST_F(ValidationTestExecution, SetInputFromMemory) { - ANeuralNetworksExecution* execution; - EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); - const size_t memorySize = 20; - int memoryFd = ASharedMemory_create("nnMemory", memorySize); - ASSERT_GT(memoryFd, 0); - ANeuralNetworksMemory* memory; - EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE, - memoryFd, 0, &memory), - ANEURALNETWORKS_NO_ERROR); - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(nullptr, 0, nullptr, - memory, 0, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, - nullptr, 0, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - // This should fail, since the operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 999, nullptr, - memory, 0, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since the operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, -1, nullptr, - memory, 0, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since memory is not the size of a float32. - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, - memory, 0, memorySize), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since offset is larger than memorySize. - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, - memory, memorySize + 1, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since requested size is larger than the memory. - EXPECT_EQ(ANeuralNetworksExecution_setInputFromMemory(execution, 0, nullptr, - memory, memorySize - 3, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); -} -TEST_F(ValidationTestExecution, SetOutputFromMemory) { - ANeuralNetworksExecution* execution; - EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); - const size_t memorySize = 20; - int memoryFd = ASharedMemory_create("nnMemory", memorySize); - ASSERT_GT(memoryFd, 0); - ANeuralNetworksMemory* memory; - EXPECT_EQ(ANeuralNetworksMemory_createFromFd(memorySize, PROT_READ | PROT_WRITE, - memoryFd, 0, &memory), - ANEURALNETWORKS_NO_ERROR); - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(nullptr, 0, nullptr, - memory, 0, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, - nullptr, 0, sizeof(float)), - ANEURALNETWORKS_UNEXPECTED_NULL); - // This should fail, since the operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 999, nullptr, - memory, 0, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since the operand does not exist. - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, -1, nullptr, - memory, 0, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since memory is not the size of a float32. - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, - memory, 0, memorySize), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since offset is larger than memorySize. - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, - memory, memorySize + 1, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); - // This should fail, since requested size is larger than the memory. - EXPECT_EQ(ANeuralNetworksExecution_setOutputFromMemory(execution, 0, nullptr, - memory, memorySize - 3, sizeof(float)), - ANEURALNETWORKS_BAD_DATA); -} -#endif // REF-ANN -TEST_F(ValidationTestExecution, StartCompute) { - ANeuralNetworksExecution* execution; - EXPECT_EQ(ANeuralNetworksExecution_create(mCompilation, &execution), ANEURALNETWORKS_NO_ERROR); - ANeuralNetworksEvent* event; - EXPECT_EQ(ANeuralNetworksExecution_startCompute(nullptr, &event), - ANEURALNETWORKS_UNEXPECTED_NULL); - EXPECT_EQ(ANeuralNetworksExecution_startCompute(execution, nullptr), - ANEURALNETWORKS_UNEXPECTED_NULL); -} -TEST_F(ValidationTestExecution, EventWait) { - EXPECT_EQ(ANeuralNetworksEvent_wait(nullptr), ANEURALNETWORKS_UNEXPECTED_NULL); -} -} // namespace -- 2.7.4