IVGCVSW-5256 Use CreateTensorHandle() function from TensorHandleFactory in the tests for layers Q,R & T

Signed-off-by: Finn Williams <Finn.Williams@arm.com>

Change-Id: I6fc613d31785298a0b7ed18f1abdd59bafed1e8e

14 files changed, 1691 insertions, 1495 deletions

diff --git a/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.cpp
index d16669502a..5a36856e54 100644
--- a/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.cpp
@@ -23,6 +23,7 @@ template<typename T, std::size_t Dim>
 LayerTestResult<T, Dim> QuantizeTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::TensorInfo& inputTensorInfo,
     const armnn::TensorInfo& outputTensorInfo,
     const std::vector<float>& inputData,
@@ -35,10 +36,8 @@ LayerTestResult<T, Dim> QuantizeTestImpl(
     LayerTestResult<T, Dim> ret(outputTensorInfo);
     ret.outputExpected = MakeTensor<T, Dim>(outputTensorInfo, expectedOutputData);
 
-    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::WorkloadInfo info;
     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
@@ -61,7 +60,8 @@ LayerTestResult<T, Dim> QuantizeTestImpl(
 template <armnn::DataType ArmnnOutputType, typename T = armnn::ResolveType<ArmnnOutputType>>
 LayerTestResult<T, 4> QuantizeSimpleTest(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::QuantizeQueueDescriptor desc;
 
@@ -86,6 +86,7 @@ LayerTestResult<T, 4> QuantizeSimpleTest(
 
     return QuantizeTestImpl<T, 4>(workloadFactory,
                                   memoryManager,
+                                  tensorHandleFactory,
                                   inputTensorInfo,
                                   outputTensorInfo,
                                   inputData,
@@ -96,7 +97,8 @@ LayerTestResult<T, 4> QuantizeSimpleTest(
 template <armnn::DataType ArmnnOutputType, typename T = armnn::ResolveType<ArmnnOutputType>>
 LayerTestResult<T, 4> QuantizeClampTest(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::QuantizeQueueDescriptor desc;
 
@@ -118,6 +120,7 @@ LayerTestResult<T, 4> QuantizeClampTest(
 
     return QuantizeTestImpl<T, 4>(workloadFactory,
                                   memoryManager,
+                                  tensorHandleFactory,
                                   inputTensorInfo,
                                   outputTensorInfo,
                                   inputData,
@@ -129,35 +132,40 @@ LayerTestResult<T, 4> QuantizeClampTest(
 
 LayerTestResult<uint8_t, 4> QuantizeSimpleUint8Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    return QuantizeSimpleTest<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager);
+    return QuantizeSimpleTest<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 LayerTestResult<uint8_t, 4> QuantizeClampUint8Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    return QuantizeClampTest<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager);
+    return QuantizeClampTest<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 LayerTestResult<int8_t, 4> QuantizeClampAsymmInt8Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    return QuantizeClampTest<armnn::DataType::QAsymmS8>(workloadFactory, memoryManager);
+    return QuantizeClampTest<armnn::DataType::QAsymmS8>(workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 LayerTestResult<int8_t, 4> QuantizeClampInt8Test(
-        armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    return QuantizeClampTest<armnn::DataType::QSymmS8>(workloadFactory, memoryManager);
+    return QuantizeClampTest<armnn::DataType::QSymmS8>(workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 LayerTestResult<int16_t, 4> QuantizeClampInt16Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    return QuantizeClampTest<armnn::DataType::QSymmS16>(workloadFactory, memoryManager);
+    return QuantizeClampTest<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, tensorHandleFactory);
 }
diff --git a/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.hpp
index e16466c445..9e2f3dfe28 100644
--- a/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/QuantizeTestImpl.hpp
@@ -12,20 +12,25 @@
 
 LayerTestResult<uint8_t, 4> QuantizeSimpleUint8Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 LayerTestResult<uint8_t, 4> QuantizeClampUint8Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 LayerTestResult<int8_t, 4> QuantizeClampAsymmInt8Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 LayerTestResult<int8_t, 4> QuantizeClampInt8Test(
-        armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 LayerTestResult<int16_t, 4> QuantizeClampInt16Test(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
diff --git a/src/backends/backendsCommon/test/layerTests/RankTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/RankTestImpl.cpp
index f815968a7f..aeed272446 100644
--- a/src/backends/backendsCommon/test/layerTests/RankTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/RankTestImpl.cpp
@@ -16,7 +16,8 @@ LayerTestResult<int32_t, 1> RankTest(
         armnn::TensorInfo inputTensorInfo,
         boost::multi_array<T, n> input,
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     IgnoreUnused(memoryManager);
 
@@ -26,10 +27,8 @@ LayerTestResult<int32_t, 1> RankTest(
     LayerTestResult<int32_t , 1> ret(outputTensorInfo);
     ret.outputExpected = MakeTensor<uint32_t, 1>(outputTensorInfo, { n });
 
-    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::RankQueueDescriptor data;
     armnn::WorkloadInfo info;
@@ -53,46 +52,50 @@ LayerTestResult<int32_t, 1> RankTest(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 1> RankDimSize1Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo({6}, ArmnnType, 1.0f, 0);
     auto input = MakeTensor<T, 1>(inputTensorInfo, ConvertToDataType<ArmnnType>(
             { -37.5f, -15.2f, -8.76f, -2.0f, -1.3f, -0.5f },
             inputTensorInfo));
 
-    return RankTest<T, 1>(inputTensorInfo, input, workloadFactory, memoryManager);
+    return RankTest<T, 1>(inputTensorInfo, input, workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 1> RankDimSize2Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo({1, 3}, ArmnnType, 1.0f, 0);
     auto input = MakeTensor<T, 2>(inputTensorInfo, ConvertToDataType<ArmnnType>(
             { -37.5f, -15.2f, -8.76f },
             inputTensorInfo));
 
-    return RankTest<T, 2>(inputTensorInfo, input, workloadFactory, memoryManager);
+    return RankTest<T, 2>(inputTensorInfo, input, workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 1> RankDimSize3Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo({1, 3, 2}, ArmnnType, 1.0f, 0);
     auto input = MakeTensor<T, 3>(inputTensorInfo, ConvertToDataType<ArmnnType>(
             { -37.5f, -15.2f, -8.76f, -2.0f, -1.5f, -1.3f},
             inputTensorInfo));
 
-    return RankTest<T, 3>(inputTensorInfo, input, workloadFactory, memoryManager);
+    return RankTest<T, 3>(inputTensorInfo, input, workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<int32_t, 1> RankDimSize4Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo({1, 3, 2, 3}, ArmnnType, 1.0f, 0);
     auto input = MakeTensor<T, 4>(inputTensorInfo, ConvertToDataType<ArmnnType>(
@@ -100,165 +103,197 @@ LayerTestResult<int32_t, 1> RankDimSize4Test(
               1.0f, 0.4f, 0.5f, 1.3f, 1.5f, 2.0f, 8.76f, 15.2f, 37.5f },
             inputTensorInfo));
 
-    return RankTest<T, 4>(inputTensorInfo, input, workloadFactory, memoryManager);
+    return RankTest<T, 4>(inputTensorInfo, input, workloadFactory, memoryManager, tensorHandleFactory);
 }
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::QSymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize4Test<armnn::DataType::BFloat16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::QSymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize3Test<armnn::DataType::BFloat16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::QSymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize2Test<armnn::DataType::BFloat16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::Float32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::Signed32>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::QSymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<int32_t, 1>
 RankDimSize1Test<armnn::DataType::BFloat16>(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
\ No newline at end of file
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file
diff --git a/src/backends/backendsCommon/test/layerTests/RankTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/RankTestImpl.hpp
index ac82ac949d..2757eceb8a 100644
--- a/src/backends/backendsCommon/test/layerTests/RankTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/RankTestImpl.hpp
@@ -17,24 +17,29 @@ LayerTestResult<int32_t, 1> RankTest(
         armnn::TensorInfo inputTensorInfo,
         boost::multi_array<T, n> input,
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 1> RankDimSize1Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 1> RankDimSize2Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 1> RankDimSize3Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<int32_t, 1> RankDimSize4Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
diff --git a/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.cpp
index 1e528a0fdc..d233e89be8 100644
--- a/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.cpp
@@ -18,6 +18,7 @@ template<typename T, size_t NumDims>
 LayerTestResult<T, NumDims> SimpleReshapeTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     armnn::TensorInfo inputTensorInfo,
     armnn::TensorInfo outputTensorInfo,
     const std::vector<T>& inputData,
@@ -29,10 +30,8 @@ LayerTestResult<T, NumDims> SimpleReshapeTestImpl(
     LayerTestResult<T, NumDims> ret(outputTensorInfo);
     ret.outputExpected = MakeTensor<T, NumDims>(outputTensorInfo, outputExpectedData);
 
-    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::ReshapeQueueDescriptor data;
     armnn::WorkloadInfo info;
@@ -58,7 +57,8 @@ LayerTestResult<T, NumDims> SimpleReshapeTestImpl(
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> SimpleReshapeTest(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -104,13 +104,14 @@ LayerTestResult<T, 4> SimpleReshapeTest(
         outputTensorInfo);
 
     return SimpleReshapeTestImpl<T, 4>(
-        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected);
+        workloadFactory, memoryManager, tensorHandleFactory, inputTensorInfo, outputTensorInfo, input, outputExpected);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 5> Reshape5dTest(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -166,7 +167,7 @@ LayerTestResult<T, 5> Reshape5dTest(
         outputTensorInfo);
 
     return SimpleReshapeTestImpl<T, 5>(
-        workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected);
+        workloadFactory, memoryManager, tensorHandleFactory, inputTensorInfo, outputTensorInfo, input, outputExpected);
 }
 
 //
@@ -176,39 +177,47 @@ LayerTestResult<T, 5> Reshape5dTest(
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 SimpleReshapeTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 SimpleReshapeTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 SimpleReshapeTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 SimpleReshapeTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 5>
 Reshape5dTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 5>
 Reshape5dTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 5>
 Reshape5dTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 5>
 Reshape5dTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
diff --git a/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.hpp
index 2bc1d2c78c..661702b9e7 100644
--- a/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/ReshapeTestImpl.hpp
@@ -15,9 +15,11 @@
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> SimpleReshapeTest(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 5> Reshape5dTest(
     armnn::IWorkloadFactory& workloadFactory,
-    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
diff --git a/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.cpp
index f3c72709e0..a2a804d54e 100644
--- a/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.cpp
@@ -76,6 +76,7 @@ template<size_t NumDims,
 LayerTestResult<T, NumDims> ResizeTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const ResizeTestParams& params)
 {
     IgnoreUnused(memoryManager);
@@ -109,10 +110,9 @@ LayerTestResult<T, NumDims> ResizeTestImpl(
 
     LayerTestResult<T, NumDims> result(outputInfo);
     result.outputExpected = MakeTensor<T, NumDims>(outputInfo, expectedOutputData);
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    std::unique_ptr<armnn::ITensorHandle> inputHandle  = workloadFactory.CreateTensorHandle(inputInfo);
-    std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputInfo);
-    ARMNN_NO_DEPRECATE_WARN_END
+
+    std::unique_ptr<armnn::ITensorHandle> inputHandle  = tensorHandleFactory.CreateTensorHandle(inputInfo);
+    std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
 
     armnn::ResizeQueueDescriptor descriptor;
     descriptor.m_Parameters.m_Method     = params.m_ResizeMethod;
@@ -151,6 +151,7 @@ template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeBilinearNopTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -177,13 +178,14 @@ LayerTestResult<T, 4> ResizeBilinearNopTest(
 
     testParams.SetInOutQuantParams(1.5f, 3);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> SimpleResizeBilinearTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -216,13 +218,14 @@ LayerTestResult<T, 4> SimpleResizeBilinearTest(
 
     testParams.SetInOutQuantParams(0.1567f, 1);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeBilinearSqMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -256,13 +259,14 @@ LayerTestResult<T, 4> ResizeBilinearSqMinTest(
 
     testParams.SetInOutQuantParams(3.141592f, 3);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeBilinearMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -294,13 +298,14 @@ LayerTestResult<T, 4> ResizeBilinearMinTest(
 
     testParams.SetInOutQuantParams(1.5f, -1);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeBilinearMagTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -334,7 +339,7 @@ LayerTestResult<T, 4> ResizeBilinearMagTest(
 
     testParams.SetInQuantParams(1.0f, 0);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 //
@@ -345,6 +350,7 @@ template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeNearestNeighborNopTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -371,13 +377,14 @@ LayerTestResult<T, 4> ResizeNearestNeighborNopTest(
 
     testParams.SetInOutQuantParams(1.5f, 3);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> SimpleResizeNearestNeighborTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -410,13 +417,14 @@ LayerTestResult<T, 4> SimpleResizeNearestNeighborTest(
 
     testParams.SetInOutQuantParams(0.1567f, 1);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeNearestNeighborSqMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -450,13 +458,14 @@ LayerTestResult<T, 4> ResizeNearestNeighborSqMinTest(
 
     testParams.SetInOutQuantParams(3.141592f, 3);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeNearestNeighborMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
         ResizeTestParams testParams;
@@ -488,13 +497,14 @@ LayerTestResult<T, 4> ResizeNearestNeighborMinTest(
 
     testParams.SetInOutQuantParams(1.5f, -1);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> ResizeNearestNeighborMagTest(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout,
         float inQuantScale,
         int32_t inQuantOffset,
@@ -533,13 +543,14 @@ LayerTestResult<T, 4> ResizeNearestNeighborMagTest(
     testParams.SetInQuantParams(inQuantScale, inQuantOffset);
     testParams.SetOutQuantParams(outQuantScale, outQuantOffset);
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> HalfPixelCentersResizeBilinearTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -570,13 +581,14 @@ LayerTestResult<T, 4> HalfPixelCentersResizeBilinearTest(
           3.0f, 3.5f, 4.0f,
     };
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> AlignCornersResizeBilinearTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -598,13 +610,14 @@ LayerTestResult<T, 4> AlignCornersResizeBilinearTest(
           1.0f
     };
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> HalfPixelCentersResizeNearestNeighbourTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -628,13 +641,14 @@ LayerTestResult<T, 4> HalfPixelCentersResizeNearestNeighbourTest(
           2.0f, 4.0f
     };
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 template<armnn::DataType ArmnnType, typename T>
 LayerTestResult<T, 4> AlignCornersResizeNearestNeighbourTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout)
 {
     ResizeTestParams testParams;
@@ -656,7 +670,7 @@ LayerTestResult<T, 4> AlignCornersResizeNearestNeighbourTest(
           1.0f
     };
 
-    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, testParams);
+    return ResizeTestImpl<4, ArmnnType>(workloadFactory, memoryManager, tensorHandleFactory, testParams);
 }
 
 //
@@ -668,60 +682,70 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeBilinearNopTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 SimpleResizeBilinearTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeBilinearSqMinTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeBilinearMinTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeBilinearMagTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeNearestNeighborNopTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 SimpleResizeNearestNeighborTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeNearestNeighborSqMinTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeNearestNeighborMinTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 ResizeNearestNeighborMagTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout,
     float inQuantScale,
     int32_t inQuantOffset,
@@ -732,24 +756,28 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 HalfPixelCentersResizeBilinearTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 AlignCornersResizeBilinearTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 HalfPixelCentersResizeNearestNeighbourTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 AlignCornersResizeNearestNeighbourTest<armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 // Float16
@@ -757,60 +785,70 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeBilinearNopTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 SimpleResizeBilinearTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeBilinearSqMinTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeBilinearMinTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeBilinearMagTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeNearestNeighborNopTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 SimpleResizeNearestNeighborTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeNearestNeighborSqMinTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeNearestNeighborMinTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 ResizeNearestNeighborMagTest<armnn::DataType::Float16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout,
     float inQuantScale,
     int32_t inQuantOffset,
@@ -821,24 +859,28 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 HalfPixelCentersResizeBilinearTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 AlignCornersResizeBilinearTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 HalfPixelCentersResizeNearestNeighbourTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 AlignCornersResizeNearestNeighbourTest<armnn::DataType::Float16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 // QAsymm8
@@ -846,60 +888,70 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeBilinearNopTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 SimpleResizeBilinearTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeBilinearSqMinTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeBilinearMinTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeBilinearMagTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeNearestNeighborNopTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 SimpleResizeNearestNeighborTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeNearestNeighborSqMinTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeNearestNeighborMinTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 ResizeNearestNeighborMagTest<armnn::DataType::QAsymmU8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout,
     float inQuantScale,
     int32_t inQuantOffset,
@@ -910,24 +962,28 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 HalfPixelCentersResizeBilinearTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 AlignCornersResizeBilinearTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 HalfPixelCentersResizeNearestNeighbourTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 AlignCornersResizeNearestNeighbourTest<armnn::DataType::QAsymmS8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 // QAsymmS8
@@ -935,60 +991,70 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeBilinearNopTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 SimpleResizeBilinearTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeBilinearSqMinTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeBilinearMinTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeBilinearMagTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeNearestNeighborNopTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 SimpleResizeNearestNeighborTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeNearestNeighborSqMinTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeNearestNeighborMinTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 ResizeNearestNeighborMagTest<armnn::DataType::QAsymmS8>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout,
     float inQuantScale,
     int32_t inQuantOffset,
@@ -999,24 +1065,28 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 HalfPixelCentersResizeBilinearTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 AlignCornersResizeBilinearTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 HalfPixelCentersResizeNearestNeighbourTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 AlignCornersResizeNearestNeighbourTest<armnn::DataType::QAsymmU8>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 // QSymm16
@@ -1024,60 +1094,70 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeBilinearNopTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 SimpleResizeBilinearTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeBilinearSqMinTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeBilinearMinTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeBilinearMagTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeNearestNeighborNopTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 SimpleResizeNearestNeighborTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeNearestNeighborSqMinTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeNearestNeighborMinTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 ResizeNearestNeighborMagTest<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout,
     float inQuantScale,
     int32_t inQuantOffset,
@@ -1088,22 +1168,26 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 HalfPixelCentersResizeBilinearTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 AlignCornersResizeBilinearTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 HalfPixelCentersResizeNearestNeighbourTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 AlignCornersResizeNearestNeighbourTest<armnn::DataType::QSymmS16>(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         const armnn::DataLayout dataLayout);
\ No newline at end of file
diff --git a/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.hpp
index b70ae85b8f..ce7d41910c 100644
--- a/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/ResizeTestImpl.hpp
@@ -19,30 +19,35 @@ template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeBilinearNopTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> SimpleResizeBilinearTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeBilinearSqMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeBilinearMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeBilinearMagTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 // NearestNeighbor
@@ -50,30 +55,35 @@ template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeNearestNeighborNopTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> SimpleResizeNearestNeighborTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeNearestNeighborSqMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeNearestNeighborMinTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> ResizeNearestNeighborMagTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout,
     float inQuantScale,
     int32_t inQuantOffset,
@@ -84,22 +94,26 @@ template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> HalfPixelCentersResizeBilinearTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> AlignCornersResizeBilinearTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> HalfPixelCentersResizeNearestNeighbourTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> AlignCornersResizeNearestNeighbourTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout dataLayout);
\ No newline at end of file
diff --git a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp
index d5a045eec7..328e724b54 100644
--- a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.cpp
@@ -45,6 +45,7 @@ void VerifyInputTensorData(const TensorData<T>& data, const std::string& tensorN
 template<typename T, typename BT>
 void TransposeConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
                                     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+                                    const armnn::ITensorHandleFactory& tensorHandleFactory,
                                     const armnn::TransposeConvolution2dDescriptor& descriptor,
                                     const TensorData<T>& input,
                                     TensorData<T>& output,
@@ -85,11 +86,9 @@ void TransposeConvolution2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
         AllocateAndCopyDataToITensorHandle(biasesTensor.get(), biases.value().second.data());
     }
 
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
     // set up input and output handles
-    std::unique_ptr<ITensorHandle> inputHandle  = workloadFactory.CreateTensorHandle(input.first);
-    std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(output.first);
-    ARMNN_NO_DEPRECATE_WARN_END
+    std::unique_ptr<ITensorHandle> inputHandle  = tensorHandleFactory.CreateTensorHandle(input.first);
+    std::unique_ptr<ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(output.first);
 
     // set up workload
     armnn::WorkloadInfo workloadInfo;
@@ -115,6 +114,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = arm
 LayerTestResult<T, 4> TransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::TransposeConvolution2dDescriptor& descriptor,
     armnn::TensorInfo& inputInfo,
     const std::vector<float>& inputData,
@@ -183,7 +183,8 @@ LayerTestResult<T, 4> TransposeConvolution2dTest(
 
     // execute test
     TransposeConvolution2dTestImpl(workloadFactory,
-                                   memoryManager,
+                                                             memoryManager,
+                                                             tensorHandleFactory,
                                    descriptor,
                                    input,
                                    output,
@@ -220,6 +221,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
 LayerTestResult<T, 4> SimpleTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout)
 {
@@ -292,6 +294,7 @@ LayerTestResult<T, 4> SimpleTransposeConvolution2dTest(
 
     return TransposeConvolution2dTest<ArmnnType, ArmnnBType>(workloadFactory,
                                                              memoryManager,
+                                                             tensorHandleFactory,
                                                              descriptor,
                                                              inputInfo,
                                                              inputData,
@@ -307,6 +310,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
 LayerTestResult<T, 4> PaddedTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout)
 {
@@ -381,6 +385,7 @@ LayerTestResult<T, 4> PaddedTransposeConvolution2dTest(
 
     return TransposeConvolution2dTest<ArmnnType, ArmnnBType>(workloadFactory,
                                                              memoryManager,
+                                                             tensorHandleFactory,
                                                              descriptor,
                                                              inputInfo,
                                                              inputData,
@@ -396,6 +401,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
 LayerTestResult<T, 4> StridedTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout)
 {
@@ -470,6 +476,7 @@ LayerTestResult<T, 4> StridedTransposeConvolution2dTest(
 
     return TransposeConvolution2dTest<ArmnnType, ArmnnBType>(workloadFactory,
                                                              memoryManager,
+                                                             tensorHandleFactory,
                                                              descriptor,
                                                              inputInfo,
                                                              inputData,
@@ -485,6 +492,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
 LayerTestResult<T, 4> MultiChannelTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout)
 {
     using namespace armnn;
@@ -549,6 +557,7 @@ LayerTestResult<T, 4> MultiChannelTransposeConvolution2dTest(
 
     return TransposeConvolution2dTest<ArmnnType, ArmnnBType>(workloadFactory,
                                                              memoryManager,
+                                                             tensorHandleFactory,
                                                              descriptor,
                                                              inputInfo,
                                                              inputData,
@@ -563,6 +572,7 @@ LayerTestResult<T, 4> MultiChannelTransposeConvolution2dTest(
 LayerTestResult<uint8_t, 4> TransposeConvolution2dPerAxisQuantTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout)
 {
    using namespace armnn;
@@ -629,10 +639,8 @@ LayerTestResult<uint8_t, 4> TransposeConvolution2dPerAxisQuantTest(
     descriptor.m_BiasEnabled = true;
     descriptor.m_DataLayout  = layout;
 
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    std::unique_ptr<ITensorHandle> inputHandle  = workloadFactory.CreateTensorHandle(inputInfo);
-    std::unique_ptr<ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputInfo);
-    ARMNN_NO_DEPRECATE_WARN_END
+    std::unique_ptr<ITensorHandle> inputHandle  = tensorHandleFactory.CreateTensorHandle(inputInfo);
+    std::unique_ptr<ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
 
     WorkloadInfo workloadInfo;
     ScopedCpuTensorHandle weightTensor(kernelInfo);
@@ -672,6 +680,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 SimpleTransposeConvolution2dTest<armnn::DataType::Float32, armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -679,6 +688,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 SimpleTransposeConvolution2dTest<armnn::DataType::QAsymmS8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -686,6 +696,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 SimpleTransposeConvolution2dTest<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -693,6 +704,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 SimpleTransposeConvolution2dTest<armnn::DataType::QSymmS16, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -700,6 +712,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 PaddedTransposeConvolution2dTest<armnn::DataType::Float32, armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -707,6 +720,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 PaddedTransposeConvolution2dTest<armnn::DataType::QAsymmS8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -714,6 +728,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 PaddedTransposeConvolution2dTest<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -721,6 +736,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 PaddedTransposeConvolution2dTest<armnn::DataType::QSymmS16, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -728,6 +744,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 StridedTransposeConvolution2dTest<armnn::DataType::Float32, armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -735,6 +752,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 StridedTransposeConvolution2dTest<armnn::DataType::QAsymmS8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -742,6 +760,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 StridedTransposeConvolution2dTest<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -749,6 +768,7 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 StridedTransposeConvolution2dTest<armnn::DataType::QSymmS16, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -756,22 +776,26 @@ template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 MultiChannelTransposeConvolution2dTest<armnn::DataType::Float32, armnn::DataType::Float32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 4>
 MultiChannelTransposeConvolution2dTest<armnn::DataType::QAsymmS8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 4>
 MultiChannelTransposeConvolution2dTest<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout);
 
 template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 4>
 MultiChannelTransposeConvolution2dTest<armnn::DataType::QSymmS16, armnn::DataType::Signed32>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout);
diff --git a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp
index 76e66d713b..0c45b0fb9b 100644
--- a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp
@@ -16,6 +16,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = arm
 LayerTestResult<T, 4> SimpleTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -23,6 +24,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = arm
 LayerTestResult<T, 4> PaddedTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -30,6 +32,7 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = arm
 LayerTestResult<T, 4> StridedTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     bool biasEnabled,
     const armnn::DataLayout layout);
 
@@ -37,9 +40,11 @@ template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = arm
 LayerTestResult<T, 4> MultiChannelTransposeConvolution2dTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout);
 
 LayerTestResult<uint8_t, 4> TransposeConvolution2dPerAxisQuantTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory,
     const armnn::DataLayout layout);
diff --git a/src/backends/backendsCommon/test/layerTests/TransposeTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/TransposeTestImpl.hpp
index c014078d12..d0f9e82197 100644
--- a/src/backends/backendsCommon/test/layerTests/TransposeTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/TransposeTestImpl.hpp
@@ -16,22 +16,23 @@
 
 #include <test/TensorHelpers.hpp>
 
-template<typename FactoryType, typename T>
+template<typename T>
 LayerTestResult<T, 4> SimpleTransposeTestImpl(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory,
         armnn::TransposeDescriptor descriptor,
         armnn::TensorInfo inputTensorInfo,
         armnn::TensorInfo outputTensorInfo,
         const std::vector<T>& inputData,
         const std::vector<T>& outputExpectedData)
 {
+    IgnoreUnused(memoryManager);
     auto input = MakeTensor<T, 4>(inputTensorInfo, inputData);
 
     LayerTestResult<T, 4> ret(outputTensorInfo);
     ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputExpectedData);
 
-    auto tensorHandleFactory = WorkloadFactoryHelper<FactoryType>::GetTensorHandleFactory(memoryManager);
     std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
     std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
 
@@ -55,10 +56,11 @@ LayerTestResult<T, 4> SimpleTransposeTestImpl(
     return ret;
 }
 
-template<typename FactoryType, armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> SimpleTransposeTest(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -99,15 +101,16 @@ LayerTestResult<T, 4> SimpleTransposeTest(
     },
     qScale, qOffset);
 
-    return SimpleTransposeTestImpl<FactoryType, T>(workloadFactory, memoryManager,
-                                                   descriptor, inputTensorInfo,
-                                                   outputTensorInfo, input, outputExpected);
+    return SimpleTransposeTestImpl(workloadFactory, memoryManager, tensorHandleFactory,
+                                   descriptor, inputTensorInfo,
+                                   outputTensorInfo, input, outputExpected);
 }
 
-template<typename FactoryType, armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> TransposeValueSet1Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -149,15 +152,16 @@ LayerTestResult<T, 4> TransposeValueSet1Test(
     },
     qScale, qOffset);
 
-    return SimpleTransposeTestImpl<FactoryType, T>(workloadFactory, memoryManager,
-                                                   descriptor, inputTensorInfo,
-                                                   outputTensorInfo, input, outputExpected);
+    return SimpleTransposeTestImpl<T>(workloadFactory, memoryManager, tensorHandleFactory,
+                                      descriptor, inputTensorInfo,
+                                      outputTensorInfo, input, outputExpected);
 }
 
-template<typename FactoryType, armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> TransposeValueSet2Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -199,15 +203,16 @@ LayerTestResult<T, 4> TransposeValueSet2Test(
     },
     qScale, qOffset);
 
-    return SimpleTransposeTestImpl<FactoryType, T>(workloadFactory, memoryManager,
-                                                   descriptor, inputTensorInfo,
-                                                   outputTensorInfo, input, outputExpected);
+    return SimpleTransposeTestImpl<T>(workloadFactory, memoryManager, tensorHandleFactory,
+                                      descriptor, inputTensorInfo,
+                                      outputTensorInfo, input, outputExpected);
 }
 
-template<typename FactoryType, armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> TransposeValueSet3Test(
         armnn::IWorkloadFactory& workloadFactory,
-        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
     armnn::TensorInfo inputTensorInfo;
     armnn::TensorInfo outputTensorInfo;
@@ -251,7 +256,7 @@ LayerTestResult<T, 4> TransposeValueSet3Test(
     },
     qScale, qOffset);
 
-    return SimpleTransposeTestImpl<FactoryType, T>(workloadFactory, memoryManager,
-                                                   descriptor, inputTensorInfo,
-                                                   outputTensorInfo, input, outputExpected);
+    return SimpleTransposeTestImpl<T>(workloadFactory, memoryManager, tensorHandleFactory,
+                                      descriptor, inputTensorInfo,
+                                      outputTensorInfo, input, outputExpected);
 }
diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp
index 898944216e..7da4029cdf 100644
--- a/src/backends/cl/test/ClLayerTests.cpp
+++ b/src/backends/cl/test/ClLayerTests.cpp
@@ -481,10 +481,10 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(GatherMultiDimParamsFloat32, GatherMultiDimParamsF
 ARMNN_AUTO_TEST_CASE_WITH_THF(GatherMultiDimParamsUint8, GatherMultiDimParamsUint8Test)
 
 // Reshape
-ARMNN_AUTO_TEST_CASE(SimpleReshapeFloat32, SimpleReshapeTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(SimpleReshapeInt8, SimpleReshapeTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(SimpleReshapeUint8, SimpleReshapeTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(Reshape5d, Reshape5dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeFloat32, SimpleReshapeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeInt8, SimpleReshapeTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeUint8, SimpleReshapeTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(Reshape5d, Reshape5dTest<DataType::Float32>)
 
 // Pad
 ARMNN_AUTO_TEST_CASE_WITH_THF(PadFloat322d, PadFloat322dTest)
@@ -785,250 +785,250 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dUint8, StridedSlice2dUint8Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dReverseUint8, StridedSlice2dReverseUint8Test)
 
 // Resize Bilinear - NCHW
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinear,
-                     SimpleResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearInt8,
-                     SimpleResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8,
-                     SimpleResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNop,
-                     ResizeBilinearNopTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopInt8,
-                     ResizeBilinearNopTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8,
-                     ResizeBilinearNopTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMin,
-                     ResizeBilinearSqMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinInt8,
-                     ResizeBilinearSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8,
-                     ResizeBilinearSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMin,
-                     ResizeBilinearMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinInt8,
-                     ResizeBilinearMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8,
-                     ResizeBilinearMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinear,
+                              SimpleResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8,
+                              SimpleResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8,
+                              SimpleResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNop,
+                              ResizeBilinearNopTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8,
+                              ResizeBilinearNopTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8,
+                              ResizeBilinearNopTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMin,
+                              ResizeBilinearSqMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8,
+                              ResizeBilinearSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8,
+                              ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMin,
+                              ResizeBilinearMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8,
+                              ResizeBilinearMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8,
+                              ResizeBilinearMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinear,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinear,
-                     AlignCornersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearInt8,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearInt8,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint8,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint8,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinear,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinear,
+                              AlignCornersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
 
 // Resize Bilinear - NHWC
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwc,
-                     ResizeBilinearNopTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopInt8Nhwc,
-                     ResizeBilinearNopTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8Nhwc,
-                     ResizeBilinearNopTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwc,
-                     SimpleResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearInt8Nhwc,
-                     SimpleResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8Nhwc,
-                     SimpleResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwc,
-                     ResizeBilinearSqMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinInt8Nhwc,
-                     ResizeBilinearSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8Nhwc,
-                     ResizeBilinearSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwc,
-                     ResizeBilinearMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinInt8Nhwc,
-                     ResizeBilinearMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8Nhwc,
-                     ResizeBilinearMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearNhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearNhwc,
-                     AlignCornersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearInt8Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearInt8Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint8Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint8Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopNhwc,
+                              ResizeBilinearNopTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8Nhwc,
+                              ResizeBilinearNopTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8Nhwc,
+                              ResizeBilinearNopTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearNhwc,
+                              SimpleResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8Nhwc,
+                              SimpleResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8Nhwc,
+                              SimpleResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinNhwc,
+                              ResizeBilinearSqMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8Nhwc,
+                              ResizeBilinearSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8Nhwc,
+                              ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinNhwc,
+                              ResizeBilinearMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8Nhwc,
+                              ResizeBilinearMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8Nhwc,
+                              ResizeBilinearMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearNhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearNhwc,
+                              AlignCornersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
 
 // Resize NearestNeighbor - NCHW
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighbor,
-                     SimpleResizeNearestNeighborTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborInt8,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNop,
-                     ResizeNearestNeighborNopTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopInt8,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMin,
-                     ResizeNearestNeighborSqMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinInt8,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMin,
-                     ResizeNearestNeighborMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinInt8,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMag,
-                     ResizeNearestNeighborMagTest<DataType::Float32>,
-                     DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagInt8,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
-
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbour,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbour,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourInt8,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourInt8,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint8,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint8,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighbor,
+                              SimpleResizeNearestNeighborTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNop,
+                              ResizeNearestNeighborNopTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMin,
+                              ResizeNearestNeighborSqMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMin,
+                              ResizeNearestNeighborMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMag,
+                              ResizeNearestNeighborMagTest<DataType::Float32>,
+                              DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbour,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbour,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
 
 // Resize NearestNeighbor - NHWC
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopNhwc,
-                     ResizeNearestNeighborNopTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopInt8Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborNhwc,
-                     SimpleResizeNearestNeighborTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborInt8Nhwc,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8Nhwc,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinNhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinInt8Nhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8Nhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinNhwc,
-                     ResizeNearestNeighborMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinInt8Nhwc,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8Nhwc,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagNhwc,
-                     ResizeNearestNeighborMagTest<DataType::Float32>,
-                     DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagInt8Nhwc,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8Nhwc,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourNhwc,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourNhwc,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourInt8Nhwc,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourInt8Nhwc,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint8Nhwc,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint8Nhwc,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopNhwc,
+                              ResizeNearestNeighborNopTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborNhwc,
+                              SimpleResizeNearestNeighborTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8Nhwc,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8Nhwc,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinNhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8Nhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8Nhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinNhwc,
+                              ResizeNearestNeighborMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8Nhwc,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8Nhwc,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagNhwc,
+                              ResizeNearestNeighborMagTest<DataType::Float32>,
+                              DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8Nhwc,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8Nhwc,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourNhwc,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourNhwc,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8Nhwc,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8Nhwc,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8Nhwc,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8Nhwc,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
 
 // Rsqrt
 ARMNN_AUTO_TEST_CASE_WITH_THF(Rsqrt2d, Rsqrt2dTest<DataType::Float32>)
@@ -1037,8 +1037,8 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(RsqrtZero, RsqrtZeroTest<DataType::Float32>)
 ARMNN_AUTO_TEST_CASE_WITH_THF(RsqrtNegative, RsqrtNegativeTest<DataType::Float32>)
 
 // Quantize
-ARMNN_AUTO_TEST_CASE(QuantizeSimpleUint8, QuantizeSimpleUint8Test)
-ARMNN_AUTO_TEST_CASE(QuantizeClampUint8, QuantizeClampUint8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeSimpleUint8, QuantizeSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeClampUint8, QuantizeClampUint8Test)
 
 // Dequantize
 ARMNN_AUTO_TEST_CASE(DequantizeSimpleUint8, DequantizeSimpleUint8Test)
@@ -1048,138 +1048,138 @@ ARMNN_AUTO_TEST_CASE(DequantizeSimpleUint8ToFp16, DequantizeSimpleUint8ToFp16Tes
 ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt16ToFp16, DequantizeSimpleInt16ToFp16Test)
 
 // Transpose
-ARMNN_AUTO_TEST_CASE(SimpleTransposeFloat32, SimpleTransposeTest<ClWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet1Test, TransposeValueSet1Test<ClWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet2Test, TransposeValueSet2Test<ClWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet3Test, TransposeValueSet3Test<ClWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQASymmS8, SimpleTransposeTest<ClWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test<ClWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test<ClWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test<ClWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQASymm8, SimpleTransposeTest<ClWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test<ClWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test<ClWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test<ClWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQSymm16, SimpleTransposeTest<ClWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test<ClWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test<ClWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test<ClWorkloadFactory, DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeFloat32, SimpleTransposeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet1Test, TransposeValueSet1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet2Test, TransposeValueSet2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet3Test, TransposeValueSet3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymmS8, SimpleTransposeTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymm8, SimpleTransposeTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQSymm16, SimpleTransposeTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test<DataType::QSymmS16>)
 
 // TransposeConvolution2d
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNchw,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNhwc,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNchw,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNchw,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNhwc,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNchw,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNchw,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNhwc,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNchw,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNhwc,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNchw,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNhwc,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNchw,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNchw,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNhwc,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNchw,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNchw,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNhwc,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNchw,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNhwc,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
 
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNchw,
-                     MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNhwc,
-                     MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nchw,
-                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nhwc,
-                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNchw,
+                              MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNhwc,
+                              MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nchw,
+                              MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nhwc,
+                              MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              DataLayout::NHWC)
 
 // Abs
 ARMNN_AUTO_TEST_CASE_WITH_THF(Abs2d, Abs2dTest<DataType::Float32>)
diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp
index 974473dbf2..20afbcb701 100644
--- a/src/backends/neon/test/NeonLayerTests.cpp
+++ b/src/backends/neon/test/NeonLayerTests.cpp
@@ -743,10 +743,10 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1ElementUint8, NotEqualBroadcast1
 ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1dVectorUint8, NotEqualBroadcast1dVectorUint8Test)
 
 // Reshape
-ARMNN_AUTO_TEST_CASE(SimpleReshapeFloat32, SimpleReshapeTest<armnn::DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(SimpleReshapeInt8, SimpleReshapeTest<armnn::DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(SimpleReshapeUint8, SimpleReshapeTest<armnn::DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(Reshape5d, Reshape5dTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeFloat32, SimpleReshapeTest<armnn::DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeInt8, SimpleReshapeTest<armnn::DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeUint8, SimpleReshapeTest<armnn::DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(Reshape5d, Reshape5dTest<armnn::DataType::Float32>)
 
 // Pad
 ARMNN_AUTO_TEST_CASE_WITH_THF(PadFloat322d, PadFloat322dTest)
@@ -840,202 +840,202 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleNormalizationWithin, SimpleNormalizationWith
 ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleNormalizationAcrossNhwc, SimpleNormalizationAcrossNhwcTest)
 
 // Resize Bilinear - NCHW data layout
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinear, SimpleResizeBilinearTest<DataType::Float32>, DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNop, ResizeBilinearNopTest<DataType::Float32>, DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMin, ResizeBilinearSqMinTest<DataType::Float32>, DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMin, ResizeBilinearMinTest<DataType::Float32>, DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMag, ResizeBilinearMagTest<DataType::Float32>, DataLayout::NCHW)
-
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8,
-                     SimpleResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8,
-                     ResizeBilinearNopTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8,
-                     ResizeBilinearSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8,
-                     ResizeBilinearMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8,
-                     ResizeBilinearMagTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinear, SimpleResizeBilinearTest<DataType::Float32>, DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNop, ResizeBilinearNopTest<DataType::Float32>, DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMin, ResizeBilinearSqMinTest<DataType::Float32>, DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMin, ResizeBilinearMinTest<DataType::Float32>, DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMag, ResizeBilinearMagTest<DataType::Float32>, DataLayout::NCHW)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8,
+                              SimpleResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8,
+                              ResizeBilinearNopTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8,
+                              ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8,
+                              ResizeBilinearMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagUint8,
+                              ResizeBilinearMagTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinear,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinear,
-                     AlignCornersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearInt8,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearInt8,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint8,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint8,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinear,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinear,
+                              AlignCornersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
 
 // Resize Bilinear - NHWC data layout
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwc,
-                     ResizeBilinearNopTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwc,
-                     SimpleResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwc,
-                     ResizeBilinearSqMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwc,
-                     ResizeBilinearMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagNhwc,
-                     ResizeBilinearMagTest<DataType::Float32>,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8Nhwc,
-                     ResizeBilinearNopTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8Nhwc,
-                     SimpleResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8Nhwc,
-                     ResizeBilinearSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8Nhwc,
-                     ResizeBilinearMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8Nhwc,
-                     ResizeBilinearMagTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearNhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearNhwc,
-                     AlignCornersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearInt8Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearInt8Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint8Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint8Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopNhwc,
+                              ResizeBilinearNopTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearNhwc,
+                              SimpleResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinNhwc,
+                              ResizeBilinearSqMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinNhwc,
+                              ResizeBilinearMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagNhwc,
+                              ResizeBilinearMagTest<DataType::Float32>,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8Nhwc,
+                              ResizeBilinearNopTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8Nhwc,
+                              SimpleResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8Nhwc,
+                              ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8Nhwc,
+                              ResizeBilinearMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagUint8Nhwc,
+                              ResizeBilinearMagTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearNhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearNhwc,
+                              AlignCornersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
 
 // Resize NearestNeighbor - NCHW
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighbor,
-                     SimpleResizeNearestNeighborTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNop,
-                     ResizeNearestNeighborNopTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMin,
-                     ResizeNearestNeighborSqMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMin,
-                     ResizeNearestNeighborMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMag,
-                     ResizeNearestNeighborMagTest<DataType::Float32>,
-                     DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighbor,
+                              SimpleResizeNearestNeighborTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNop,
+                              ResizeNearestNeighborNopTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMin,
+                              ResizeNearestNeighborSqMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMin,
+                              ResizeNearestNeighborMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMag,
+                              ResizeNearestNeighborMagTest<DataType::Float32>,
+                              DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
 
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
 
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbour,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbour,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourInt8,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourInt8,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint8,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint8,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbour,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbour,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
 
 // Resize NearestNeighbor - NHWC
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopNhwc,
-                     ResizeNearestNeighborNopTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborNhwc,
-                     SimpleResizeNearestNeighborTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinNhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinNhwc,
-                     ResizeNearestNeighborMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagNhwc,
-                     ResizeNearestNeighborMagTest<DataType::Float32>,
-                     DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8Nhwc,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8Nhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8Nhwc,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8Nhwc,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourNhwc,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourNhwc,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourInt8Nhwc,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourInt8Nhwc,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint8Nhwc,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint8Nhwc,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopNhwc,
+                              ResizeNearestNeighborNopTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborNhwc,
+                              SimpleResizeNearestNeighborTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinNhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinNhwc,
+                              ResizeNearestNeighborMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagNhwc,
+                              ResizeNearestNeighborMagTest<DataType::Float32>,
+                              DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8Nhwc,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8Nhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8Nhwc,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8Nhwc,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourNhwc,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourNhwc,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8Nhwc,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8Nhwc,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8Nhwc,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8Nhwc,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
 
 // Slice
 ARMNN_AUTO_TEST_CASE(Slice4dFloat32, Slice4dFloat32Test)
@@ -1111,8 +1111,8 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dUint8, StridedSlice2dUint8Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dReverseUint8, StridedSlice2dReverseUint8Test)
 
 // Quantize
-ARMNN_AUTO_TEST_CASE(QuantizeSimpleUint8, QuantizeSimpleUint8Test)
-ARMNN_AUTO_TEST_CASE(QuantizeClampUint8, QuantizeClampUint8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeSimpleUint8, QuantizeSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeClampUint8, QuantizeClampUint8Test)
 
 // PReLU
 ARMNN_AUTO_TEST_CASE_WITH_THF(PreluFloat32, PreluTest<DataType::Float32>)
@@ -1127,146 +1127,146 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(StackOutput3DInputs3, StackOutput3DInputs3Float32T
 ARMNN_AUTO_TEST_CASE_WITH_THF(StackOutput5D,        StackOutput5DFloat32Test)
 
 // Transpose
-ARMNN_AUTO_TEST_CASE(SimpleTransposeFloat32, SimpleTransposeTest<NeonWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet1Test, TransposeValueSet1Test<NeonWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet2Test, TransposeValueSet2Test<NeonWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet3Test, TransposeValueSet3Test<NeonWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQASymms8, SimpleTransposeTest<NeonWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test<NeonWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test<NeonWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test<NeonWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQASymm8, SimpleTransposeTest<NeonWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test<NeonWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test<NeonWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test<NeonWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQSymm16, SimpleTransposeTest<NeonWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test<NeonWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test<NeonWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test<NeonWorkloadFactory, DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeFloat32, SimpleTransposeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet1Test, TransposeValueSet1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet2Test, TransposeValueSet2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet3Test, TransposeValueSet3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymms8, SimpleTransposeTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymm8, SimpleTransposeTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQSymm16, SimpleTransposeTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test<DataType::QSymmS16>)
 
 // TransposeConvolution2d
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNchw,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNhwc,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNchw,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNchw,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNhwc,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNchw,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt8Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt8Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNchw,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNhwc,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNchw,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNhwc,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNchw,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNhwc,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNchw,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNchw,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNhwc,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNchw,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dInt8Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dInt8Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNchw,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNhwc,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNchw,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNhwc,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
 
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNchw,
-                     MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNhwc,
-                     MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nchw,
-                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nhwc,
-                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNchw,
+                              MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNhwc,
+                              MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nchw,
+                              MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nhwc,
+                              MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              DataLayout::NHWC)
 
 // Abs
 ARMNN_AUTO_TEST_CASE_WITH_THF(Abs2d, Abs2dTest<DataType::Float32>)
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index b7ab1ec9b4..7542a64711 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -608,9 +608,9 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(ConcatUint8, ConcatUint8Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(ConcatUint8DifferentQParams, ConcatUint8DifferentQParamsTest)
 ARMNN_AUTO_TEST_CASE_WITH_THF(ConcatUint16, ConcatUint16Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(ConcatUint8DifferentInputOutputQParam,
-                     ConcatDifferentInputOutputQParamTest<DataType::QAsymmU8>, true)
+                              ConcatDifferentInputOutputQParamTest<DataType::QAsymmU8>, true)
 ARMNN_AUTO_TEST_CASE_WITH_THF(ConcatInt16DifferentInputOutputQParam,
-                     ConcatDifferentInputOutputQParamTest<DataType::QSymmS16>, true)
+                              ConcatDifferentInputOutputQParamTest<DataType::QSymmS16>, true)
 
 // Add
 ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAdd, AdditionTest)
@@ -810,439 +810,439 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(BatchNormInt16, BatchNormInt16Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(BatchNormInt16Nhwc, BatchNormInt16NhwcTest)
 
 // Rank
-ARMNN_AUTO_TEST_CASE(RankDimSize1Float16,  RankDimSize1Test<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize1Float32,  RankDimSize1Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize1QAsymmU8, RankDimSize1Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize1Signed32, RankDimSize1Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize1QSymmS16, RankDimSize1Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize1QSymmS8,  RankDimSize1Test<DataType::QSymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize1QAsymmS8, RankDimSize1Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize1BFloat16, RankDimSize1Test<DataType::BFloat16>)
-
-ARMNN_AUTO_TEST_CASE(RankDimSize2Float16,  RankDimSize2Test<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize2Float32,  RankDimSize2Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize2QAsymmU8, RankDimSize2Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize2Signed32, RankDimSize2Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize2QSymmS16, RankDimSize2Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize2QSymmS8,  RankDimSize2Test<DataType::QSymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize2QAsymmS8, RankDimSize2Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize2BFloat16, RankDimSize2Test<DataType::BFloat16>)
-
-ARMNN_AUTO_TEST_CASE(RankDimSize3Float16,  RankDimSize3Test<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize3Float32,  RankDimSize3Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize3QAsymmU8, RankDimSize3Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize3Signed32, RankDimSize3Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize3QSymmS16, RankDimSize3Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize3QSymmS8,  RankDimSize3Test<DataType::QSymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize3QAsymmS8, RankDimSize3Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize3BFloat16, RankDimSize3Test<DataType::BFloat16>)
-
-ARMNN_AUTO_TEST_CASE(RankDimSize4Float16,  RankDimSize4Test<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize4Float32,  RankDimSize4Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize4QAsymmU8, RankDimSize4Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize4Signed32, RankDimSize4Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE(RankDimSize4QSymmS16, RankDimSize4Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(RankDimSize4QSymmS8,  RankDimSize4Test<DataType::QSymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize4QAsymmS8, RankDimSize4Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(RankDimSize4BFloat16, RankDimSize4Test<DataType::BFloat16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Float16,  RankDimSize1Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Float32,  RankDimSize1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QAsymmU8, RankDimSize1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Signed32, RankDimSize1Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QSymmS16, RankDimSize1Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QSymmS8,  RankDimSize1Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QAsymmS8, RankDimSize1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1BFloat16, RankDimSize1Test<DataType::BFloat16>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Float16,  RankDimSize2Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Float32,  RankDimSize2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QAsymmU8, RankDimSize2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Signed32, RankDimSize2Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QSymmS16, RankDimSize2Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QSymmS8,  RankDimSize2Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QAsymmS8, RankDimSize2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2BFloat16, RankDimSize2Test<DataType::BFloat16>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Float16,  RankDimSize3Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Float32,  RankDimSize3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QAsymmU8, RankDimSize3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Signed32, RankDimSize3Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QSymmS16, RankDimSize3Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QSymmS8,  RankDimSize3Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QAsymmS8, RankDimSize3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3BFloat16, RankDimSize3Test<DataType::BFloat16>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Float16,  RankDimSize4Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Float32,  RankDimSize4Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QAsymmU8, RankDimSize4Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Signed32, RankDimSize4Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QSymmS16, RankDimSize4Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QSymmS8,  RankDimSize4Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QAsymmS8, RankDimSize4Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4BFloat16, RankDimSize4Test<DataType::BFloat16>)
 
 // Resize Bilinear - NCHW
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinear,
-                     SimpleResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearFloat16,
-                     SimpleResizeBilinearTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearInt8,
-                     SimpleResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8,
-                     SimpleResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint16,
-                     SimpleResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNop,
-                     ResizeBilinearNopTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopFloat16,
-                     ResizeBilinearNopTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopInt8,
-                     ResizeBilinearNopTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8,
-                     ResizeBilinearNopTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(esizeBilinearNopUint16,
-                     SimpleResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMin,
-                     ResizeBilinearSqMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinFloat16,
-                     ResizeBilinearSqMinTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinInt8,
-                     ResizeBilinearSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8,
-                     ResizeBilinearSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint16,
-                     SimpleResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMin,
-                     ResizeBilinearMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinFloat16,
-                     ResizeBilinearMinTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinInt8,
-                     ResizeBilinearMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8,
-                     ResizeBilinearMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint16,
-                     SimpleResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMag,
-                     ResizeBilinearMagTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagFloat16,
-                     ResizeBilinearMagTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagInt8,
-                     ResizeBilinearMagTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8,
-                     ResizeBilinearMagTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint16,
-                     SimpleResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinear,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearFloat16,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearInt8,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint8,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint16,
-                     HalfPixelCentersResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinear,
-                     AlignCornersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearFloat16,
-                     AlignCornersResizeBilinearTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearInt8,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint8,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint16,
-                     AlignCornersResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinear,
+                              SimpleResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearFloat16,
+                              SimpleResizeBilinearTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8,
+                              SimpleResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8,
+                              SimpleResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint16,
+                              SimpleResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNop,
+                              ResizeBilinearNopTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopFloat16,
+                              ResizeBilinearNopTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8,
+                              ResizeBilinearNopTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8,
+                              ResizeBilinearNopTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(esizeBilinearNopUint16,
+                              SimpleResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMin,
+                              ResizeBilinearSqMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinFloat16,
+                              ResizeBilinearSqMinTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8,
+                              ResizeBilinearSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8,
+                              ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint16,
+                              SimpleResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMin,
+                              ResizeBilinearMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinFloat16,
+                              ResizeBilinearMinTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8,
+                              ResizeBilinearMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8,
+                              ResizeBilinearMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint16,
+                              SimpleResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMag,
+                              ResizeBilinearMagTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagFloat16,
+                              ResizeBilinearMagTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagInt8,
+                              ResizeBilinearMagTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagUint8,
+                              ResizeBilinearMagTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagUint16,
+                              SimpleResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinear,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearFloat16,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint16,
+                              HalfPixelCentersResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinear,
+                              AlignCornersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearFloat16,
+                              AlignCornersResizeBilinearTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint16,
+                              AlignCornersResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
 
 // Resize Bilinear - NHWC
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwc,
-                     ResizeBilinearNopTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwcFloat16,
-                     ResizeBilinearNopTest<DataType::Float16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopInt8Nhwc,
-                     ResizeBilinearNopTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8Nhwc,
-                     ResizeBilinearNopTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint16Nhwc,
-                     ResizeBilinearNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwc,
-                     SimpleResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwcFloat16,
-                     SimpleResizeBilinearTest<DataType::Float16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearInt8Nhwc,
-                     SimpleResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8Nhwc,
-                     SimpleResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint16Nhwc,
-                     ResizeBilinearNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwc,
-                     ResizeBilinearSqMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwcFloat16,
-                     ResizeBilinearSqMinTest<DataType::Float16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinInt8Nhwc,
-                     ResizeBilinearSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8Nhwc,
-                     ResizeBilinearSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint16Nhwc,
-                     ResizeBilinearNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwc,
-                     ResizeBilinearMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwcFloat16,
-                     ResizeBilinearMinTest<DataType::Float16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinInt8Nhwc,
-                     ResizeBilinearMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8Nhwc,
-                     ResizeBilinearMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint16Nhwc,
-                     ResizeBilinearNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagNhwc,
-                     ResizeBilinearMagTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagNhwcFloat16,
-                     ResizeBilinearMagTest<DataType::Float16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagInt8Nhwc,
-                     ResizeBilinearMagTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8Nhwc,
-                     ResizeBilinearMagTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint16Nhwc,
-                     ResizeBilinearNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearNhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearFloat16Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearInt8Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint8Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeBilinearUint16Nhwc,
-                     HalfPixelCentersResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearNhwc,
-                     AlignCornersResizeBilinearTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearFloat16Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearInt8Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint8Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeBilinearUint16Nhwc,
-                     AlignCornersResizeBilinearTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopNhwc,
+                              ResizeBilinearNopTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopNhwcFloat16,
+                              ResizeBilinearNopTest<DataType::Float16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8Nhwc,
+                              ResizeBilinearNopTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8Nhwc,
+                              ResizeBilinearNopTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint16Nhwc,
+                              ResizeBilinearNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearNhwc,
+                              SimpleResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearNhwcFloat16,
+                              SimpleResizeBilinearTest<DataType::Float16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8Nhwc,
+                              SimpleResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8Nhwc,
+                              SimpleResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint16Nhwc,
+                              ResizeBilinearNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinNhwc,
+                              ResizeBilinearSqMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinNhwcFloat16,
+                              ResizeBilinearSqMinTest<DataType::Float16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8Nhwc,
+                              ResizeBilinearSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8Nhwc,
+                              ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint16Nhwc,
+                              ResizeBilinearNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinNhwc,
+                              ResizeBilinearMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinNhwcFloat16,
+                              ResizeBilinearMinTest<DataType::Float16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8Nhwc,
+                              ResizeBilinearMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8Nhwc,
+                              ResizeBilinearMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint16Nhwc,
+                              ResizeBilinearNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagNhwc,
+                              ResizeBilinearMagTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagNhwcFloat16,
+                              ResizeBilinearMagTest<DataType::Float16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagInt8Nhwc,
+                              ResizeBilinearMagTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagUint8Nhwc,
+                              ResizeBilinearMagTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMagUint16Nhwc,
+                              ResizeBilinearNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearNhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearFloat16Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint16Nhwc,
+                              HalfPixelCentersResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearNhwc,
+                              AlignCornersResizeBilinearTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearFloat16Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint16Nhwc,
+                              AlignCornersResizeBilinearTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
 
 // Resize NearestNeighbor - NCHW
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighbor,
-                     SimpleResizeNearestNeighborTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborInt8,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint16,
-                     SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNop,
-                     ResizeNearestNeighborNopTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopInt8,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(esizeNearestNeighborNopUint16,
-                     SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMin,
-                     ResizeNearestNeighborSqMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinInt8,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint16,
-                     SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMin,
-                     ResizeNearestNeighborMinTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinInt8,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint16,
-                     SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMag,
-                     ResizeNearestNeighborMagTest<DataType::Float32>,
-                     DataLayout::NCHW, 0.10f, 50, 0.11f, 20)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagInt8,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW, 0.10f, 50, 0.11f, 20)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW, 0.10f, 50, 0.11f, 20)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint16,
-                     SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbour,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourFloat16,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourInt8,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint8,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint16,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbour,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourFloat16,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourInt8,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint8,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint16,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighbor,
+                              SimpleResizeNearestNeighborTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint16,
+                              SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNop,
+                              ResizeNearestNeighborNopTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(esizeNearestNeighborNopUint16,
+                              SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMin,
+                              ResizeNearestNeighborSqMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint16,
+                              SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMin,
+                              ResizeNearestNeighborMinTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint16,
+                              SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMag,
+                              ResizeNearestNeighborMagTest<DataType::Float32>,
+                              DataLayout::NCHW, 0.10f, 50, 0.11f, 20)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW, 0.10f, 50, 0.11f, 20)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW, 0.10f, 50, 0.11f, 20)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint16,
+                              SimpleResizeNearestNeighborTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbour,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourFloat16,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint16,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbour,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourFloat16,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint16,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
 
 // Resize NearestNeighbor - NHWC
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopNhwc,
-                     ResizeNearestNeighborNopTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopInt8Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint16Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborNhwc,
-                     SimpleResizeNearestNeighborTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborInt8Nhwc,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8Nhwc,
-                     SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint16Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinNhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinInt8Nhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8Nhwc,
-                     ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint16Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinNhwc,
-                     ResizeNearestNeighborMinTest<DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinInt8Nhwc,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8Nhwc,
-                     ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint16Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagNhwc,
-                     ResizeNearestNeighborMagTest<DataType::Float32>,
-                     DataLayout::NHWC, 0.10f, 50, 0.11f, 20)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagInt8Nhwc,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
-                     DataLayout::NHWC, 0.10f, 50, 0.11f, 20)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8Nhwc,
-                     ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
-                     DataLayout::NHWC, 0.10f, 50, 0.11f, 20)
-ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint16Nhwc,
-                     ResizeNearestNeighborNopTest<DataType::QSymmS16>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourNchw,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourFloat16Nchw,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourInt8Nchw,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint8Nchw,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(HalfPixelCentersResizeNearestNeighbourUint16Nchw,
-                     HalfPixelCentersResizeNearestNeighbourTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourNchw,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourFloat16Nchw,
-                     AlignCornersResizeNearestNeighbourTest<DataType::Float16>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourInt8Nchw,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint8Nchw,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(AlignCornersResizeNearestNeighbourUint16Nchw,
-                     AlignCornersResizeNearestNeighbourTest<DataType::QSymmS16>,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopNhwc,
+                              ResizeNearestNeighborNopTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint16Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborNhwc,
+                              SimpleResizeNearestNeighborTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8Nhwc,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8Nhwc,
+                              SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint16Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinNhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8Nhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8Nhwc,
+                              ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint16Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinNhwc,
+                              ResizeNearestNeighborMinTest<DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8Nhwc,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8Nhwc,
+                              ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint16Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagNhwc,
+                              ResizeNearestNeighborMagTest<DataType::Float32>,
+                              DataLayout::NHWC, 0.10f, 50, 0.11f, 20)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8Nhwc,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
+                              DataLayout::NHWC, 0.10f, 50, 0.11f, 20)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8Nhwc,
+                              ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+                              DataLayout::NHWC, 0.10f, 50, 0.11f, 20)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint16Nhwc,
+                              ResizeNearestNeighborNopTest<DataType::QSymmS16>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourNchw,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourFloat16Nchw,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8Nchw,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8Nchw,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint16Nchw,
+                              HalfPixelCentersResizeNearestNeighbourTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourNchw,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourFloat16Nchw,
+                              AlignCornersResizeNearestNeighbourTest<DataType::Float16>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8NchRsqrtw,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8Nchw,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint16Nchw,
+                              AlignCornersResizeNearestNeighbourTest<DataType::QSymmS16>,
+                              DataLayout::NCHW)
 
 // Fake Quantization
 ARMNN_AUTO_TEST_CASE_WITH_THF(FakeQuantization, FakeQuantizationTest)
@@ -1381,11 +1381,11 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFloor, SimpleFloorTest<DataType::Float32>)
 ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFloorFloat16, SimpleFloorTest<DataType::Float16>)
 
 // Reshape
-ARMNN_AUTO_TEST_CASE(SimpleReshapeFloat32, SimpleReshapeTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(SimpleReshapeQuantisedAsymmS8, SimpleReshapeTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(SimpleReshapeQuantisedAsymm8, SimpleReshapeTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(SimpleReshapeQuantisedSymm16, SimpleReshapeTest<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(Reshape5d, Reshape5dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeFloat32, SimpleReshapeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeQuantisedAsymmS8, SimpleReshapeTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeQuantisedAsymm8, SimpleReshapeTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeQuantisedSymm16, SimpleReshapeTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(Reshape5d, Reshape5dTest<DataType::Float32>)
 
 // Rsqrt
 ARMNN_AUTO_TEST_CASE_WITH_THF(Rsqrt2d, Rsqrt2dTest<DataType::Float32>)
@@ -1425,15 +1425,15 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQSymm16ValueSet3Test, PermuteValueSet3Test<
 
 // Lstm
 BOOST_AUTO_TEST_CASE(LstmUtilsZeroVector) {
-                     LstmUtilsZeroVectorTest(); }
+                              LstmUtilsZeroVectorTest(); }
 BOOST_AUTO_TEST_CASE(LstmUtilsMeanStddevNormalization) {
-                     LstmUtilsMeanStddevNormalizationNoneZeroInputTest();
-                     LstmUtilsMeanStddevNormalizationAllZeroInputTest();
-                     LstmUtilsMeanStddevNormalizationMixedZeroInputTest(); }
+                              LstmUtilsMeanStddevNormalizationNoneZeroInputTest();
+                              LstmUtilsMeanStddevNormalizationAllZeroInputTest();
+                              LstmUtilsMeanStddevNormalizationMixedZeroInputTest(); }
 BOOST_AUTO_TEST_CASE(LstmUtilsVectorBatchVectorCwiseProduct) {
-                     LstmUtilsVectorBatchVectorCwiseProductTest(); }
+                              LstmUtilsVectorBatchVectorCwiseProductTest(); }
 BOOST_AUTO_TEST_CASE(LstmUtilsVectorBatchVectorAdd) {
-                     LstmUtilsVectorBatchVectorAddTest(); }
+                              LstmUtilsVectorBatchVectorAddTest(); }
 
 ARMNN_AUTO_TEST_CASE_WITH_THF(LstmLayerFloat32WithCifgWithPeepholeNoProjection,
                               LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest)
@@ -1728,7 +1728,7 @@ ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceSimpleRangeMaskFloat32, StridedSliceSi
 ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceShrinkAxisMaskFloat32, StridedSliceShrinkAxisMaskFloat32Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceShrinkAxisMaskCTSFloat32, StridedSliceShrinkAxisMaskCTSFloat32Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0Dim3Float32,
-                     StridedSliceShrinkAxisMaskBitPosition0Dim3Float32Test)
+                              StridedSliceShrinkAxisMaskBitPosition0Dim3Float32Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(
     StridedSliceShrinkAxisMaskBitPosition0Float32, StridedSliceShrinkAxisMaskBitPosition0Float32Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(
@@ -1897,11 +1897,11 @@ ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt8ToFp16, DequantizeSimpleInt8ToFp16Test)
 ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt16ToFp16, DequantizeSimpleInt16ToFp16Test)
 
 // Quantize
-ARMNN_AUTO_TEST_CASE(QuantizeSimpleUint8, QuantizeSimpleUint8Test)
-ARMNN_AUTO_TEST_CASE(QuantizeClampUint8, QuantizeClampUint8Test)
-ARMNN_AUTO_TEST_CASE(QuantizeClampAsymmInt8, QuantizeClampAsymmInt8Test)
-ARMNN_AUTO_TEST_CASE(QuantizeClampInt8, QuantizeClampInt8Test)
-ARMNN_AUTO_TEST_CASE(QuantizeClampInt16, QuantizeClampInt16Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeSimpleUint8, QuantizeSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeClampUint8, QuantizeClampUint8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeClampAsymmInt8, QuantizeClampAsymmInt8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeClampInt8, QuantizeClampInt8Test)
+ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeClampInt16, QuantizeClampInt16Test)
 
 // PReLU
 ARMNN_AUTO_TEST_CASE_WITH_THF(PreluFloat32, PreluTest<DataType::Float32>)
@@ -1926,257 +1926,257 @@ ARMNN_AUTO_TEST_CASE(Slice2dInt16, Slice2dInt16Test)
 ARMNN_AUTO_TEST_CASE(Slice1dInt16, Slice1dInt16Test)
 
 // Transpose
-ARMNN_AUTO_TEST_CASE(SimpleTransposeBFloat16, SimpleTransposeTest<RefWorkloadFactory, DataType::BFloat16>)
-ARMNN_AUTO_TEST_CASE(TransposeBFloat16ValueSet1Test, TransposeValueSet1Test<RefWorkloadFactory, DataType::BFloat16>)
-ARMNN_AUTO_TEST_CASE(TransposeBFloat16ValueSet2Test, TransposeValueSet2Test<RefWorkloadFactory, DataType::BFloat16>)
-ARMNN_AUTO_TEST_CASE(TransposeBFloat16ValueSet3Test, TransposeValueSet3Test<RefWorkloadFactory, DataType::BFloat16>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeFloat32, SimpleTransposeTest<RefWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet1Test, TransposeValueSet1Test<RefWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet2Test, TransposeValueSet2Test<RefWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(TransposeFloat32ValueSet3Test, TransposeValueSet3Test<RefWorkloadFactory, DataType::Float32>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQASymmS8, SimpleTransposeTest<RefWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test<RefWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test<RefWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test<RefWorkloadFactory, DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQASymm8, SimpleTransposeTest<RefWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test<RefWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test<RefWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test<RefWorkloadFactory, DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeQSymm16, SimpleTransposeTest<RefWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test<RefWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test<RefWorkloadFactory, DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test<RefWorkloadFactory, DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeBFloat16, SimpleTransposeTest<DataType::BFloat16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeBFloat16ValueSet1Test, TransposeValueSet1Test<DataType::BFloat16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeBFloat16ValueSet2Test, TransposeValueSet2Test<DataType::BFloat16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeBFloat16ValueSet3Test, TransposeValueSet3Test<DataType::BFloat16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeFloat32, SimpleTransposeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet1Test, TransposeValueSet1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet2Test, TransposeValueSet2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet3Test, TransposeValueSet3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymmS8, SimpleTransposeTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymm8, SimpleTransposeTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQSymm16, SimpleTransposeTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test<DataType::QSymmS16>)
 
 // TransposeConvolution2d
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNchw,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNhwc,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dInt8Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dInt8Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dInt16Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dInt16Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNchw,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNhwc,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dInt8Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dInt8Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dInt16Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dInt16Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNchw,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
-                     SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dInt8Nchw,
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNchw,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
+                              SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dInt8Nchw,
                     SimpleTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dInt8Nhwc,
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dInt8Nhwc,
                     SimpleTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dInt16Nchw,
-                     SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dInt16Nhwc,
-                     SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dInt16Nchw,
+                              SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dInt16Nhwc,
+                              SimpleTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNchw,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNhwc,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dInt8Nchw,
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNchw,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNhwc,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dInt8Nchw,
                     PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dInt8Nhwc,
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dInt8Nhwc,
                     PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dInt16Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dInt16Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dInt16Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dInt16Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNchw,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
-                     PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt8Nchw,
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNchw,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
+                              PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dInt8Nchw,
                     PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt8Nhwc,
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dInt8Nhwc,
                     PaddedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt16Nchw,
-                     PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dInt16Nhwc,
-                     PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dInt16Nchw,
+                              PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dInt16Nhwc,
+                              PaddedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNchw,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNhwc,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dInt8Nchw,
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNchw,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNhwc,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dInt8Nchw,
                     StridedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dInt8Nhwc,
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dInt8Nhwc,
                     StridedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dInt16Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dInt16Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dInt16Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dInt16Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNchw,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     false,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNhwc,
-                     StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dInt8Nchw,
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNchw,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              false,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNhwc,
+                              StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dInt8Nchw,
                     StridedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dInt8Nhwc,
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dInt8Nhwc,
                     StridedTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     true,
                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     true,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dInt16Nchw,
-                     StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dInt16Nhwc,
-                     StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     true,
-                     DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              true,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dInt16Nchw,
+                              StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dInt16Nhwc,
+                              StridedTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              true,
+                              DataLayout::NCHW)
 
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNchw,
-                     MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dFloatNhwc,
-                     MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dInt8Nchw,
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNchw,
+                              MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNhwc,
+                              MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dInt8Nchw,
                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dInt8Nhwc,
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dInt8Nhwc,
                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmS8, DataType::Signed32>,
                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nchw,
-                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dUint8Nhwc,
-                     MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
-                     DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dInt16Nchw,
-                     MultiChannelTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE(MultiChannelTransposeConvolution2dInt16Nhwc,
-                     MultiChannelTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
-                     DataLayout::NCHW)
-
-ARMNN_AUTO_TEST_CASE(TransposeConvolution2dPerAxisQuantTestNchw,
-                     TransposeConvolution2dPerAxisQuantTest,
-                     DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(TransposeConvolution2dPerAxisQuantTestNhwc,
-                     TransposeConvolution2dPerAxisQuantTest,
-                     DataLayout::NHWC);
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nchw,
+                              MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nhwc,
+                              MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+                              DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dInt16Nchw,
+                              MultiChannelTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dInt16Nhwc,
+                              MultiChannelTransposeConvolution2dTest<DataType::QSymmS16, DataType::Signed32>,
+                              DataLayout::NCHW)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeConvolution2dPerAxisQuantTestNchw,
+                              TransposeConvolution2dPerAxisQuantTest,
+                              DataLayout::NCHW);
+ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeConvolution2dPerAxisQuantTestNhwc,
+                              TransposeConvolution2dPerAxisQuantTest,
+                              DataLayout::NHWC);
 
 // Stack
 ARMNN_AUTO_TEST_CASE_WITH_THF(Stack0Axis,           StackAxis0Float32Test)