IVGCVSW-1938: Move backend-specific source files to the corresponding backend

Change-Id: I558a9a007604afc55e536d877f8da7d0215cc9c3

31 files changed, 300 insertions, 254 deletions

diff --git a/Android.mk b/Android.mk
index 1155153e3f..87fec7b309 100644
--- a/Android.mk
+++ b/Android.mk
@@ -113,10 +113,7 @@ LOCAL_SRC_FILES := \
         src/armnn/InternalTypes.cpp \
         src/armnn/Layer.cpp \
         src/armnn/LoadedNetwork.cpp \
-        src/armnn/NeonInterceptorScheduler.cpp \
-        src/armnn/NeonTimer.cpp \
         src/armnn/Network.cpp \
-        src/armnn/OpenClTimer.cpp \
         src/armnn/WallClockTimer.cpp \
         src/armnn/ProfilingEvent.cpp \
         src/armnn/Profiling.cpp \
@@ -187,23 +184,26 @@ LOCAL_SRC_FILES := \
 	src/armnn/test/GraphTests.cpp \
 	src/armnn/test/RuntimeTests.cpp \
 	src/armnn/test/TensorTest.cpp \
-	src/armnn/test/NeonTimerTest.cpp \
 	src/armnn/test/NetworkTests.cpp \
 	src/armnn/test/InstrumentTests.cpp \
-	src/armnn/test/OpenClTimerTest.cpp \
 	src/armnn/test/ProfilingEventTest.cpp \
 	src/armnn/test/ObservableTest.cpp \
 	src/armnn/test/OptionalTest.cpp \
 	src/backends/test/WorkloadDataValidation.cpp \
 	src/backends/test/TensorCopyUtils.cpp \
 	src/backends/test/LayerTests.cpp \
-	src/backends/test/MemCopyTests.cpp \
+	src/backends/aclCommon/test/MemCopyTests.cpp \
         src/backends/cl/test/ClCreateWorkloadTests.cpp \
         src/backends/cl/test/ClLayerSupportTests.cpp \
 	src/backends/cl/test/ClLayerTests.cpp \
+        src/backends/cl/test/ClMemCopyTests.cpp \
+        src/backends/cl/test/Fp16SupportTest.cpp \
+        src/backends/cl/test/OpenClTimerTest.cpp \
         src/backends/neon/test/NeonCreateWorkloadTests.cpp \
         src/backends/neon/test/NeonLayerSupportTests.cpp \
 	src/backends/neon/test/NeonLayerTests.cpp \
+        src/backends/neon/test/NeonMemCopyTests.cpp \
+        src/backends/neon/test/NeonTimerTest.cpp \
         src/backends/reference/test/RefCreateWorkloadTests.cpp \
         src/backends/reference/test/RefLayerSupportTests.cpp \
 	src/backends/reference/test/RefLayerTests.cpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7325d40303..1956643fb7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -277,21 +277,6 @@ list(APPEND armnn_sources
     src/armnn/Observable.cpp
     )
 
-if(ARMCOMPUTENEON)
-    # Additionally include source files for ARM Compute NEON backend
-    list(APPEND armnn_sources
-        src/armnn/NeonInterceptorScheduler.hpp
-        src/armnn/NeonInterceptorScheduler.cpp
-        src/armnn/NeonTimer.hpp
-        src/armnn/NeonTimer.cpp)
-endif()
-if(ARMCOMPUTECL)
-    # Additionally include source files for ARM Compute OpenCL backend
-    list(APPEND armnn_sources
-        src/armnn/OpenClTimer.cpp
-        src/armnn/OpenClTimer.hpp)
-endif()
-# Files shared by all ARM Compute backends
 if(ARMCOMPUTENEON OR ARMCOMPUTECL)
     list(APPEND armnn_sources
         src/armnn/memory/IMemoryPool.hpp
@@ -405,24 +390,6 @@ if(BUILD_UNIT_TESTS)
         src/backends/test/WorkloadTestUtils.hpp
         src/backends/test/QuantizeHelper.hpp)
 
