IVGCVSW-7831: Front end and Reference Implementation for REVERSE_V2

 * Descriptors added for ReverseV2
 * Layer definition added
 * Input validation added
 * Reference workload implementation for ReverseV2 added
 * Reference layer unit tests made for ReverseV2
 * CompareTensors method updated to support comparison between empty tensors
 * CMake and other build files updated

Signed-off-by: Tianle Cheng <tianle.cheng@arm.com>
Change-Id: I805738454421309fda77c44218a8df171d68dc18

5 files changed, 1245 insertions, 0 deletions

diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt
index aba9c72e6c..0139044432 100644
--- a/src/backends/backendsCommon/test/CMakeLists.txt
+++ b/src/backends/backendsCommon/test/CMakeLists.txt
@@ -170,6 +170,8 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     layerTests/ReshapeTestImpl.hpp
     layerTests/ResizeTestImpl.cpp
     layerTests/ResizeTestImpl.hpp
+    layerTests/ReverseV2TestImpl.cpp
+    layerTests/ReverseV2TestImpl.hpp
     layerTests/RsqrtTestImpl.cpp
     layerTests/RsqrtTestImpl.hpp
     layerTests/SinTestImpl.cpp
diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
index 182fab97be..f7a852f440 100644
--- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
+++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
@@ -744,6 +744,8 @@ DECLARE_LAYER_POLICY_2_PARAM(Resize)
 
 DECLARE_LAYER_POLICY_2_PARAM(Reshape)
 
+DECLARE_LAYER_POLICY_2_PARAM(ReverseV2)
+
 DECLARE_LAYER_POLICY_1_PARAM(Shape)
 
 DECLARE_LAYER_POLICY_2_PARAM(Slice)
diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp
index b6ddb31419..755a665ba6 100644
--- a/src/backends/backendsCommon/test/LayerTests.hpp
+++ b/src/backends/backendsCommon/test/LayerTests.hpp
@@ -60,6 +60,7 @@
 #include <backendsCommon/test/layerTests/ReduceSumTestImpl.hpp>
 #include <backendsCommon/test/layerTests/ReshapeTestImpl.hpp>
 #include <backendsCommon/test/layerTests/ResizeTestImpl.hpp>
+#include <backendsCommon/test/layerTests/ReverseV2TestImpl.hpp>
 #include <backendsCommon/test/layerTests/RsqrtTestImpl.hpp>
 #include <backendsCommon/test/layerTests/ShapeTestImpl.hpp>
 #include <backendsCommon/test/layerTests/SinTestImpl.hpp>
