IVGCVSW-5251 'Remove CreateTensorHandle for ArgMinMaxTestImpl'

* Refactored ArgMinMax tests to use TensorHandleFactory instead of WorkloadFactory


Signed-off-by: Sadik Armagan <sadik.armagan@arm.com>
Change-Id: Ibff0f9370972f9a0a977c05275cb6168f8f88ae5

5 files changed, 172 insertions, 127 deletions

diff --git a/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.cpp
index c2aad3d4fb..153d7269f7 100644
--- a/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.cpp
@@ -18,7 +18,8 @@ namespace
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 3> ArgMinMaxTestCommon(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         armnn::ArgMinMaxFunction argMinMaxFunction,
         const armnn::TensorInfo inputTensorInfo,
         const armnn::TensorInfo outputTensorInfo,
@@ -26,16 +27,13 @@ LayerTestResult<int32_t, 3> ArgMinMaxTestCommon(
         const std::vector<int32_t>& outputData,
         int axis = 3)
 {
-    IgnoreUnused(memoryManager);
     auto inputTensor = MakeTensor<T, 4>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputData, inputTensorInfo));
 
     LayerTestResult<int32_t, 3> result(outputTensorInfo);
     result.outputExpected = MakeTensor<int32_t, 3>(outputTensorInfo, outputData);
 
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
-    std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
-    ARMNN_NO_DEPRECATE_WARN_END
+    std::unique_ptr<armnn::ITensorHandle> inputHandle  = tensorHandleFactory->CreateTensorHandle(inputTensorInfo);
+    std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory->CreateTensorHandle(outputTensorInfo);
 
     armnn::ArgMinMaxQueueDescriptor descriptor;
     descriptor.m_Parameters.m_Function = argMinMaxFunction;