-    if(ARMCOMPUTENEON)
-        list(APPEND unittest_sources
-            src/armnn/test/CreateWorkloadClNeon.hpp
-            src/armnn/test/NeonTimerTest.cpp)
-    endif()
-
-    if(ARMCOMPUTECL)
-        list(APPEND unittest_sources
-            src/armnn/test/CreateWorkloadClNeon.hpp
-            src/armnn/test/OpenClTimerTest.cpp
-            src/armnn/test/FP16SupportTest.cpp)
-    endif()
-
-    if(ARMCOMPUTENEON OR ARMCOMPUTECL)
-        list(APPEND unittest_sources
-            src/backends/test/MemCopyTests.cpp)
-    endif()
-
     if(BUILD_TF_PARSER)
         list(APPEND unittest_sources
             src/armnnTfParser/test/Activations.cpp
diff --git a/src/backends/aclCommon/CMakeLists.txt b/src/backends/aclCommon/CMakeLists.txt
index 42f914263a..6f99f4f146 100644
--- a/src/backends/aclCommon/CMakeLists.txt
+++ b/src/backends/aclCommon/CMakeLists.txt
@@ -9,6 +9,8 @@ list(APPEND armnnAclCommon_sources
     ArmComputeUtils.hpp
 )
 
+add_subdirectory(test)
+
 add_library(armnnAclCommon STATIC ${armnnAclCommon_sources})
 target_include_directories(armnnAclCommon PRIVATE ${PROJECT_SOURCE_DIR}/src)
 target_include_directories(armnnAclCommon PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
diff --git a/src/backends/aclCommon/common.cmake b/src/backends/aclCommon/common.cmake
index d9d035f307..89be236a7f 100644
--- a/src/backends/aclCommon/common.cmake
+++ b/src/backends/aclCommon/common.cmake
@@ -6,4 +6,5 @@
 if(ARMCOMPUTENEON OR ARMCOMPUTECL)
     add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/aclCommon)
     list(APPEND armnnLibraries armnnAclCommon)
+    list(APPEND armnnUnitTestLibraries armnnAclCommonUnitTests)
 endif()
diff --git a/src/backends/aclCommon/test/CMakeLists.txt b/src/backends/aclCommon/test/CMakeLists.txt
new file mode 100644
index 0000000000..98008edeb5
--- /dev/null
+++ b/src/backends/aclCommon/test/CMakeLists.txt
@@ -0,0 +1,14 @@
+#
+# Copyright © 2017 Arm Ltd. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+list(APPEND armnnAclCommonUnitTests_sources
+    CreateWorkloadClNeon.hpp
+    MemCopyTests.cpp
+)
+
+add_library(armnnAclCommonUnitTests OBJECT ${armnnAclCommonUnitTests_sources})
+target_include_directories(armnnAclCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src)
+target_include_directories(armnnAclCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
+target_include_directories(armnnAclCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
\ No newline at end of file
diff --git a/src/armnn/test/CreateWorkloadClNeon.hpp b/src/backends/aclCommon/test/CreateWorkloadClNeon.hpp
index 56de085f8e..a79cfe6b0d 100644
--- a/src/armnn/test/CreateWorkloadClNeon.hpp
+++ b/src/backends/aclCommon/test/CreateWorkloadClNeon.hpp
@@ -4,7 +4,7 @@
 //
 #pragma once
 
-#include "CreateWorkload.hpp"
+#include <armnn/test/CreateWorkload.hpp>
 
 #include <backends/MemCopyWorkload.hpp>
 #include <backends/reference/RefWorkloadFactory.hpp>
@@ -17,7 +17,6 @@
 #include <backends/neon/NeonTensorHandle.hpp>
 #endif
 
-
 using namespace armnn;
 
 namespace
diff --git a/src/backends/aclCommon/test/MemCopyTests.cpp b/src/backends/aclCommon/test/MemCopyTests.cpp
new file mode 100644
index 0000000000..8ecdb1014d
--- /dev/null
+++ b/src/backends/aclCommon/test/MemCopyTests.cpp
@@ -0,0 +1,62 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <backends/cl/ClWorkloadFactory.hpp>
+#include <backends/neon/NeonWorkloadFactory.hpp>
+#include <backends/test/MemCopyTestImpl.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_SUITE(MemCopyTestSuite)
+
+BOOST_AUTO_TEST_CASE(AclTypeConversions)
+{
+    arm_compute::Strides strides(1, 2, 3, 4);
+    armnn::TensorShape convertedStrides = armnn::armcomputetensorutils::GetStrides(strides);
+
+    BOOST_TEST(convertedStrides[0] == 4);
+    BOOST_TEST(convertedStrides[1] == 3);
+    BOOST_TEST(convertedStrides[2] == 2);
+    BOOST_TEST(convertedStrides[3] == 1);
+
+    arm_compute::TensorShape shape(5, 6, 7, 8);
+    armnn::TensorShape convertedshape = armnn::armcomputetensorutils::GetShape(shape);
+
+    BOOST_TEST(convertedshape[0] == 8);
+    BOOST_TEST(convertedshape[1] == 7);
+    BOOST_TEST(convertedshape[2] == 6);
+    BOOST_TEST(convertedshape[3] == 5);
+}
+
+#if ARMCOMPUTECL_ENABLED && ARMCOMPUTENEON_ENABLED
+
+BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndGpu)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::NeonWorkloadFactory, armnn::ClWorkloadFactory>(false);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndNeon)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::ClWorkloadFactory, armnn::NeonWorkloadFactory>(false);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndGpuWithSubtensors)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::NeonWorkloadFactory, armnn::ClWorkloadFactory>(true);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndNeonWithSubtensors)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::ClWorkloadFactory, armnn::NeonWorkloadFactory>(true);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+#endif
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/backends/cl/CMakeLists.txt b/src/backends/cl/CMakeLists.txt
index 04da6ddcff..2f32081dfe 100644
--- a/src/backends/cl/CMakeLists.txt
+++ b/src/backends/cl/CMakeLists.txt
@@ -15,6 +15,11 @@ list(APPEND armnnClBackend_sources
 )
 
 if(ARMCOMPUTECL)