diff --git a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
new file mode 100644
index 0000000000..586b831e45
--- /dev/null
+++ b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
@@ -0,0 +1,1084 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ReverseV2TestImpl.hpp"
+
+#include <armnn/backends/IBackendInternal.hpp>
+#include <armnn/backends/Workload.hpp>
+#include <armnn/backends/WorkloadData.hpp>
+#include <armnn/backends/WorkloadFactory.hpp>
+
+#include <armnnTestUtils/WorkloadTestUtils.hpp>
+#include <armnnUtils/QuantizeHelper.hpp>
+#include <armnnTestUtils/TensorCopyUtils.hpp>
+#include <armnn/Optional.hpp>
+#include <armnn/BackendHelper.hpp>
+
+namespace
+{
+    template<armnn::DataType ArmnnType, typename T, std::size_t NumDims>
+    LayerTestResult<T, NumDims> ReverseV2TestImpl(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
+        armnn::ReverseV2Descriptor descriptor,
+        const std::vector<T>& input,
+        const std::vector<T>& outputExpected,
+        const armnn::TensorInfo& inputInfo,
+        const armnn::TensorInfo& outputInfo)
+    {
+        LayerTestResult<T, NumDims> result(outputInfo);
+        std::vector<T> outputActual(outputInfo.GetNumElements());
+
+        std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo);
+        std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
+
+        armnn::ReverseV2QueueDescriptor queueDescriptor;
+        queueDescriptor.m_Parameters = std::move(descriptor);
+        armnn::WorkloadInfo workloadInfo;
+
+        AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get());
+        AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
+
+        // Don't execute if ReverseV2 is not supported, as an exception will be raised.
+        const armnn::BackendId& backend = workloadFactory.GetBackendId();
+        std::string reasonIfUnsupported;
+        armnn::LayerSupportHandle handle = armnn::GetILayerSupportByBackendId(backend);
+        result.m_Supported = handle.IsReverseV2Supported(inputInfo,
+                                                           outputInfo,
+                                                           queueDescriptor.m_Parameters,
+                                                           reasonIfUnsupported);
+        if (!result.m_Supported)
+        {
+            return result;
+        }
+
+        auto workload = workloadFactory.CreateWorkload(armnn::LayerType::ReverseV2, queueDescriptor, workloadInfo);
+
+        inputHandle->Allocate();
+        outputHandle->Allocate();
+
+        CopyDataToITensorHandle(inputHandle.get(), input.data());
+
+        workload->PostAllocationConfigure();
+        ExecuteWorkload(*workload, memoryManager);
+
+        CopyDataFromITensorHandle(outputActual.data(), outputHandle.get());
+
+        return LayerTestResult<T, NumDims>(outputActual,
+                                           outputExpected,
+                                           outputHandle->GetShape(),
+                                           outputInfo.GetShape());
+    }
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTestEmptyAxis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor. No axes set so output is the same as input
+    auto descriptor = armnn::ReverseV2Descriptor();
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2,
+        3, 4
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        1, 2,
+        3, 4
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                                memoryManager,
+                                                tensorHandleFactory,
+                                                descriptor,
+                                                input,
+                                                outputExpected,
+                                                inputInfo,
+                                                outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTestEmptyTensor(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor. Empty tensor set so output is the same as input
+    auto descriptor = armnn::ReverseV2Descriptor();
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({0}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({0}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({}, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({}, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest1Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({4}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2,
+        3, 4
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3,
+        2, 1
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest2Dim1Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2,
+        3, 4
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        2, 1,
+        4, 3
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest2Dim2Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, 0});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2,
+        3, 4
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3,
+        2, 1
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest3Dim1Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8,
+        9, 10, 11, 12,
+        13, 14, 15, 16,
+        17, 18, 19, 20,
+        21, 22, 23, 24
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        9, 10, 11, 12,
+        5, 6, 7, 8,
+        1, 2, 3, 4,
+        21, 22, 23, 24,
+        17, 18, 19, 20,
+        13, 14, 15, 16
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest3Dim2Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8,
+        9, 10, 11, 12,
+        13, 14, 15, 16,
+        17, 18, 19, 20,
+        21, 22, 23, 24
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        21, 22, 23, 24,
+        17, 18, 19, 20,
+        13, 14, 15, 16,
+        9, 10, 11, 12,
+        5, 6, 7, 8,
+        1, 2, 3, 4
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest3Dim3Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, 0, 2});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8,
+        9, 10, 11, 12,
+        13, 14, 15, 16,
+        17, 18, 19, 20,
+        21, 22, 23, 24
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        24, 23, 22, 21,
+        20, 19, 18, 17,
+        16, 15, 14, 13,
+        12, 11, 10, 9,
+        8, 7, 6, 5,
+        4, 3, 2, 1
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim1Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9,
+        10, 11, 12,
+        13, 14, 15,
+        16, 17, 18,
+        19, 20, 21,
+        22, 23, 24
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        13, 14, 15,
+        16, 17, 18,
+        19, 20, 21,
+        22, 23, 24,
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9,
+        10, 11, 12
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim2Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9,
+        10, 11, 12,
+        13, 14, 15,
+        16, 17, 18,
+        19, 20, 21,
+        22, 23, 24
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        19, 20, 21,
+        22, 23, 24,
+        13, 14, 15,
+        16, 17, 18,
+        7, 8, 9,
+        10, 11, 12,
+        1, 2, 3,
+        4, 5, 6
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim3Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1, 2});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9,
+        10, 11, 12,
+        13, 14, 15,
+        16, 17, 18,
+        19, 20, 21,
+        22, 23, 24
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        22, 23, 24,
+        19, 20, 21,
+        16, 17, 18,
+        13, 14, 15,
+        10, 11, 12,
+        7, 8, 9,
+        4, 5, 6,
+        1, 2, 3
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim4Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1, 2, 3});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9,
+        10, 11, 12,
+        13, 14, 15,
+        16, 17, 18,
+        19, 20, 21,
+        22, 23, 24
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+                                                                           24, 23, 22,
+                                                                           21, 20, 19,
+                                                                           18, 17, 16,
+                                                                           15, 14, 13,
+                                                                           12, 11, 10,
+                                                                           9, 8, 7,
+                                                                           6, 5, 4,
+                                                                           3, 2, 1
+                                                                   }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2EvenRowOddColTest2Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor. No axes set so output is the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 3}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        3, 2, 1,
+        6, 5, 4
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2EvenRowOddColTest3Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 3, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 3, 1}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        3, 2, 1,
+        6, 5, 4
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2EvenRowEvenColTest2Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3, 2, 1,
+        8, 7, 6, 5
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2EvenRowEvenColTest3Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3, 2, 1,
+        8, 7, 6, 5
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2OddRowOddColTest2Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({3, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({3, 3}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        3, 2, 1,
+        6, 5, 4,
+        9, 8, 7
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2OddRowOddColTest3Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({3, 3, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({3, 3, 1}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        3, 2, 1,
+        6, 5, 4,
+        9, 8, 7
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2OddRowEvenColTest2Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({3, 4}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8,
+        9, 10, 11, 12
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3, 2, 1,
+        8, 7, 6, 5,
+        12, 11, 10, 9
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2OddRowEvenColTest3Dim(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({3, 4, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({3, 4, 1}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8,
+        9, 10, 11, 12
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3, 2, 1,
+        8, 7, 6, 5,
+        12, 11, 10, 9
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2NegAxisTest2Dim1Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {-1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8,
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3, 2, 1,
+        8, 7, 6, 5
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<T, 2> ReverseV2NegAxisTest3Dim2Axis(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    // Simple test with default descriptor.  No axes set so output is
+    // the same as input
+    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, -1});
+
+    float qScale = 1.0f;
+    int32_t qOffset = 0;
+
+    armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+
+    std::vector<T> input = armnnUtils::QuantizedVector<T>({
+        1, 2, 3, 4,
+        5, 6, 7, 8,
+    }, qScale, qOffset);
+
+    std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
+        4, 3, 2, 1,
+        8, 7, 6, 5
+    }, qScale, qOffset);
+
+    return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
+                                              memoryManager,
+                                              tensorHandleFactory,
+                                              descriptor,
+                                              input,
+                                              outputExpected,
+                                              inputInfo,
+                                              outputInfo);
+}
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTestEmptyAxis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTestEmptyTensor<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest1Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest2Dim1Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest2Dim2Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest3Dim1Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest3Dim2Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest3Dim3Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest4Dim1Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest4Dim2Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest4Dim3Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2SimpleTest4Dim4Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2EvenRowOddColTest2Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2EvenRowOddColTest3Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2EvenRowEvenColTest2Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2EvenRowEvenColTest3Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2OddRowOddColTest2Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2OddRowOddColTest3Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2OddRowEvenColTest2Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2OddRowEvenColTest3Dim<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2NegAxisTest2Dim1Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2>
+ReverseV2NegAxisTest3Dim2Axis<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2>
+ReverseV2SimpleTest2Dim2Axis<armnn::DataType::Float16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2>
+ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QAsymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2>
+ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QAsymmU8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2>
+ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QSymmS16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file
diff --git a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.hpp
new file mode 100644
index 0000000000..a40e7734a0
--- /dev/null
+++ b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.hpp
@@ -0,0 +1,156 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnnTestUtils/LayerTestResult.hpp>
+
+#include <ResolveType.hpp>
+
+#include <armnn/backends/IBackendInternal.hpp>
+
+// Empty test cases
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTestEmptyAxis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTestEmptyTensor(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+// Multidimensional input tensor and multi-axis tests
+// These test cases are conducted with even-row-even-column input tensors
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest1Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest2Dim1Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest2Dim2Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest3Dim1Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest3Dim2Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest3Dim3Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim1Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim2Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim3Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2SimpleTest4Dim4Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+// Even and odd row number tests
+// These tests are conducted with 1-axis input param
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2EvenRowOddColTest2Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2EvenRowOddColTest3Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2EvenRowEvenColTest2Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2EvenRowEvenColTest3Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2OddRowOddColTest2Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2OddRowOddColTest3Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2OddRowEvenColTest2Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2OddRowEvenColTest3Dim(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+// Negative axis input tests with even-row-even-column input
+
+// one negative axis
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2NegAxisTest2Dim1Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+// one negative and one positive axis
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<T, 2> ReverseV2NegAxisTest3Dim2Axis(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file