@@ -65,7 +63,8 @@ LayerTestResult<int32_t, 3> ArgMinMaxTestCommon(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 3> ArgMaxSimpleTest(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory)
 {
     const armnn::TensorShape inputShape{ 1, 1, 1, 5 };
     const armnn::TensorShape outputShape{ 1, 1, 1 };
@@ -83,7 +82,7 @@ LayerTestResult<int32_t, 3> ArgMaxSimpleTest(
     std::vector<float> inputValues({ 5.0f, 2.0f, 8.0f, 10.0f, 9.0f });
     std::vector<int32_t> outputValues({ 3 });
 
-    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager,
+    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory,
                                           armnn::ArgMinMaxFunction::Max,
                                           inputTensorInfo, outputTensorInfo,
                                           inputValues, outputValues, -1); // axis -1 === 3
@@ -92,7 +91,8 @@ LayerTestResult<int32_t, 3> ArgMaxSimpleTest(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 3> ArgMinSimpleTest(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory)
 {
     const armnn::TensorShape inputShape{ 1, 1, 1, 5 };
     const armnn::TensorShape outputShape{ 1, 1, 1 };
@@ -110,7 +110,7 @@ LayerTestResult<int32_t, 3> ArgMinSimpleTest(
     std::vector<float> inputValues({ 5.0f, 2.0f, 8.0f, 10.0f, 9.0f });
     std::vector<int32_t> outputValues({ 1 });
 
-    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager,
+    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory,
                                           armnn::ArgMinMaxFunction::Min,
                                           inputTensorInfo, outputTensorInfo,
                                           inputValues, outputValues, 3);
@@ -119,7 +119,8 @@ LayerTestResult<int32_t, 3> ArgMinSimpleTest(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 3> ArgMinChannelTest(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory)
 {
     const armnn::TensorShape inputShape{ 1, 3, 2, 4};
     const armnn::TensorShape outputShape{ 1, 2, 4 };
@@ -145,7 +146,7 @@ LayerTestResult<int32_t, 3> ArgMinChannelTest(
     std::vector<int32_t> outputValues({ 0, 0, 0, 0,
                                         0, 0, 0, 0 });
 
-    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager,
+    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory,
                                           armnn::ArgMinMaxFunction::Min,
                                           inputTensorInfo, outputTensorInfo,
                                           inputValues, outputValues, 1);
@@ -154,7 +155,8 @@ LayerTestResult<int32_t, 3> ArgMinChannelTest(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 3> ArgMaxChannelTest(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory)
 {
     const armnn::TensorShape inputShape{ 1, 3, 2, 4};
     const armnn::TensorShape outputShape{ 1, 2, 4 };
@@ -180,7 +182,7 @@ LayerTestResult<int32_t, 3> ArgMaxChannelTest(
     std::vector<int32_t> outputValues({ 2, 2, 2, 2,
                                         2, 2, 2, 2 });
 
-    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager,
+    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory,
                                           armnn::ArgMinMaxFunction::Max,
                                           inputTensorInfo, outputTensorInfo,
                                           inputValues, outputValues, 1);
@@ -189,7 +191,8 @@ LayerTestResult<int32_t, 3> ArgMaxChannelTest(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 3> ArgMaxHeightTest(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory)
 {
     const armnn::TensorShape inputShape{ 1, 3, 2, 4};
     const armnn::TensorShape outputShape{ 1, 3, 4 };
@@ -215,7 +218,7 @@ LayerTestResult<int32_t, 3> ArgMaxHeightTest(
                                         1, 1, 1, 1,
                                         1, 1, 1, 1 });
 
-    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager,
+    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory,
                                           armnn::ArgMinMaxFunction::Max,
                                           inputTensorInfo, outputTensorInfo,
                                           inputValues, outputValues, 2);
@@ -224,7 +227,8 @@ LayerTestResult<int32_t, 3> ArgMaxHeightTest(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 3> ArgMinWidthTest(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory)
 {
     const armnn::TensorShape inputShape{ 1, 3, 2, 4};
     const armnn::TensorShape outputShape{ 1, 3, 2 };
@@ -250,7 +254,7 @@ LayerTestResult<int32_t, 3> ArgMinWidthTest(
                                         0, 0,
                                         0, 0 });
 
-    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager,
+    return ArgMinMaxTestCommon<ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory,
                                           armnn::ArgMinMaxFunction::Min,
                                           inputTensorInfo, outputTensorInfo,
                                           inputValues, outputValues, 3);
@@ -262,169 +266,203 @@ LayerTestResult<int32_t, 3> ArgMinWidthTest(
 template LayerTestResult<int32_t, 3>
 ArgMaxSimpleTest<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxSimpleTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxSimpleTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxSimpleTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxSimpleTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxSimpleTest<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinSimpleTest<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinSimpleTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinSimpleTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinSimpleTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinSimpleTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinSimpleTest<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinChannelTest<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinChannelTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinChannelTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinChannelTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinChannelTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinChannelTest<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxChannelTest<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxChannelTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxChannelTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxChannelTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxChannelTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxChannelTest<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxHeightTest<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxHeightTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxHeightTest<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxHeightTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMaxHeightTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinWidthTest<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinWidthTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinWidthTest<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinWidthTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template LayerTestResult<int32_t, 3>
 ArgMinWidthTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory);
diff --git a/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.hpp
index 24deba71b7..2f3483e4bd 100644
--- a/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/ArgMinMaxTestImpl.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2019 Arm Ltd. All rights reserved.
+// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -11,27 +11,34 @@
 
 #include <armnn/backends/IBackendInternal.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
+#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 3> ArgMaxSimpleTest(armnn::IWorkloadFactory& workloadFactory,
-                                             const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+                                             const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                                             armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 3> ArgMinSimpleTest(armnn::IWorkloadFactory& workloadFactory,
-                                             const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+                                             const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                                             armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 3> ArgMinChannelTest(armnn::IWorkloadFactory& workloadFactory,
-                                              const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+                                              const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                                              armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 3> ArgMaxChannelTest(armnn::IWorkloadFactory& workloadFactory,
-                                              const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+                                              const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                                              armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 3> ArgMaxHeightTest(armnn::IWorkloadFactory& workloadFactory,
-                                             const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+                                             const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                                             armnn::ITensorHandleFactory* tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 3> ArgMinWidthTest(armnn::IWorkloadFactory& workloadFactory,
-                                            const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
\ No newline at end of file
+                                            const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                                            armnn::ITensorHandleFactory* tensorHandleFactory);
\ No newline at end of file
diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp
index cf0d2adc40..3da6b080a8 100644
--- a/src/backends/cl/test/ClLayerTests.cpp
+++ b/src/backends/cl/test/ClLayerTests.cpp
@@ -1181,19 +1181,19 @@ ARMNN_AUTO_TEST_CASE(Abs3dFloat16, Abs3dTest<DataType::Float16>)
 ARMNN_AUTO_TEST_CASE(AbsZeroFloat16, AbsZeroTest<DataType::Float16>)
 
 // ArgMinMax
-ARMNN_AUTO_TEST_CASE(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannel, ArgMinChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannel, ArgMaxChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeight, ArgMaxHeightTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidth, ArgMinWidthTest<DataType::Float32>)
-
-ARMNN_AUTO_TEST_CASE(ArgMinQAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxQAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelQAsymm8, ArgMinChannelTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelQAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeightQAsymm8, ArgMaxHeightTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidthQAsymm8, ArgMinWidthTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannel, ArgMinChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannel, ArgMaxChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeight, ArgMaxHeightTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidth, ArgMinWidthTest<DataType::Float32>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinQAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxQAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQAsymm8, ArgMinChannelTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightQAsymm8, ArgMaxHeightTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthQAsymm8, ArgMinWidthTest<DataType::QAsymmU8>)
 
 // Neg
 ARMNN_AUTO_TEST_CASE(Neg2d, Neg2dTest<DataType::Float32>)
diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp
index 0c5e2d0efe..70ba459d9d 100644
--- a/src/backends/neon/test/NeonLayerTests.cpp
+++ b/src/backends/neon/test/NeonLayerTests.cpp
@@ -1263,26 +1263,26 @@ ARMNN_AUTO_TEST_CASE(RsqrtZero, RsqrtZeroTest<DataType::Float32>)
 ARMNN_AUTO_TEST_CASE(RsqrtNegative, RsqrtNegativeTest<DataType::Float32>)
 
 // ArgMinMax
-ARMNN_AUTO_TEST_CASE(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannel, ArgMinChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannel, ArgMaxChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeight, ArgMaxHeightTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidth, ArgMinWidthTest<DataType::Float32>)
-
-ARMNN_AUTO_TEST_CASE(ArgMinQAsymmS8, ArgMinSimpleTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxQAsymmS8, ArgMaxSimpleTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelQAsymmS8, ArgMinChannelTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelQAsymmS8, ArgMaxChannelTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeightQAsymmS8, ArgMaxHeightTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidthQAsymmS8, ArgMinWidthTest<DataType::QAsymmS8>)
-
-ARMNN_AUTO_TEST_CASE(ArgMinQAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxQAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelQAsymm8, ArgMinChannelTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelQAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeightQAsymm8, ArgMaxHeightTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidthQAsymm8, ArgMinWidthTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannel, ArgMinChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannel, ArgMaxChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeight, ArgMaxHeightTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidth, ArgMinWidthTest<DataType::Float32>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinQAsymmS8, ArgMinSimpleTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxQAsymmS8, ArgMaxSimpleTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQAsymmS8, ArgMinChannelTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQAsymmS8, ArgMaxChannelTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightQAsymmS8, ArgMaxHeightTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthQAsymmS8, ArgMinWidthTest<DataType::QAsymmS8>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinQAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxQAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQAsymm8, ArgMinChannelTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightQAsymm8, ArgMaxHeightTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthQAsymm8, ArgMinWidthTest<DataType::QAsymmU8>)
 
 // Neg
 ARMNN_AUTO_TEST_CASE(Neg2d, Neg2dTest<DataType::Float32>)
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index 2ff289069f..b09a8ce504 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -1493,41 +1493,41 @@ ARMNN_AUTO_TEST_CASE(MeanVts3QuantisedSymm16, MeanVts3Test<DataType::QSymmS16>)
 ARMNN_AUTO_TEST_CASE(AdditionAfterMaxPool, AdditionAfterMaxPoolTest)
 
 // ArgMinMax
-ARMNN_AUTO_TEST_CASE(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelFloat32, ArgMinChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelFloat32, ArgMaxChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeightFloat32, ArgMaxHeightTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidthFloat32, ArgMinWidthTest<DataType::Float32>)
-
-ARMNN_AUTO_TEST_CASE(ArgMaxFloat16, ArgMaxSimpleTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(ArgMinFloat16, ArgMinSimpleTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelFloat16, ArgMinChannelTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelFloat16, ArgMaxChannelTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeightFloat16, ArgMaxHeightTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidthFloat16, ArgMinWidthTest<DataType::Float16>)
-
-ARMNN_AUTO_TEST_CASE(ArgMaxSigned32, ArgMaxSimpleTest<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(ArgMinSigned32, ArgMinSimpleTest<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelSigned32, ArgMinChannelTest<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelSigned32, ArgMaxChannelTest<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(ArgMaxHeightSigned32, ArgMaxHeightTest<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(ArgMinWidthSigned32, ArgMinWidthTest<DataType::Signed32>)
-
-ARMNN_AUTO_TEST_CASE(ArgMaxSimpleQuantisedAsymmS8, ArgMaxSimpleTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMinSimpleQuantisedAsymmS8, ArgMinSimpleTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelQuantisedAsymmS8, ArgMinChannelTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelQuantisedAsymmS8, ArgMaxChannelTest<DataType::QAsymmS8>)
-
-ARMNN_AUTO_TEST_CASE(ArgMaxSimpleQuantisedAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMinSimpleQuantisedAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelQuantisedAsymm8, ArgMinChannelTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelQuantisedAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>)
-
-ARMNN_AUTO_TEST_CASE(ArgMaxSimpleQuantisedSymm16, ArgMaxSimpleTest<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(ArgMinSimpleQuantisedSymm16, ArgMinSimpleTest<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(ArgMinChannelQuantisedSymm16, ArgMinChannelTest<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(ArgMaxChannelQuantisedSymm16, ArgMaxChannelTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelFloat32, ArgMinChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelFloat32, ArgMaxChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightFloat32, ArgMaxHeightTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthFloat32, ArgMinWidthTest<DataType::Float32>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxFloat16, ArgMaxSimpleTest<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinFloat16, ArgMinSimpleTest<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelFloat16, ArgMinChannelTest<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelFloat16, ArgMaxChannelTest<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightFloat16, ArgMaxHeightTest<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthFloat16, ArgMinWidthTest<DataType::Float16>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxSigned32, ArgMaxSimpleTest<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinSigned32, ArgMinSimpleTest<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelSigned32, ArgMinChannelTest<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelSigned32, ArgMaxChannelTest<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightSigned32, ArgMaxHeightTest<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthSigned32, ArgMinWidthTest<DataType::Signed32>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxSimpleQuantisedAsymmS8, ArgMaxSimpleTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinSimpleQuantisedAsymmS8, ArgMinSimpleTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQuantisedAsymmS8, ArgMinChannelTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQuantisedAsymmS8, ArgMaxChannelTest<DataType::QAsymmS8>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxSimpleQuantisedAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinSimpleQuantisedAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQuantisedAsymm8, ArgMinChannelTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQuantisedAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxSimpleQuantisedSymm16, ArgMaxSimpleTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinSimpleQuantisedSymm16, ArgMinSimpleTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQuantisedSymm16, ArgMinChannelTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQuantisedSymm16, ArgMaxChannelTest<DataType::QSymmS16>)
 
 // Space To Batch Nd
 ARMNN_AUTO_TEST_CASE(SpaceToBatchNdSimpleFloat32, SpaceToBatchNdSimpleFloat32Test)