FL7: Add REVERSE CPU reference implementation and functional testing
Also refined REVERSE specification.
Also updated sample shim driver prebuilts.
Test: NeuralNetworksTest_static 2 --gtest_filter=*reverse_dim*
Bug: 202280925
Change-Id: Id7be504cc86eb3a96ea7a6b138d2e94631c06844
diff --git a/common/include/nnapi/OperationTypes.h b/common/include/nnapi/OperationTypes.h
index 2052e22..764ca1b 100644
--- a/common/include/nnapi/OperationTypes.h
+++ b/common/include/nnapi/OperationTypes.h
@@ -5370,7 +5370,7 @@
* must be in the range [0, n).
*
* Outputs:
- * * 0: The reversed tensor.
+ * * 0: The reversed tensor of the same shape as the input tensor.
* For {@link OperandType::TENSOR_QUANT8_ASYMM} and
* {@link OperandType::TENSOR_QUANT8_ASYMM_SIGNED} tensors,
* the scales and zeroPoint must be the same as input0.
diff --git a/common/operations/Reverse.cpp b/common/operations/Reverse.cpp
index f42080c..2335819 100644
--- a/common/operations/Reverse.cpp
+++ b/common/operations/Reverse.cpp
@@ -21,13 +21,11 @@
#ifdef NN_INCLUDE_CPU_IMPLEMENTATION
-#if 0
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wsign-compare"
#include <tensorflow/lite/kernels/internal/reference/reference_ops.h>
#pragma clang diagnostic pop
-#endif
#include "CpuOperationUtils.h"
#endif // NN_INCLUDE_CPU_IMPLEMENTATION
@@ -94,12 +92,55 @@
}
#ifdef NN_INCLUDE_CPU_IMPLEMENTATION
-bool prepare(IOperationExecutionContext* /*context*/) {
- return false;
+bool prepare(IOperationExecutionContext* context) {
+ const Shape inputShape = context->getInputShape(kInputTensor);
+
+ // Input tensor must be of rank 1..8.
+ const auto inputTensorRank = getNumberOfDimensions(inputShape);
+ NN_RET_CHECK_GE(inputTensorRank, 1U);
+ NN_RET_CHECK_LE(inputTensorRank, 8U);
+
+ // Check the axis dimension value.
+ const Shape axisShape = context->getInputShape(kInputAxisTensor);
+ NN_RET_CHECK_EQ(getNumberOfDimensions(axisShape), 1U);
+ NN_RET_CHECK_EQ(getNumberOfElements(axisShape), 1U);
+ const int32_t axisDimension = (context->getInputBuffer<int32_t>(kInputAxisTensor))[0];
+ NN_RET_CHECK_GE(axisDimension, 0);
+ NN_RET_CHECK_LT(uint32_t(axisDimension), inputTensorRank);
+
+ Shape outputShape = context->getOutputShape(kOutputTensor);
+ NN_RET_CHECK(SetShape(inputShape, &outputShape));
+ return context->setOutputShape(kOutputTensor, outputShape);
}
-bool execute(IOperationExecutionContext* /*context*/) {
- return false;
+template <typename T>
+bool reverse(IOperationExecutionContext* context) {
+ // Note that the NNAPI REVERSE operation requires input and output tensor to
+ // have the same dimensions.
+ const tflite::RuntimeShape tensorShape =
+ convertShapeToTflshape(context->getInputShape(kInputTensor));
+
+ tflite::reference_ops::Reverse((context->getInputBuffer<int32_t>(kInputAxisTensor))[0],
+ tensorShape, context->getInputBuffer<T>(kInputTensor),
+ tensorShape, context->getOutputBuffer<T>(kOutputTensor));
+ return true;
+}
+
+bool execute(IOperationExecutionContext* context) {
+ switch (context->getInputType(kInputTensor)) {
+ case OperandType::TENSOR_FLOAT16:
+ return reverse<_Float16>(context);
+ case OperandType::TENSOR_FLOAT32:
+ return reverse<float>(context);
+ case OperandType::TENSOR_QUANT8_ASYMM:
+ return reverse<uint8_t>(context);
+ case OperandType::TENSOR_QUANT8_ASYMM_SIGNED:
+ return reverse<int8_t>(context);
+ case OperandType::TENSOR_INT32:
+ return reverse<int32_t>(context);
+ default:
+ NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation " << kOperationName;
+ }
}
#endif // NN_INCLUDE_CPU_IMPLEMENTATION
diff --git a/driver/sample_shim/android_arm/neuralnetworks_sample_sl_driver_prebuilt.so b/driver/sample_shim/android_arm/neuralnetworks_sample_sl_driver_prebuilt.so
index fe35fcc..26ff8ca 100755
--- a/driver/sample_shim/android_arm/neuralnetworks_sample_sl_driver_prebuilt.so
+++ b/driver/sample_shim/android_arm/neuralnetworks_sample_sl_driver_prebuilt.so
Binary files differ
diff --git a/driver/sample_shim/android_arm64/neuralnetworks_sample_sl_driver_prebuilt.so b/driver/sample_shim/android_arm64/neuralnetworks_sample_sl_driver_prebuilt.so
index 4961c73..68d4947 100755
--- a/driver/sample_shim/android_arm64/neuralnetworks_sample_sl_driver_prebuilt.so
+++ b/driver/sample_shim/android_arm64/neuralnetworks_sample_sl_driver_prebuilt.so
Binary files differ
diff --git a/driver/sample_shim/android_x86/neuralnetworks_sample_sl_driver_prebuilt.so b/driver/sample_shim/android_x86/neuralnetworks_sample_sl_driver_prebuilt.so
index 0466bb3..5e8a9da 100755
--- a/driver/sample_shim/android_x86/neuralnetworks_sample_sl_driver_prebuilt.so
+++ b/driver/sample_shim/android_x86/neuralnetworks_sample_sl_driver_prebuilt.so
Binary files differ
diff --git a/driver/sample_shim/android_x86_64/neuralnetworks_sample_sl_driver_prebuilt.so b/driver/sample_shim/android_x86_64/neuralnetworks_sample_sl_driver_prebuilt.so
index e05a6d0..20bc3f0 100755
--- a/driver/sample_shim/android_x86_64/neuralnetworks_sample_sl_driver_prebuilt.so
+++ b/driver/sample_shim/android_x86_64/neuralnetworks_sample_sl_driver_prebuilt.so
Binary files differ
diff --git a/runtime/include/NeuralNetworksTypes.h b/runtime/include/NeuralNetworksTypes.h
index 4439af6..959552c 100644
--- a/runtime/include/NeuralNetworksTypes.h
+++ b/runtime/include/NeuralNetworksTypes.h
@@ -5817,7 +5817,7 @@
* must be in the range [0, n).
*
* Outputs:
- * * 0: The reversed tensor.
+ * * 0: The reversed tensor of the same shape as the input tensor.
* For {@link ANEURALNETWORKS_TENSOR_QUANT8_ASYMM} and
* {@link ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED} tensors,
* the scales and zeroPoint must be the same as input0.
diff --git a/runtime/test/generated/spec_AIDL_V3/reverse.example.cpp b/runtime/test/generated/spec_AIDL_V3/reverse.example.cpp
new file mode 100644
index 0000000..a100540
--- /dev/null
+++ b/runtime/test/generated/spec_AIDL_V3/reverse.example.cpp
@@ -0,0 +1,2602 @@
+// Generated from reverse.mod.py
+// DO NOT EDIT
+// clang-format off
+#include "TestHarness.h"
+using namespace test_helper;
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({6.0f, 7.0f, 8.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({8.0f, 7.0f, 6.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1 = TestModelManager::get().add("reverse_dim1", get_test_model_dim1());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({8.0f, 7.0f, 6.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // in_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({6.0f, 7.0f, 8.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // placeholder
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param4
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_all_inputs_as_internal = TestModelManager::get().add("reverse_dim1_all_inputs_as_internal", get_test_model_dim1_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_float16() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({6.0f, 7.0f, 8.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({8.0f, 7.0f, 6.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_float16 = TestModelManager::get().add("reverse_dim1_float16", get_test_model_dim1_float16());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_float16_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({8.0f, 7.0f, 6.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // in_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({6.0f, 7.0f, 8.0f}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // placeholder1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param5
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_float16_all_inputs_as_internal = TestModelManager::get().add("reverse_dim1_float16_all_inputs_as_internal", get_test_model_dim1_float16_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_quant8_asymm() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({16, 18, 20}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({20, 18, 16}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_quant8_asymm = TestModelManager::get().add("reverse_dim1_quant8_asymm", get_test_model_dim1_quant8_asymm());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_quant8_asymm_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({20, 18, 16}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // in_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({16, 18, 20}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // placeholder2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param6
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("reverse_dim1_quant8_asymm_all_inputs_as_internal", get_test_model_dim1_quant8_asymm_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_quant8_asymm_signed() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({15, 19, 23}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({23, 19, 15}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_quant8_asymm_signed = TestModelManager::get().add("reverse_dim1_quant8_asymm_signed", get_test_model_dim1_quant8_asymm_signed());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_quant8_asymm_signed_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({23, 19, 15}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // in_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({15, 19, 23}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // placeholder3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param7
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("reverse_dim1_quant8_asymm_signed_all_inputs_as_internal", get_test_model_dim1_quant8_asymm_signed_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim1_int32() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({6, 7, 8}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // param
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({8, 7, 6}),
+ .dimensions = {3},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim1_int32 = TestModelManager::get().add("reverse_dim1_int32", get_test_model_dim1_int32());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0 = TestModelManager::get().add("reverse_dim3_axis0", get_test_model_dim3_axis0());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // in1_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // placeholder4
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param8
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis0_all_inputs_as_internal", get_test_model_dim3_axis0_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_float16() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_float16 = TestModelManager::get().add("reverse_dim3_axis0_float16", get_test_model_dim3_axis0_float16());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_float16_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // in1_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // placeholder5
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param9
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_float16_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis0_float16_all_inputs_as_internal", get_test_model_dim3_axis0_float16_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_quant8_asymm() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_quant8_asymm = TestModelManager::get().add("reverse_dim3_axis0_quant8_asymm", get_test_model_dim3_axis0_quant8_asymm());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_quant8_asymm_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // in1_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // placeholder6
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param10
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis0_quant8_asymm_all_inputs_as_internal", get_test_model_dim3_axis0_quant8_asymm_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_quant8_asymm_signed() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83, -9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_quant8_asymm_signed = TestModelManager::get().add("reverse_dim3_axis0_quant8_asymm_signed", get_test_model_dim3_axis0_quant8_asymm_signed());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_quant8_asymm_signed_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83, -9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // in1_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // placeholder7
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param11
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis0_quant8_asymm_signed_all_inputs_as_internal", get_test_model_dim3_axis0_quant8_asymm_signed_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis0_int32() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // param1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out1
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis0_int32 = TestModelManager::get().add("reverse_dim3_axis0_int32", get_test_model_dim3_axis0_int32());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({8.0f, 9.0f, 10.0f, 11.0f, 4.0f, 5.0f, 6.0f, 7.0f, 0.0f, 1.0f, 2.0f, 3.0f, 20.0f, 21.0f, 22.0f, 23.0f, 16.0f, 17.0f, 18.0f, 19.0f, 12.0f, 13.0f, 14.0f, 15.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1 = TestModelManager::get().add("reverse_dim3_axis1", get_test_model_dim3_axis1());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({8.0f, 9.0f, 10.0f, 11.0f, 4.0f, 5.0f, 6.0f, 7.0f, 0.0f, 1.0f, 2.0f, 3.0f, 20.0f, 21.0f, 22.0f, 23.0f, 16.0f, 17.0f, 18.0f, 19.0f, 12.0f, 13.0f, 14.0f, 15.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // in2_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // placeholder8
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param12
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis1_all_inputs_as_internal", get_test_model_dim3_axis1_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_float16() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({8.0f, 9.0f, 10.0f, 11.0f, 4.0f, 5.0f, 6.0f, 7.0f, 0.0f, 1.0f, 2.0f, 3.0f, 20.0f, 21.0f, 22.0f, 23.0f, 16.0f, 17.0f, 18.0f, 19.0f, 12.0f, 13.0f, 14.0f, 15.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_float16 = TestModelManager::get().add("reverse_dim3_axis1_float16", get_test_model_dim3_axis1_float16());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_float16_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({8.0f, 9.0f, 10.0f, 11.0f, 4.0f, 5.0f, 6.0f, 7.0f, 0.0f, 1.0f, 2.0f, 3.0f, 20.0f, 21.0f, 22.0f, 23.0f, 16.0f, 17.0f, 18.0f, 19.0f, 12.0f, 13.0f, 14.0f, 15.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // in2_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // placeholder9
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param13
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_float16_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis1_float16_all_inputs_as_internal", get_test_model_dim3_axis1_float16_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_quant8_asymm() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({20, 22, 24, 26, 12, 14, 16, 18, 4, 6, 8, 10, 44, 46, 48, 50, 36, 38, 40, 42, 28, 30, 32, 34}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_quant8_asymm = TestModelManager::get().add("reverse_dim3_axis1_quant8_asymm", get_test_model_dim3_axis1_quant8_asymm());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_quant8_asymm_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({20, 22, 24, 26, 12, 14, 16, 18, 4, 6, 8, 10, 44, 46, 48, 50, 36, 38, 40, 42, 28, 30, 32, 34}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // in2_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // placeholder10
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param14
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis1_quant8_asymm_all_inputs_as_internal", get_test_model_dim3_axis1_quant8_asymm_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_quant8_asymm_signed() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({23, 27, 31, 35, 7, 11, 15, 19, -9, -5, -1, 3, 71, 75, 79, 83, 55, 59, 63, 67, 39, 43, 47, 51}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_quant8_asymm_signed = TestModelManager::get().add("reverse_dim3_axis1_quant8_asymm_signed", get_test_model_dim3_axis1_quant8_asymm_signed());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_quant8_asymm_signed_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({23, 27, 31, 35, 7, 11, 15, 19, -9, -5, -1, 3, 71, 75, 79, 83, 55, 59, 63, 67, 39, 43, 47, 51}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // in2_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // placeholder11
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param15
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis1_quant8_asymm_signed_all_inputs_as_internal", get_test_model_dim3_axis1_quant8_asymm_signed_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis1_int32() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // param2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({1}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out2
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3, 20, 21, 22, 23, 16, 17, 18, 19, 12, 13, 14, 15}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis1_int32 = TestModelManager::get().add("reverse_dim3_axis1_int32", get_test_model_dim3_axis1_int32());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({3.0f, 2.0f, 1.0f, 0.0f, 7.0f, 6.0f, 5.0f, 4.0f, 11.0f, 10.0f, 9.0f, 8.0f, 15.0f, 14.0f, 13.0f, 12.0f, 19.0f, 18.0f, 17.0f, 16.0f, 23.0f, 22.0f, 21.0f, 20.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2 = TestModelManager::get().add("reverse_dim3_axis2", get_test_model_dim3_axis2());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({3.0f, 2.0f, 1.0f, 0.0f, 7.0f, 6.0f, 5.0f, 4.0f, 11.0f, 10.0f, 9.0f, 8.0f, 15.0f, 14.0f, 13.0f, 12.0f, 19.0f, 18.0f, 17.0f, 16.0f, 23.0f, 22.0f, 21.0f, 20.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // in3_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // placeholder12
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<float>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT32,
+ .zeroPoint = 0
+ }, { // param16
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis2_all_inputs_as_internal", get_test_model_dim3_axis2_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_float16() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({3.0f, 2.0f, 1.0f, 0.0f, 7.0f, 6.0f, 5.0f, 4.0f, 11.0f, 10.0f, 9.0f, 8.0f, 15.0f, 14.0f, 13.0f, 12.0f, 19.0f, 18.0f, 17.0f, 16.0f, 23.0f, 22.0f, 21.0f, 20.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_float16 = TestModelManager::get().add("reverse_dim3_axis2_float16", get_test_model_dim3_axis2_float16());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_float16_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({3.0f, 2.0f, 1.0f, 0.0f, 7.0f, 6.0f, 5.0f, 4.0f, 11.0f, 10.0f, 9.0f, 8.0f, 15.0f, 14.0f, 13.0f, 12.0f, 19.0f, 18.0f, 17.0f, 16.0f, 23.0f, 22.0f, 21.0f, 20.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // in3_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // placeholder13
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<_Float16>({0.0f}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_FLOAT16,
+ .zeroPoint = 0
+ }, { // param17
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_float16_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis2_float16_all_inputs_as_internal", get_test_model_dim3_axis2_float16_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_quant8_asymm() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({10, 8, 6, 4, 18, 16, 14, 12, 26, 24, 22, 20, 34, 32, 30, 28, 42, 40, 38, 36, 50, 48, 46, 44}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_quant8_asymm = TestModelManager::get().add("reverse_dim3_axis2_quant8_asymm", get_test_model_dim3_axis2_quant8_asymm());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_quant8_asymm_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({10, 8, 6, 4, 18, 16, 14, 12, 26, 24, 22, 20, 34, 32, 30, 28, 42, 40, 38, 36, 50, 48, 46, 44}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // in3_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // placeholder14
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<uint8_t>({4}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.5f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM,
+ .zeroPoint = 4
+ }, { // param18
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis2_quant8_asymm_all_inputs_as_internal", get_test_model_dim3_axis2_quant8_asymm_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_quant8_asymm_signed() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({3, -1, -5, -9, 19, 15, 11, 7, 35, 31, 27, 23, 51, 47, 43, 39, 67, 63, 59, 55, 83, 79, 75, 71}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_quant8_asymm_signed = TestModelManager::get().add("reverse_dim3_axis2_quant8_asymm_signed", get_test_model_dim3_axis2_quant8_asymm_signed());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_quant8_asymm_signed_all_inputs_as_internal() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {3},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({3, -1, -5, -9, 19, 15, 11, 7, 35, 31, 27, 23, 51, 47, 43, 39, 67, 63, 59, 55, 83, 79, 75, 71}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // in3_new
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // placeholder15
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int8_t>({-9}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.25f,
+ .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
+ .zeroPoint = -9
+ }, { // param19
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0}),
+ .dimensions = {},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {3, 4, 5},
+ .outputs = {0},
+ .type = TestOperationType::ADD
+ }, {
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("reverse_dim3_axis2_quant8_asymm_signed_all_inputs_as_internal", get_test_model_dim3_axis2_quant8_asymm_signed_all_inputs_as_internal());
+
+} // namespace generated_tests::reverse
+
+namespace generated_tests::reverse {
+
+const TestModel& get_test_model_dim3_axis2_int32() {
+ static TestModel model = {
+ .expectFailure = false,
+ .expectedMultinomialDistributionTolerance = 0,
+ .isRelaxed = false,
+ .main = {
+ .inputIndexes = {0},
+ .operands = {{ // in3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // param3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({2}),
+ .dimensions = {1},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::CONSTANT_COPY,
+ .numberOfConsumers = 1,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }, { // out3
+ .channelQuant = {},
+ .data = TestBuffer::createFromVector<int32_t>({3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12, 19, 18, 17, 16, 23, 22, 21, 20}),
+ .dimensions = {2, 3, 4},
+ .isIgnored = false,
+ .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
+ .numberOfConsumers = 0,
+ .scale = 0.0f,
+ .type = TestOperandType::TENSOR_INT32,
+ .zeroPoint = 0
+ }},
+ .operations = {{
+ .inputs = {0, 1},
+ .outputs = {2},
+ .type = TestOperationType::REVERSE
+ }},
+ .outputIndexes = {2}
+ },
+ .minSupportedVersion = TestHalVersion::AIDL_V3,
+ .referenced = {}
+ };
+ return model;
+}
+
+const auto dummy_test_model_dim3_axis2_int32 = TestModelManager::get().add("reverse_dim3_axis2_int32", get_test_model_dim3_axis2_int32());
+
+} // namespace generated_tests::reverse
+
diff --git a/runtime/test/specs/AIDL_V3/reverse.mod.py b/runtime/test/specs/AIDL_V3/reverse.mod.py
new file mode 100644
index 0000000..14c001d
--- /dev/null
+++ b/runtime/test/specs/AIDL_V3/reverse.mod.py
@@ -0,0 +1,75 @@
+#
+# Copyright (C) 2021 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.
+#
+
+from itertools import chain
+
+def test(name, axis_value, input_tensor, output_tensor, input_data, output_data):
+ model = Model().Operation("REVERSE", input_tensor, [axis_value]).To(output_tensor)
+ quant8_asymm_type = ("TENSOR_QUANT8_ASYMM", 0.5, 4)
+ quant8_asymm = DataTypeConverter(name="quant8_asymm").Identify({
+ input_tensor: quant8_asymm_type,
+ output_tensor: quant8_asymm_type,
+ })
+ quant8_asymm_signed_type = ("TENSOR_QUANT8_ASYMM_SIGNED", 0.25, -9)
+ quant8_asymm_signed = DataTypeConverter(name="quant8_asymm_signed").Identify({
+ input_tensor: quant8_asymm_signed_type,
+ output_tensor: quant8_asymm_signed_type,
+ })
+ Example({
+ input_tensor: input_data,
+ output_tensor: output_data,
+ }, model=model, name=name).AddVariations("float16", quant8_asymm, quant8_asymm_signed, "int32")
+
+def rrange(hi, lo):
+ return range(hi, lo, -1)
+
+test(
+ name="dim1",
+ axis_value=0,
+ input_tensor=Input("in", ("TENSOR_FLOAT32", [3])),
+ output_tensor=Output("out", ("TENSOR_FLOAT32", [3])),
+ input_data=[6, 7, 8],
+ output_data=[8, 7, 6],
+ )
+
+test(
+ name="dim3_axis0",
+ axis_value=0,
+ input_tensor=Input("in", ("TENSOR_FLOAT32", [2,3,4])),
+ output_tensor=Output("out", ("TENSOR_FLOAT32", [2,3,4])),
+ input_data = list(range(24)),
+ output_data = list(chain(range(12,24), range(0,12))),
+ )
+
+test(
+ name="dim3_axis1",
+ axis_value=1,
+ input_tensor=Input("in", ("TENSOR_FLOAT32", [2,3,4])),
+ output_tensor=Output("out", ("TENSOR_FLOAT32", [2,3,4])),
+ input_data = list(range(24)),
+ output_data = list(chain(range(8,12), range(4,8), range(0,4),
+ range(20,24), range(16,20), range(12,16))),
+ )
+
+test(
+ name="dim3_axis2",
+ axis_value=2,
+ input_tensor=Input("in", ("TENSOR_FLOAT32", [2,3,4])),
+ output_tensor=Output("out", ("TENSOR_FLOAT32", [2,3,4])),
+ input_data = list(range(24)),
+ output_data = list(chain(rrange(3,-1), rrange(7,3), rrange(11,7),
+ rrange(15,11), rrange(19,15), rrange(23,19)))
+ )
diff --git a/tools/api/types.spec b/tools/api/types.spec
index 26b2a14..c97ff57 100644
--- a/tools/api/types.spec
+++ b/tools/api/types.spec
@@ -6731,7 +6731,7 @@
* must be in the range [0, n).
*
* Outputs:
- * * 0: The reversed tensor.
+ * * 0: The reversed tensor of the same shape as the input tensor.
* For {@link %{OperandTypeLinkPfx}TENSOR_QUANT8_ASYMM} and
* {@link %{OperandTypeLinkPfx}TENSOR_QUANT8_ASYMM_SIGNED} tensors,
* the scales and zeroPoint must be the same as input0.
