From ad1b3d7518429e2d16a2695d9b0bbf81b6565ac9 Mon Sep 17 00:00:00 2001 From: Teresa Charlin Date: Tue, 14 Mar 2023 12:10:28 +0000 Subject: IVGCVSW-7555 Restructure Delegate * New folders created: * common is for common code where TfLite API is not used * classic is for existing delegate implementations * opaque is for new opaque delegate implementation, * tests is for shared between existing Delegate and Opaque Delegate which have test utils to work which delegate to use. * Existing delegate is built to libarmnnDelegate.so and opaque delegate is built as libarmnnOpaqueDelegate.so * Opaque structure is introduced but no API is added yet. * CmakeList.txt and delegate/CMakeList.txt have been modified and 2 new CmakeList.txt added * Rename BUILD_ARMNN_TFLITE_DELEGATE as BUILD_CLASSIC_DELEGATE * Rename BUILD_ARMNN_TFLITE_OPAQUE_DELEGATE as BUILD_OPAQUE_DELEGATE Signed-off-by: Teresa Charlin Change-Id: Ib682b9ad0ac8d8acdc4ec6d9099bb0008a9fe8ed --- delegate/test/ComparisonTest.cpp | 844 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 844 insertions(+) create mode 100644 delegate/test/ComparisonTest.cpp (limited to 'delegate/test/ComparisonTest.cpp') diff --git a/delegate/test/ComparisonTest.cpp b/delegate/test/ComparisonTest.cpp new file mode 100644 index 0000000000..b044c27693 --- /dev/null +++ b/delegate/test/ComparisonTest.cpp @@ -0,0 +1,844 @@ +// +// Copyright © 2020, 2023 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ComparisonTestHelper.hpp" + +#include + +#include +#include +#include +#include +#include +#include + +#include + +namespace armnnDelegate +{ + +void EqualFP32Test(std::vector& backends) +{ + std::vector input0Shape { 2, 2, 2, 2 }; + std::vector input1Shape { 2, 2, 2, 2 }; + std::vector expectedOutputShape { 2, 2, 2, 2 }; + + std::vector input0Values = + { + 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f, + 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f + }; + + std::vector input1Values = + { + 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f, + 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f + }; + + std::vector expectedOutputValues = + { + 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 1 + }; + + + ComparisonTest(tflite::BuiltinOperator_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void EqualBroadcastTest(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 3 }; + std::vector input1Shape { 1, 1, 1, 3 }; + std::vector expectedOutputShape { 1, 2, 2, 3 }; + + std::vector input0Values + { + 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, + 7.f, 8.f, 9.f, 10.f, 11.f, 12.f + }; + std::vector input1Values { 4.f, 5.f, 6.f }; + // Set output data + std::vector expectedOutputValues + { + 0, 0, 0, 1, 1, 1, + 0, 0, 0, 0, 0, 0 + }; + ComparisonTest(tflite::BuiltinOperator_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void EqualInt32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1, 5, 6, 4 }; + + std::vector input1Values = { 1, 3, 9, 4 }; + + std::vector expectedOutputValues = { 1, 0, 0, 1 }; + + ComparisonTest(tflite::BuiltinOperator_EQUAL, + ::tflite::TensorType_INT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void NotEqualFP32Test(std::vector& backends) +{ + std::vector input0Shape { 2, 2, 2, 2 }; + std::vector input1Shape { 2, 2, 2, 2 }; + std::vector expectedOutputShape { 2, 2, 2, 2 }; + + std::vector input0Values = + { + 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f, + 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f + }; + + std::vector input1Values = + { + 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f, + 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f + }; + + std::vector expectedOutputValues = + { + 0, 0, 0, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 0, 0, 0 + }; + + ComparisonTest(tflite::BuiltinOperator_NOT_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void NotEqualBroadcastTest(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 3 }; + std::vector input1Shape { 1, 1, 1, 3 }; + std::vector expectedOutputShape { 1, 2, 2, 3 }; + + std::vector input0Values + { + 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, + 7.f, 8.f, 9.f, 10.f, 11.f, 12.f + }; + std::vector input1Values { 4.f, 5.f, 6.f }; + // Set output data + std::vector expectedOutputValues + { + 1, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1 + }; + ComparisonTest(tflite::BuiltinOperator_NOT_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void NotEqualInt32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1, 5, 6, 4 }; + + std::vector input1Values = { 1, 3, 9, 4 }; + + std::vector expectedOutputValues = { 0, 1, 1, 0 }; + + ComparisonTest(tflite::BuiltinOperator_NOT_EQUAL, + ::tflite::TensorType_INT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void GreaterFP32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1, 5, 6, 4 }; + + std::vector input1Values = { 1, 3, 9, 4 }; + + std::vector expectedOutputValues = { 0, 1, 0, 0 }; + + ComparisonTest(tflite::BuiltinOperator_GREATER, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void GreaterBroadcastTest(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 3 }; + std::vector input1Shape { 1, 1, 1, 3 }; + std::vector expectedOutputShape { 1, 2, 2, 3 }; + + std::vector input0Values + { + 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, + 7.f, 8.f, 9.f, 10.f, 11.f, 12.f + }; + std::vector input1Values { 4.f, 5.f, 6.f }; + + std::vector expectedOutputValues + { + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1 + }; + ComparisonTest(tflite::BuiltinOperator_GREATER, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void GreaterInt32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1, 5, 6, 4 }; + + std::vector input1Values = { 1, 3, 9, 4 }; + + std::vector expectedOutputValues = { 0, 1, 0, 0 }; + + ComparisonTest(tflite::BuiltinOperator_GREATER, + ::tflite::TensorType_INT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void GreaterEqualFP32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1.f, 5.f, 6.f, 4.f }; + + std::vector input1Values = { 1.f, 3.f, 9.f, 4.f }; + + std::vector expectedOutputValues = { true, true, false, true }; + + ComparisonTest(tflite::BuiltinOperator_GREATER_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void GreaterEqualBroadcastTest(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 3 }; + std::vector input1Shape { 1, 1, 1, 3 }; + std::vector expectedOutputShape { 1, 2, 2, 3 }; + + std::vector input0Values + { + 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, + 7.f, 8.f, 9.f, 10.f, 11.f, 12.f + }; + std::vector input1Values { 4.f, 5.f, 6.f }; + // Set output data + std::vector expectedOutputValues + { + 0, 0, 0, 1, 1, 1, + 1, 1, 1, 1, 1, 1 + }; + + ComparisonTest(tflite::BuiltinOperator_GREATER_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void GreaterEqualInt32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1, 5, 6, 3 }; + + std::vector input1Values = { 1, 3, 9, 4 }; + + std::vector expectedOutputValues = { 1, 1, 0, 0 }; + + ComparisonTest(tflite::BuiltinOperator_GREATER_EQUAL, + ::tflite::TensorType_INT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void LessFP32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1.f, 5.f, 6.f, 4.f }; + + std::vector input1Values = { 1.f, 3.f, 9.f, 4.f }; + + std::vector expectedOutputValues = { false, false, true, false }; + + ComparisonTest(tflite::BuiltinOperator_LESS, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void LessBroadcastTest(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 3 }; + std::vector input1Shape { 1, 1, 1, 3 }; + std::vector expectedOutputShape { 1, 2, 2, 3 }; + + std::vector input0Values + { + 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, + 7.f, 8.f, 9.f, 10.f, 11.f, 12.f + }; + std::vector input1Values { 4.f, 5.f, 6.f }; + + std::vector expectedOutputValues + { + true, true, true, false, false, false, + false, false, false, false, false, false + }; + + ComparisonTest(tflite::BuiltinOperator_LESS, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void LessInt32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1, 5, 6, 3 }; + + std::vector input1Values = { 1, 3, 9, 4 }; + + std::vector expectedOutputValues = { false, false, true, true }; + + ComparisonTest(tflite::BuiltinOperator_LESS, + ::tflite::TensorType_INT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void LessEqualFP32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1.f, 5.f, 6.f, 4.f }; + + std::vector input1Values = { 1.f, 3.f, 9.f, 4.f }; + + std::vector expectedOutputValues = { true, false, true, true }; + + ComparisonTest(tflite::BuiltinOperator_LESS_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void LessEqualBroadcastTest(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 3 }; + std::vector input1Shape { 1, 1, 1, 3 }; + std::vector expectedOutputShape { 1, 2, 2, 3 }; + + std::vector input0Values + { + 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, + 7.f, 8.f, 9.f, 10.f, 11.f, 12.f + }; + std::vector input1Values { 4.f, 5.f, 6.f }; + + std::vector expectedOutputValues + { + true, true, true, true, true, true, + false, false, false, false, false, false + }; + + ComparisonTest(tflite::BuiltinOperator_LESS_EQUAL, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +void LessEqualInt32Test(std::vector& backends) +{ + std::vector input0Shape { 1, 2, 2, 1 }; + std::vector input1Shape { 1, 2, 2, 1 }; + std::vector expectedOutputShape { 1, 2, 2, 1 }; + + std::vector input0Values = { 1, 5, 6, 3 }; + + std::vector input1Values = { 1, 3, 9, 4 }; + + std::vector expectedOutputValues = { true, false, true, true }; + + ComparisonTest(tflite::BuiltinOperator_LESS_EQUAL, + ::tflite::TensorType_INT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues); +} + +TEST_SUITE("Comparison_CpuRefTests") +{ + +TEST_CASE ("EQUAL_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + EqualFP32Test(backends); +} + +TEST_CASE ("EQUAL_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + EqualBroadcastTest(backends); +} + +TEST_CASE ("EQUAL_INT32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + EqualInt32Test(backends); +} + +TEST_CASE ("NOT_EQUAL_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + NotEqualFP32Test(backends); +} + +TEST_CASE ("NOT_EQUAL_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + NotEqualBroadcastTest(backends); +} + +TEST_CASE ("NOT_EQUAL_INT32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + NotEqualInt32Test(backends); +} + +TEST_CASE ("GREATER_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + GreaterFP32Test(backends); +} + +TEST_CASE ("GREATER_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + GreaterBroadcastTest(backends); +} + +TEST_CASE ("GREATER_INT32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + GreaterInt32Test(backends); +} + +TEST_CASE ("GREATER_EQUAL_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + GreaterEqualFP32Test(backends); +} + +TEST_CASE ("GREATER_EQUAL_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + GreaterEqualBroadcastTest(backends); +} + +TEST_CASE ("GREATER_EQUAL_INT32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + GreaterEqualInt32Test(backends); +} + +TEST_CASE ("LESS_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + LessFP32Test(backends); +} + +TEST_CASE ("LESS_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + LessBroadcastTest(backends); +} + +TEST_CASE ("LESS_INT32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + LessInt32Test(backends); +} + +TEST_CASE ("LESS_EQUAL_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + LessEqualFP32Test(backends); +} + +TEST_CASE ("LESS_EQUAL_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + LessEqualBroadcastTest(backends); +} + +TEST_CASE ("LESS_EQUAL_INT32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + LessEqualInt32Test(backends); +} +} // End TEST_SUITE("Comparison_CpuRefTests") + + + +TEST_SUITE("Comparison_GpuAccTests") +{ + +TEST_CASE ("EQUAL_FP32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + EqualFP32Test(backends); +} + +TEST_CASE ("EQUAL_Broadcast_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + EqualBroadcastTest(backends); +} + +TEST_CASE ("EQUAL_INT32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + EqualInt32Test(backends); +} + +TEST_CASE ("NOT_EQUAL_FP32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + NotEqualFP32Test(backends); +} + +TEST_CASE ("NOT_EQUAL_Broadcast_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + NotEqualBroadcastTest(backends); +} + +TEST_CASE ("NOT_EQUAL_INT32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + NotEqualInt32Test(backends); +} + +TEST_CASE ("GREATER_FP32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc, + armnn::Compute::CpuRef }; + GreaterFP32Test(backends); +} + +TEST_CASE ("GREATER_Broadcast_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc, + armnn::Compute::CpuRef }; + GreaterBroadcastTest(backends); +} + +TEST_CASE ("GREATER_INT32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc, + armnn::Compute::CpuRef }; + GreaterInt32Test(backends); +} + +TEST_CASE ("GREATER_EQUAL_FP32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + GreaterEqualFP32Test(backends); +} + +TEST_CASE ("GREATER_EQUAL_Broadcast_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + GreaterEqualBroadcastTest(backends); +} + +TEST_CASE ("GREATER_EQUAL_INT32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + GreaterEqualInt32Test(backends); +} + +TEST_CASE ("LESS_FP32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + LessFP32Test(backends); +} + +TEST_CASE ("LESS_Broadcast_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + LessBroadcastTest(backends); +} + +TEST_CASE ("LESS_INT32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + LessInt32Test(backends); +} + +TEST_CASE ("LESS_EQUAL_FP32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + LessEqualFP32Test(backends); +} + +TEST_CASE ("LESS_EQUAL_Broadcast_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + LessEqualBroadcastTest(backends); +} + +TEST_CASE ("LESS_EQUAL_INT32_GpuAcc_Test") +{ + std::vector backends = { armnn::Compute::GpuAcc }; + LessEqualInt32Test(backends); +} + +} // End TEST_SUITE("Comparison_GpuAccTests") + + +TEST_SUITE("Comparison_CpuAccTests") +{ + +TEST_CASE ("EQUAL_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + EqualFP32Test(backends); +} + +TEST_CASE ("EQUAL_Broadcast_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + EqualBroadcastTest(backends); +} + +TEST_CASE ("EQUAL_INT32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + EqualInt32Test(backends); +} + +TEST_CASE ("NOT_EQUAL_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + NotEqualFP32Test(backends); +} + +TEST_CASE ("NOT_EQUAL_Broadcast_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + NotEqualBroadcastTest(backends); +} + +TEST_CASE ("NOT_EQUAL_INT32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + NotEqualInt32Test(backends); +} + +TEST_CASE ("GREATER_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + GreaterFP32Test(backends); +} + +TEST_CASE ("GREATER_Broadcast_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + GreaterBroadcastTest(backends); +} + +TEST_CASE ("GREATER_INT32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + GreaterInt32Test(backends); +} + +TEST_CASE ("GREATER_EQUAL_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + GreaterEqualFP32Test(backends); +} + +TEST_CASE ("GREATER_EQUAL_Broadcast_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + GreaterEqualBroadcastTest(backends); +} + +TEST_CASE ("GREATER_EQUAL_INT32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + GreaterEqualInt32Test(backends); +} + +TEST_CASE ("LESS_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + LessFP32Test(backends); +} + +TEST_CASE ("LESS_Broadcast_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + LessBroadcastTest(backends); +} + +TEST_CASE ("LESS_INT32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + LessInt32Test(backends); +} + +TEST_CASE ("LESS_EQUAL_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + LessEqualFP32Test(backends); +} + +TEST_CASE ("LESS_EQUAL_Broadcast_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + LessEqualBroadcastTest(backends); +} + +TEST_CASE ("LESS_EQUAL_INT32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + LessEqualInt32Test(backends); +} + +} // End TEST_SUITE("Comparison_CpuAccTests") + +} // namespace armnnDelegate \ No newline at end of file -- cgit v1.2.1