+    list(APPEND armnnClBackend_sources
+        OpenClTimer.cpp
+        OpenClTimer.hpp
+    )
+
     add_subdirectory(workloads)
     add_subdirectory(test)
 endif()
diff --git a/src/armnn/OpenClTimer.cpp b/src/backends/cl/OpenClTimer.cpp
index 57552d7bd9..57552d7bd9 100644
--- a/src/armnn/OpenClTimer.cpp
+++ b/src/backends/cl/OpenClTimer.cpp
diff --git a/src/armnn/OpenClTimer.hpp b/src/backends/cl/OpenClTimer.hpp
index ca044a405e..a7ae1387d9 100644
--- a/src/armnn/OpenClTimer.hpp
+++ b/src/backends/cl/OpenClTimer.hpp
@@ -7,8 +7,8 @@
 
 #include "Instrument.hpp"
 
-#include "arm_compute/runtime/CL/CLScheduler.h"
-#include "arm_compute/core/CL/OpenCL.h"
+#include <arm_compute/runtime/CL/CLScheduler.h>
+#include <arm_compute/core/CL/OpenCL.h>
 
 #include <vector>
 #include <list>
diff --git a/src/backends/cl/backend.mk b/src/backends/cl/backend.mk
index 4375d9496c..205f7b5415 100644
--- a/src/backends/cl/backend.mk
+++ b/src/backends/cl/backend.mk
@@ -12,6 +12,7 @@ BACKEND_SOURCES := \
         ClContextControl.cpp \
         ClLayerSupport.cpp \
         ClWorkloadFactory.cpp \
+        OpenClTimer.cpp \
         workloads/ClActivationWorkload.cpp \
         workloads/ClAdditionWorkload.cpp \
         workloads/ClBatchNormalizationFloatWorkload.cpp \
diff --git a/src/backends/cl/test/CMakeLists.txt b/src/backends/cl/test/CMakeLists.txt
index d365290a6c..4936a78645 100644
--- a/src/backends/cl/test/CMakeLists.txt
+++ b/src/backends/cl/test/CMakeLists.txt
@@ -8,6 +8,8 @@ list(APPEND armnnClBackendUnitTests_sources
     ClCreateWorkloadTests.cpp
     ClLayerSupportTests.cpp
     ClLayerTests.cpp
+    ClMemCopyTests.cpp
+    OpenClTimerTest.cpp
 )
 
 add_library(armnnClBackendUnitTests OBJECT ${armnnClBackendUnitTests_sources})
diff --git a/src/backends/cl/test/ClCreateWorkloadTests.cpp b/src/backends/cl/test/ClCreateWorkloadTests.cpp
index 66c2c2aa40..526dc68fc5 100644
--- a/src/backends/cl/test/ClCreateWorkloadTests.cpp
+++ b/src/backends/cl/test/ClCreateWorkloadTests.cpp
@@ -6,13 +6,15 @@
 #include "ClContextControlFixture.hpp"
 
 #include <backends/MemCopyWorkload.hpp>
+
+#include <backends/aclCommon/test/CreateWorkloadClNeon.hpp>
+
 #include <backends/cl/ClTensorHandle.hpp>
 #include <backends/cl/ClWorkloadFactory.hpp>
 #include <backends/cl/workloads/ClWorkloads.hpp>
 #include <backends/cl/workloads/ClWorkloadUtils.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
 
-#include <test/CreateWorkloadClNeon.hpp>
+#include <backends/reference/RefWorkloadFactory.hpp>
 
 boost::test_tools::predicate_result CompareIClTensorHandleShape(IClTensorHandle*                    tensorHandle,
                                                                 std::initializer_list<unsigned int> expectedDimensions)
diff --git a/src/backends/cl/test/ClMemCopyTests.cpp b/src/backends/cl/test/ClMemCopyTests.cpp
new file mode 100644
index 0000000000..af8a36d6c0
--- /dev/null
+++ b/src/backends/cl/test/ClMemCopyTests.cpp
@@ -0,0 +1,39 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include <backends/cl/ClWorkloadFactory.hpp>
+#include <backends/reference/RefWorkloadFactory.hpp>
+
+#include <backends/test/MemCopyTestImpl.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_SUITE(ClMemCopy)
+
+BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndGpu)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::RefWorkloadFactory, armnn::ClWorkloadFactory>(false);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndCpu)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::ClWorkloadFactory, armnn::RefWorkloadFactory>(false);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndGpuWithSubtensors)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::RefWorkloadFactory, armnn::ClWorkloadFactory>(true);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndCpuWithSubtensors)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::ClWorkloadFactory, armnn::RefWorkloadFactory>(true);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/armnn/test/FP16SupportTest.cpp b/src/backends/cl/test/Fp16SupportTest.cpp
index 2706d1f363..90bef3647b 100644
--- a/src/armnn/test/FP16SupportTest.cpp
+++ b/src/backends/cl/test/Fp16SupportTest.cpp
@@ -45,7 +45,6 @@ BOOST_AUTO_TEST_CASE(Fp16DataTypeSupport)
     BOOST_CHECK(inputLayer1->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16);
     BOOST_CHECK(inputLayer2->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16);
     BOOST_CHECK(additionLayer->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16);
-
 }
 
 BOOST_AUTO_TEST_CASE(Fp16AdditionTest)
@@ -53,12 +52,11 @@ BOOST_AUTO_TEST_CASE(Fp16AdditionTest)
    using namespace half_float::literal;
    // Create runtime in which test will run
    IRuntime::CreationOptions options;
-   IRuntimePtr  runtime(IRuntime::Create(options));
+   IRuntimePtr runtime(IRuntime::Create(options));
 
    // Builds up the structure of the network.
    INetworkPtr net(INetwork::Create());
 
-
    IConnectableLayer* inputLayer1 = net->AddInputLayer(0);
    IConnectableLayer* inputLayer2 = net->AddInputLayer(1);
    IConnectableLayer* additionLayer = net->AddAdditionLayer();
@@ -79,7 +77,6 @@ BOOST_AUTO_TEST_CASE(Fp16AdditionTest)
    IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime->GetDeviceSpec());
 
    // Loads it into the runtime.
-
    NetworkId netId;
    runtime->LoadNetwork(netId, std::move(optNet));
 
diff --git a/src/armnn/test/OpenClTimerTest.cpp b/src/backends/cl/test/OpenClTimerTest.cpp
index 76cffec4f3..70ceac2a3f 100644
--- a/src/armnn/test/OpenClTimerTest.cpp
+++ b/src/backends/cl/test/OpenClTimerTest.cpp
@@ -5,19 +5,25 @@
 
 #if (defined(__aarch64__)) || (defined(__x86_64__)) // disable test failing on FireFly/Armv7
 
-#include <arm_compute/runtime/CL/CLScheduler.h>
+#include <armnn/test/TensorHelpers.hpp>
+
+#include <backends/CpuTensorHandle.hpp>
+#include <backends/WorkloadFactory.hpp>
+
 #include <backends/cl/ClContextControl.hpp>
 #include <backends/cl/ClWorkloadFactory.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <boost/format.hpp>
-#include <iostream>
-#include <OpenClTimer.hpp>
+#include <backends/cl/OpenClTimer.hpp>
+
 #include <backends/test/TensorCopyUtils.hpp>
-#include "TensorHelpers.hpp"
-#include <boost/test/unit_test.hpp>
-#include <backends/WorkloadFactory.hpp>
 #include <backends/test/WorkloadTestUtils.hpp>
 
+#include <arm_compute/runtime/CL/CLScheduler.h>
+
+#include <boost/format.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
 using namespace armnn;
 
 struct OpenClFixture
diff --git a/src/backends/cl/workloads/ClWorkloadUtils.hpp b/src/backends/cl/workloads/ClWorkloadUtils.hpp
index af4ccd0bb8..c765c63dce 100644
--- a/src/backends/cl/workloads/ClWorkloadUtils.hpp
+++ b/src/backends/cl/workloads/ClWorkloadUtils.hpp
@@ -5,11 +5,11 @@
 #pragma once
 
 #include <armnnUtils/Half.hpp>
+
 #include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <backends/cl/OpenClTimer.hpp>
 #include <backends/CpuTensorHandle.hpp>
 
-#include "OpenClTimer.hpp"
-
 #define ARMNN_SCOPED_PROFILING_EVENT_CL(name) \
     ARMNN_SCOPED_PROFILING_EVENT_WITH_INSTRUMENTS(armnn::Compute::GpuAcc, \
                                                   name, \
diff --git a/src/backends/neon/CMakeLists.txt b/src/backends/neon/CMakeLists.txt
index 93c7955a5f..152955aa06 100644
--- a/src/backends/neon/CMakeLists.txt
+++ b/src/backends/neon/CMakeLists.txt
@@ -7,11 +7,15 @@ if(ARMCOMPUTENEON)
     list(APPEND armnnNeonBackend_sources
         NeonBackend.cpp
         NeonBackend.hpp
+        NeonInterceptorScheduler.hpp
+        NeonInterceptorScheduler.cpp
         NeonLayerSupport.cpp
         NeonLayerSupport.hpp
         NeonWorkloadFactory.cpp
         NeonWorkloadFactory.hpp
         NeonTensorHandle.hpp
+        NeonTimer.hpp
+        NeonTimer.cpp
     )
 
     add_subdirectory(workloads)
diff --git a/src/armnn/NeonInterceptorScheduler.cpp b/src/backends/neon/NeonInterceptorScheduler.cpp
index 03b4670296..03b4670296 100644
--- a/src/armnn/NeonInterceptorScheduler.cpp
+++ b/src/backends/neon/NeonInterceptorScheduler.cpp
diff --git a/src/armnn/NeonInterceptorScheduler.hpp b/src/backends/neon/NeonInterceptorScheduler.hpp
index f33b79a2da..f33b79a2da 100644
--- a/src/armnn/NeonInterceptorScheduler.hpp
+++ b/src/backends/neon/NeonInterceptorScheduler.hpp
diff --git a/src/armnn/NeonTimer.cpp b/src/backends/neon/NeonTimer.cpp
index 219edc9680..219edc9680 100644
--- a/src/armnn/NeonTimer.cpp
+++ b/src/backends/neon/NeonTimer.cpp
diff --git a/src/armnn/NeonTimer.hpp b/src/backends/neon/NeonTimer.hpp
index 31d3e85a7c..31d3e85a7c 100644
--- a/src/armnn/NeonTimer.hpp
+++ b/src/backends/neon/NeonTimer.hpp
diff --git a/src/backends/neon/backend.mk b/src/backends/neon/backend.mk
index 132328ba72..af83fb1321 100644
--- a/src/backends/neon/backend.mk
+++ b/src/backends/neon/backend.mk
@@ -9,7 +9,9 @@
 
 BACKEND_SOURCES := \
         NeonBackend.cpp \
+        NeonInterceptorScheduler.cpp \
         NeonLayerSupport.cpp \
+        NeonTimer.cpp \
         NeonWorkloadFactory.cpp \
         workloads/NeonActivationWorkload.cpp \
         workloads/NeonAdditionFloatWorkload.cpp \
diff --git a/src/backends/neon/test/CMakeLists.txt b/src/backends/neon/test/CMakeLists.txt
index 87da01e9e2..4a3380c3f9 100644
--- a/src/backends/neon/test/CMakeLists.txt
+++ b/src/backends/neon/test/CMakeLists.txt
@@ -7,6 +7,8 @@ list(APPEND armnnNeonBackendUnitTests_sources
     NeonCreateWorkloadTests.cpp
     NeonLayerSupportTests.cpp
     NeonLayerTests.cpp
+    NeonMemCopyTests.cpp
+    NeonTimerTest.cpp
 )
 
 add_library(armnnNeonBackendUnitTests OBJECT ${armnnNeonBackendUnitTests_sources})
diff --git a/src/backends/neon/test/NeonCreateWorkloadTests.cpp b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
index 2c4d0ae0f9..ec8fe803a1 100644
--- a/src/backends/neon/test/NeonCreateWorkloadTests.cpp
+++ b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
@@ -3,9 +3,10 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include <armnn/test/CreateWorkloadClNeon.hpp>
-
 #include <backends/MemCopyWorkload.hpp>
+
+#include <backends/aclCommon/test/CreateWorkloadClNeon.hpp>
+
 #include <backends/neon/NeonWorkloadFactory.hpp>
 #include <backends/neon/NeonTensorHandle.hpp>
 #include <backends/neon/workloads/NeonWorkloadUtils.hpp>
diff --git a/src/backends/neon/test/NeonMemCopyTests.cpp b/src/backends/neon/test/NeonMemCopyTests.cpp
new file mode 100644
index 0000000000..ddb47343a1
--- /dev/null
+++ b/src/backends/neon/test/NeonMemCopyTests.cpp
@@ -0,0 +1,39 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include <backends/neon/NeonWorkloadFactory.hpp>
+#include <backends/reference/RefWorkloadFactory.hpp>
+
+#include <backends/test/MemCopyTestImpl.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_SUITE(NeonMemCopy)
+
+BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndNeon)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::RefWorkloadFactory, armnn::NeonWorkloadFactory>(false);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndCpu)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::NeonWorkloadFactory, armnn::RefWorkloadFactory>(false);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndNeonWithSubtensors)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::RefWorkloadFactory, armnn::NeonWorkloadFactory>(true);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndCpuWithSubtensors)
+{
+    LayerTestResult<float, 4> result = MemCopyTest<armnn::NeonWorkloadFactory, armnn::RefWorkloadFactory>(true);
+    BOOST_TEST(CompareTensors(result.output, result.outputExpected));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/armnn/test/NeonTimerTest.cpp b/src/backends/neon/test/NeonTimerTest.cpp
index 6d0429c8b9..06f19c6ec3 100644
--- a/src/armnn/test/NeonTimerTest.cpp
+++ b/src/backends/neon/test/NeonTimerTest.cpp
@@ -3,20 +3,22 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include <NeonTimer.hpp>
-#include "TensorHelpers.hpp"
-
 #include <armnn/ArmNN.hpp>
-#include <armnn/Tensor.hpp>
-#include <armnn/TypesUtils.hpp>
+
+#include <armnn/test/TensorHelpers.hpp>
+
 #include <backends/CpuTensorHandle.hpp>
-#include <backends/neon/NeonWorkloadFactory.hpp>
 #include <backends/WorkloadFactory.hpp>
+
+#include <backends/neon/NeonTimer.hpp>
+#include <backends/neon/NeonWorkloadFactory.hpp>
+
 #include <backends/test/LayerTests.hpp>
 #include <backends/test/TensorCopyUtils.hpp>
 #include <backends/test/WorkloadTestUtils.hpp>
 
 #include <boost/test/unit_test.hpp>
+
 #include <cstdlib>
 #include <algorithm>
 
diff --git a/src/backends/neon/workloads/NeonWorkloadUtils.hpp b/src/backends/neon/workloads/NeonWorkloadUtils.hpp
index 22668f6f4b..c4accd6c89 100644
--- a/src/backends/neon/workloads/NeonWorkloadUtils.hpp
+++ b/src/backends/neon/workloads/NeonWorkloadUtils.hpp
@@ -5,9 +5,9 @@
 #pragma once
 
 #include <backends/Workload.hpp>
-#include <backends/neon/NeonTensorHandle.hpp>
 
-#include "NeonTimer.hpp"
+#include <backends/neon/NeonTensorHandle.hpp>
+#include <backends/neon/NeonTimer.hpp>
 
 #include <arm_compute/core/Types.h>
 #include <arm_compute/core/Helpers.h>
diff --git a/src/backends/test/LayerTests.cpp b/src/backends/test/LayerTests.cpp
index 4b50e4b5f9..d955e42c36 100755
--- a/src/backends/test/LayerTests.cpp
+++ b/src/backends/test/LayerTests.cpp
@@ -16,11 +16,6 @@
 #include <backends/CpuTensorHandle.hpp>
 #include <backends/WorkloadFactory.hpp>
 
-#ifdef ARMCOMPUTECL_ENABLED
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#endif
-
 #include <algorithm>
 #include <boost/cast.hpp>
 
diff --git a/src/backends/test/MemCopyTestImpl.hpp b/src/backends/test/MemCopyTestImpl.hpp
new file mode 100644
index 0000000000..dab7f47915
--- /dev/null
+++ b/src/backends/test/MemCopyTestImpl.hpp
@@ -0,0 +1,84 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include "LayerTests.hpp"
+#include "TensorCopyUtils.hpp"
+#include "WorkloadTestUtils.hpp"
+
+#include <armnn/test/TensorHelpers.hpp>
+
+#include <boost/multi_array.hpp>
+
+namespace
+{
+
+LayerTestResult<float, 4> MemCopyTest(armnn::IWorkloadFactory& srcWorkloadFactory,
+                                      armnn::IWorkloadFactory& dstWorkloadFactory,
+                                      bool withSubtensors)
+{
+    const std::array<unsigned int, 4> shapeData = { { 1u, 1u, 6u, 5u } };
+    const armnn::TensorShape tensorShape(4, shapeData.data());
+    const armnn::TensorInfo tensorInfo(tensorShape, armnn::DataType::Float32);
+    boost::multi_array<float, 4> inputData = MakeTensor<float, 4>(tensorInfo, std::vector<float>(
+        {
+            1.0f, 2.0f, 3.0f, 4.0f, 5.0f,
+
+            6.0f, 7.0f, 8.0f, 9.0f, 10.0f,
+
+            11.0f, 12.0f, 13.0f, 14.0f, 15.0f,
+
+            16.0f, 17.0f, 18.0f, 19.0f, 20.0f,
+
+            21.0f, 22.0f, 23.0f, 24.0f, 25.0f,
+
+            26.0f, 27.0f, 28.0f, 29.0f, 30.0f,
+        })
+    );
+
+    LayerTestResult<float, 4> ret(tensorInfo);
+    ret.outputExpected = inputData;
+
+    boost::multi_array<float, 4> outputData(shapeData);
+
+    auto inputTensorHandle = srcWorkloadFactory.CreateTensorHandle(tensorInfo);
+    auto outputTensorHandle = dstWorkloadFactory.CreateTensorHandle(tensorInfo);
+
+    AllocateAndCopyDataToITensorHandle(inputTensorHandle.get(), inputData.data());
+    outputTensorHandle->Allocate();
+
+    armnn::MemCopyQueueDescriptor memCopyQueueDesc;
+    armnn::WorkloadInfo workloadInfo;
+
+    const unsigned int origin[4] = {};
+
+    auto workloadInput = (withSubtensors && srcWorkloadFactory.SupportsSubTensors())
+                         ? srcWorkloadFactory.CreateSubTensorHandle(*inputTensorHandle, tensorShape, origin)
+                         : std::move(inputTensorHandle);
+    auto workloadOutput = (withSubtensors && dstWorkloadFactory.SupportsSubTensors())
+                          ? dstWorkloadFactory.CreateSubTensorHandle(*outputTensorHandle, tensorShape, origin)
+                          : std::move(outputTensorHandle);
+
+    AddInputToWorkload(memCopyQueueDesc, workloadInfo, tensorInfo, workloadInput.get());
+    AddOutputToWorkload(memCopyQueueDesc, workloadInfo, tensorInfo, workloadOutput.get());
+
+    dstWorkloadFactory.CreateMemCopy(memCopyQueueDesc, workloadInfo)->Execute();
+
+    CopyDataFromITensorHandle(outputData.data(), workloadOutput.get());
+    ret.output = outputData;
+
+    return ret;
+}
+
+template<typename SrcWorkloadFactory, typename DstWorkloadFactory>
+LayerTestResult<float, 4> MemCopyTest(bool withSubtensors)
+{
+    SrcWorkloadFactory srcWorkloadFactory;
+    DstWorkloadFactory dstWorkloadFactory;
+
+    return MemCopyTest(srcWorkloadFactory, dstWorkloadFactory, withSubtensors);
+}
+
+} // anonymous namespace
diff --git a/src/backends/test/MemCopyTests.cpp b/src/backends/test/MemCopyTests.cpp
deleted file mode 100644
index f66caffd92..0000000000
--- a/src/backends/test/MemCopyTests.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#include <boost/test/unit_test.hpp>
-#include <boost/multi_array.hpp>
-
-#include <armnn/ArmNN.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#if ARMCOMPUTECL_ENABLED
-#include <backends/cl/ClWorkloadFactory.hpp>
-#endif
-#if ARMCOMPUTENEON_ENABLED
-#include <backends/neon/NeonWorkloadFactory.hpp>
-#endif
-#include <backends/CpuTensorHandle.hpp>
-#include <test/TensorHelpers.hpp>
-
-#include "TensorCopyUtils.hpp"
-#include "WorkloadTestUtils.hpp"
-
-#if ARMCOMPUTECL_ENABLED || ARMCOMPUTENEON_ENABLED
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#endif
-
-BOOST_AUTO_TEST_SUITE(MemCopyTestSuite)
-
-void MemCopyTest(armnn::IWorkloadFactory& srcWorkloadFactory, armnn::IWorkloadFactory& dstWorkloadFactory,
-                 bool withSubtensors)
-{
-    const std::array<unsigned int, 4> shapeData = { { 1u, 1u, 6u, 5u } };
-    const armnn::TensorShape tensorShape(4, shapeData.data());
-    const armnn::TensorInfo tensorInfo(tensorShape, armnn::DataType::Float32);
-    boost::multi_array<float, 4> inputData = MakeTensor<float, 4>(tensorInfo, std::vector<float>(
-        {
-            1.0f, 2.0f, 3.0f, 4.0f, 5.0f,
-
-            6.0f, 7.0f, 8.0f, 9.0f, 10.0f,
-
-            11.0f, 12.0f, 13.0f, 14.0f, 15.0f,
-
-            16.0f, 17.0f, 18.0f, 19.0f, 20.0f,
-
-            21.0f, 22.0f, 23.0f, 24.0f, 25.0f,
-
-            26.0f, 27.0f, 28.0f, 29.0f, 30.0f,
-        })
-    );
-
-    boost::multi_array<float, 4> outputData(shapeData);
-
-    auto inputTensorHandle = srcWorkloadFactory.CreateTensorHandle(tensorInfo);
-    auto outputTensorHandle = dstWorkloadFactory.CreateTensorHandle(tensorInfo);
-
-    AllocateAndCopyDataToITensorHandle(inputTensorHandle.get(), inputData.data());
-    outputTensorHandle->Allocate();
-
-    armnn::MemCopyQueueDescriptor memCopyQueueDesc;
-    armnn::WorkloadInfo workloadInfo;
-
-    const unsigned int origin[4] = {};
-
-    auto workloadInput = (withSubtensors && srcWorkloadFactory.SupportsSubTensors())
-                         ? srcWorkloadFactory.CreateSubTensorHandle(*inputTensorHandle, tensorShape, origin)
-                         : std::move(inputTensorHandle);
-    auto workloadOutput = (withSubtensors && dstWorkloadFactory.SupportsSubTensors())
-                          ? dstWorkloadFactory.CreateSubTensorHandle(*outputTensorHandle, tensorShape, origin)
-                          : std::move(outputTensorHandle);
-
-    AddInputToWorkload(memCopyQueueDesc, workloadInfo, tensorInfo, workloadInput.get());
-    AddOutputToWorkload(memCopyQueueDesc, workloadInfo, tensorInfo, workloadOutput.get());
-
-    dstWorkloadFactory.CreateMemCopy(memCopyQueueDesc, workloadInfo)->Execute();
-
-    CopyDataFromITensorHandle(outputData.data(), workloadOutput.get());
-
-    BOOST_TEST(CompareTensors(inputData, outputData));
-}
-
-template <typename SrcWorkloadFactory, typename DstWorkloadFactory>
-void MemCopyTest(bool withSubtensors)
-{
-    SrcWorkloadFactory srcWorkloadFactory;
-    DstWorkloadFactory dstWorkloadFactory;
-    MemCopyTest(srcWorkloadFactory, dstWorkloadFactory, withSubtensors);
-}
-
-#if ARMCOMPUTECL_ENABLED || ARMCOMPUTENEON_ENABLED
-
-BOOST_AUTO_TEST_CASE(AclTypeConversions)
-{
-    arm_compute::Strides strides(1,2,3,4);
-    armnn::TensorShape convertedStrides = armnn::armcomputetensorutils::GetStrides(strides);
-    BOOST_TEST(convertedStrides[0] == 4);
-    BOOST_TEST(convertedStrides[1] == 3);
-    BOOST_TEST(convertedStrides[2] == 2);
-    BOOST_TEST(convertedStrides[3] == 1);
-
-    arm_compute::TensorShape shape(5,6,7,8);
-    armnn::TensorShape convertedshape = armnn::armcomputetensorutils::GetShape(shape);
-    BOOST_TEST(convertedshape[0] == 8);
-    BOOST_TEST(convertedshape[1] == 7);
-    BOOST_TEST(convertedshape[2] == 6);
-    BOOST_TEST(convertedshape[3] == 5);
-}
-#endif
-
-#if ARMCOMPUTECL_ENABLED
-
-BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndGpu)
-{
-    MemCopyTest<armnn::RefWorkloadFactory, armnn::ClWorkloadFactory>(false);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndCpu)
-{
-    MemCopyTest<armnn::ClWorkloadFactory, armnn::RefWorkloadFactory>(false);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndGpuWithSubtensors)
-{
-    MemCopyTest<armnn::RefWorkloadFactory, armnn::ClWorkloadFactory>(true);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndCpuWithSubtensors)
-{
-    MemCopyTest<armnn::ClWorkloadFactory, armnn::RefWorkloadFactory>(true);
-}
-
-#endif // ARMCOMPUTECL_ENABLED
-
-#if ARMCOMPUTENEON_ENABLED
-
-BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndNeon)
-{
-    MemCopyTest<armnn::RefWorkloadFactory, armnn::NeonWorkloadFactory>(false);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndCpu)
-{
-    MemCopyTest<armnn::NeonWorkloadFactory, armnn::RefWorkloadFactory>(false);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndNeonWithSubtensors)
-{
-    MemCopyTest<armnn::RefWorkloadFactory, armnn::NeonWorkloadFactory>(true);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndCpuWithSubtensors)
-{
-    MemCopyTest<armnn::NeonWorkloadFactory, armnn::RefWorkloadFactory>(true);
-}
-
-#endif // ARMCOMPUTENEON_ENABLED
-
-#if ARMCOMPUTECL_ENABLED && ARMCOMPUTENEON_ENABLED
-
-BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndGpu)
-{
-    MemCopyTest<armnn::NeonWorkloadFactory, armnn::ClWorkloadFactory>(false);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndNeon)
-{
-    MemCopyTest<armnn::ClWorkloadFactory, armnn::NeonWorkloadFactory>(false);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenNeonAndGpuWithSubtensors)
-{
-    MemCopyTest<armnn::NeonWorkloadFactory, armnn::ClWorkloadFactory>(true);
-}
-
-BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndNeonWithSubtensors)
-{
-    MemCopyTest<armnn::ClWorkloadFactory, armnn::NeonWorkloadFactory>(true);
-}
-
-#endif
-
-BOOST_AUTO_TEST_SUITE_END()