IVGCVSW-3738 Add end-to-end layer test for DepthToSpace

* Added end-to-end layer test implementation for DepthToSpace
* Added test to reference, CL and NEON backends for all supported
  data types and data layouts
* Extracted common data permutation code into new utility file and
  refactored some existing tests to reduce code duplication
* Fixed EndToEndLayerTestImpl template to work with Float16 data

Signed-off-by: Aron Virginas-Tar <Aron.Virginas-Tar@arm.com>
Change-Id: Iaf7a0012c520451052b20c37e36dc05fa8314ff6

12 files changed, 582 insertions, 298 deletions

diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk
index 343af5a019..ae9fdec269 100644
--- a/src/backends/backendsCommon/common.mk
+++ b/src/backends/backendsCommon/common.mk
@@ -33,6 +33,7 @@ COMMON_TEST_SOURCES := \
     test/CommonTestUtils.cpp \
     test/JsonPrinterTestImpl.cpp \
     test/QuantizedLstmEndToEndTestImpl.cpp \
+    test/SpaceToDepthEndToEndTestImpl.cpp \
     test/TensorCopyUtils.cpp \
     test/layerTests/AbsTestImpl.cpp \
     test/layerTests/ActivationTestImpl.cpp \
diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt
index 481d7d8423..034fe4cb1b 100644
--- a/src/backends/backendsCommon/test/CMakeLists.txt
+++ b/src/backends/backendsCommon/test/CMakeLists.txt
@@ -10,7 +10,9 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     BackendRegistryTests.cpp
     CommonTestUtils.cpp
     CommonTestUtils.hpp
+    DataLayoutUtils.hpp
     DataTypeUtils.hpp
+    DepthToSpaceEndToEndTestImpl.hpp
     DequantizeEndToEndTestImpl.hpp
     DetectionPostProcessEndToEndTestImpl.hpp
     DynamicBackendTests.cpp
@@ -34,6 +36,7 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     QuantizedLstmEndToEndTestImpl.hpp
     ResizeEndToEndTestImpl.hpp
     RuntimeTestImpl.hpp
+    SpaceToDepthEndToEndTestImpl.cpp
     SpaceToDepthEndToEndTestImpl.hpp
     SplitterEndToEndTestImpl.hpp
     TensorCopyUtils.cpp
diff --git a/src/backends/backendsCommon/test/DataLayoutUtils.hpp b/src/backends/backendsCommon/test/DataLayoutUtils.hpp
new file mode 100644
index 0000000000..f89325829e
--- /dev/null
+++ b/src/backends/backendsCommon/test/DataLayoutUtils.hpp
@@ -0,0 +1,36 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <Permute.hpp>
+
+#include <armnn/Tensor.hpp>
+#include <armnn/Types.hpp>
+
+template<typename T>
+void PermuteTensorNchwToNhwc(armnn::TensorInfo& tensorInfo, std::vector<T>& tensorData)
+{
+    const armnn::PermutationVector nchwToNhwc = { 0, 3, 1, 2 };
+
+    tensorInfo = armnnUtils::Permuted(tensorInfo, nchwToNhwc);
+
+    std::vector<T> tmp(tensorData.size());
+    armnnUtils::Permute(tensorInfo.GetShape(), nchwToNhwc, tensorData.data(), tmp.data(), sizeof(T));
+    tensorData = tmp;
+}
+
+template<typename T>
+void PermuteTensorNhwcToNchw(armnn::TensorInfo& tensorInfo, std::vector<T>& tensorData)
+{
+    const armnn::PermutationVector nhwcToNchw = { 0, 2, 3, 1 };
+
+    tensorInfo = armnnUtils::Permuted(tensorInfo, nhwcToNchw);
+
+    std::vector<T> tmp(tensorData.size());
+    armnnUtils::Permute(tensorInfo.GetShape(), nhwcToNchw, tensorData.data(), tmp.data(), sizeof(T));
+
+    tensorData = tmp;
+}
diff --git a/src/backends/backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp
new file mode 100644
index 0000000000..cf4db1d2d4
--- /dev/null
+++ b/src/backends/backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp
@@ -0,0 +1,121 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <ResolveType.hpp>
+
+#include <armnn/ArmNN.hpp>
+
+#include <backendsCommon/test/DataLayoutUtils.hpp>
+#include <backendsCommon/test/QuantizeHelper.hpp>
+
+namespace
+{
+
+armnn::INetworkPtr CreateDepthToSpaceNetwork(const armnn::TensorInfo& inputInfo,
+                                             const armnn::TensorInfo& outputInfo,
+                                             const armnn::DepthToSpaceDescriptor& descriptor)
+{
+    using namespace armnn;
+
+    INetworkPtr network(INetwork::Create());
+
+    IConnectableLayer* input        = network->AddInputLayer(0, "input");
+    IConnectableLayer* depthToSpace = network->AddDepthToSpaceLayer(descriptor, "depthToSpace");
+    IConnectableLayer* output       = network->AddOutputLayer(0, "output");
+
+    Connect(input, depthToSpace, inputInfo, 0, 0);
+    Connect(depthToSpace, output, outputInfo, 0, 0);
+
+    return network;
+}
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+void DepthToSpaceEndToEndImpl(const std::vector<armnn::BackendId>& backends,
+                              const DepthToSpaceDescriptor& descriptor,
+                              const armnn::TensorShape& nhwcInputShape,
+                              const armnn::TensorShape& nhwcOutputShape,
+                              const std::vector<float>& floatInputData,
+                              const std::vector<float>& floatExpectedOutputData)
+{
+    using namespace armnn;
+
+    TensorInfo inputInfo(nhwcInputShape, ArmnnType);
+    TensorInfo outputInfo(nhwcOutputShape, ArmnnType);
+
+    constexpr float   qScale  = 0.25f;
+    constexpr int32_t qOffset = 128;
+
+    // Set quantization parameters for quantized types
+    if (IsQuantizedType<T>())
+    {
+        inputInfo.SetQuantizationScale(qScale);
+        inputInfo.SetQuantizationOffset(qOffset);
+        outputInfo.SetQuantizationScale(qScale);
+        outputInfo.SetQuantizationOffset(qOffset);
+    }
+
+    std::vector<T> inputData          = QuantizedVector<T>(qScale, qOffset, floatInputData);
+    std::vector<T> expectedOutputData = QuantizedVector<T>(qScale, qOffset, floatExpectedOutputData);
+
+    // Permute tensors from NHWC to NCHW (if needed)
+    if (descriptor.m_DataLayout == DataLayout::NCHW)
+    {
+        PermuteTensorNhwcToNchw(inputInfo, inputData);
+        PermuteTensorNhwcToNchw(outputInfo, expectedOutputData);
+    }
+
+    INetworkPtr network = CreateDepthToSpaceNetwork(inputInfo, outputInfo, descriptor);
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(std::move(network),
+                                                { { 0, inputData } },
+                                                { { 0, expectedOutputData } },
+                                                backends);
+}
+
+} // anonymous namespace
+
+template<armnn::DataType ArmnnType>
+void DepthToSpaceEndToEnd(const std::vector<armnn::BackendId>& defaultBackends,
+                          armnn::DataLayout dataLayout)
+{
+    using namespace armnn;
+
+    TensorShape inputShape  = { 2, 2, 2, 4 };
+    TensorShape outputShape = { 2, 4, 4, 1 };
+
+    std::vector<float> inputData =
+    {
+         1.f,  2.f,  3.f,  4.f,
+         5.f,  6.f,  7.f,  8.f,
+         9.f, 10.f, 11.f, 12.f,
+        13.f, 14.f, 15.f, 16.f,
+
+        17.f, 18.f, 19.f, 20.f,
+        21.f, 22.f, 23.f, 24.f,
+        25.f, 26.f, 27.f, 28.f,
+        29.f, 30.f, 31.f, 32.f
+    };
+
+    std::vector<float> expectedOutputData =
+    {
+         1.f,  2.f,  5.f,  6.f,
+         3.f,  4.f,  7.f,  8.f,
+         9.f, 10.f, 13.f, 14.f,
+        11.f, 12.f, 15.f, 16.f,
+
+        17.f, 18.f, 21.f, 22.f,
+        19.f, 20.f, 23.f, 24.f,
+        25.f, 26.f, 29.f, 30.f,
+        27.f, 28.f, 31.f, 32.f
+    };
+
+    DepthToSpaceEndToEndImpl<ArmnnType>(defaultBackends,
+                                        DepthToSpaceDescriptor(2, dataLayout),
+                                        inputShape,
+                                        outputShape,
+                                        inputData,
+                                        expectedOutputData);
+}
diff --git a/src/backends/backendsCommon/test/EndToEndTestImpl.hpp b/src/backends/backendsCommon/test/EndToEndTestImpl.hpp
index 1577e1323c..efaffb9b67 100644
--- a/src/backends/backendsCommon/test/EndToEndTestImpl.hpp
+++ b/src/backends/backendsCommon/test/EndToEndTestImpl.hpp
@@ -105,11 +105,23 @@ inline bool ConstantUsageUint8Test(const std::vector<BackendId>& backends)
     );
 }
 
-template<typename T>
-bool CompareBoolean(T a, T b)
+// Utility template for comparing tensor elements
+template<DataType ArmnnType, typename T = ResolveType<ArmnnType>>
+bool Compare(T a, T b)
 {
-    return (a == 0 && b == 0) ||(a != 0 && b != 0);
-};
+    if (ArmnnType == DataType::Boolean)
+    {
+        // NOTE: Boolean is represented as uint8_t (with zero equals
+        // false and everything else equals true), therefore values
+        // need to be casted to bool before comparing them
+        return static_cast<bool>(a) == static_cast<bool>(b);
+    }
+
+    // NOTE: All other types can be cast to float and compared with
+    // a certain level of tolerance
+    constexpr float tolerance = 0.000001f;
+    return std::fabs(static_cast<float>(a) - static_cast<float>(b)) <= tolerance;
+}
 
 // Utility function to find the number of instances of a substring within a string.
 int SubStringCounter(std::string& string, std::string&& substring)
@@ -170,19 +182,9 @@ void EndToEndLayerTestImpl(INetworkPtr network,
     for (auto&& it : expectedOutputData)
     {
         std::vector<TOutput> out = outputStorage.at(it.first);
-        if (ArmnnOType == DataType::Boolean)
-        {
-            for (unsigned int i = 0; i < out.size(); ++i)
-            {
-                BOOST_TEST(CompareBoolean<TOutput>(it.second[i], out[i]));
-            }
-        }
-        else
+        for (unsigned int i = 0; i < out.size(); ++i)
         {
-            for (unsigned int i = 0; i < out.size(); ++i)
-            {
-                BOOST_TEST(it.second[i] == out[i], boost::test_tools::tolerance(0.000001f));
-            }
+            BOOST_CHECK(Compare<ArmnnOType>(it.second[i], out[i]) == true);
         }
     }
 }
diff --git a/src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.cpp b/src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.cpp
new file mode 100644
index 0000000000..8eb1c97350
--- /dev/null
+++ b/src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.cpp
@@ -0,0 +1,222 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "SpaceToDepthEndToEndTestImpl.hpp"
+
+#include "ResolveType.hpp"
+#include "DataLayoutIndexed.hpp"
+#include "EndToEndTestImpl.hpp"
+
+#include <Permute.hpp>
+
+#include <armnn/INetwork.hpp>
+
+#include <backendsCommon/test/DataLayoutUtils.hpp>
+
+#include <test/TestUtils.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+namespace
+{
+
+template<typename armnn::DataType DataType>
+armnn::INetworkPtr CreateSpaceToDepthNetwork(const armnn::TensorShape& inputShape,
+                                             const armnn::TensorShape& outputShape,
+                                             const armnn::DataLayout dataLayout,
+                                             unsigned int blockSize,
+                                             const float qScale = 1.0f,
+                                             const int32_t qOffset = 0)
+{
+    using namespace armnn;
+
+    // Builds up the structure of the network.
+    INetworkPtr net(INetwork::Create());
+
+    TensorInfo inputTensorInfo(inputShape, DataType, qScale, qOffset);
+
+    armnnUtils::DataLayoutIndexed dimensionIndices(dataLayout);
+    if (inputShape[dimensionIndices.GetHeightIndex()] % blockSize!=0
+        || inputShape[dimensionIndices.GetWidthIndex()] % blockSize!=0)
+    {
+        throw InvalidArgumentException("Input shape must be divisible by block size in all spatial dimensions");
+    }
+
+    SpaceToDepthDescriptor spaceToDepthDesc;
+    spaceToDepthDesc.m_BlockSize = blockSize;
+    spaceToDepthDesc.m_DataLayout = dataLayout;
+
+    IConnectableLayer* SpaceToDepth = net->AddSpaceToDepthLayer(spaceToDepthDesc, "SpaceToDepth");
+    IConnectableLayer* input        = net->AddInputLayer(0, "input");
+    Connect(input, SpaceToDepth, inputTensorInfo, 0, 0);
+
+    TensorInfo outputTensorInfo(outputShape, DataType, qScale, qOffset);
+    IConnectableLayer* output = net->AddOutputLayer(0, "output");
+    Connect(SpaceToDepth, output, outputTensorInfo, 0, 0);
+
+    return net;
+}
+
+void SpaceToDepthEndToEnd(const std::vector<armnn::BackendId>& backends,
+                          const armnn::DataLayout& dataLayout,
+                          armnn::TensorInfo& inputTensorInfo,
+                          armnn::TensorInfo& outputTensorInfo,
+                          std::vector<float>& inputData,
+                          std::vector<float>& expectedOutputData,
+                          const unsigned int blockSize)
+{
+    using namespace armnn;
+
+    if (dataLayout == DataLayout::NCHW)
+    {
+        PermuteTensorNhwcToNchw<float>(inputTensorInfo, inputData);
+        PermuteTensorNhwcToNchw<float>(outputTensorInfo, expectedOutputData);
+    }
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateSpaceToDepthNetwork<DataType::Float32>(
+            inputTensorInfo.GetShape(),
+            outputTensorInfo.GetShape(),
+            dataLayout,
+            blockSize);
+
+    BOOST_TEST_CHECKPOINT("Create a network");
+
+    std::map<int, std::vector<float>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<float>> expectedOutputTensorData = { { 0, expectedOutputData } };
+
+    EndToEndLayerTestImpl<DataType::Float32, DataType::Float32>(
+            move(net),
+            inputTensorData,
+            expectedOutputTensorData,
+            backends);
+}
+
+} // anonymous namespace
+
+void SpaceToDepthNhwcEndToEndTest1(const std::vector<armnn::BackendId>& defaultBackends)
+{
+    using namespace armnn;
+
+    const unsigned int blockSize = 2;
+
+    TensorShape inputShape{1, 2, 2, 1};
+    TensorInfo inputTensorInfo(inputShape, DataType::Float32);
+
+    TensorShape outputShape{1, 1, 1, 4};
+    TensorInfo outputTensorInfo(outputShape, DataType::Float32);
+
+    std::vector<float> inputData = std::vector<float>(
+    {
+        1.0f, 2.0f, 3.0f, 4.0f
+    });
+
+    std::vector<float> expectedOutputData = std::vector<float>(
+    {
+        1.0f, 2.0f, 3.0f, 4.0f
+    });
+
+    SpaceToDepthEndToEnd(defaultBackends,
+                         DataLayout::NHWC,
+                         inputTensorInfo,
+                         outputTensorInfo,
+                         inputData,
+                         expectedOutputData,
+                         blockSize);
+}
+
+void SpaceToDepthNchwEndToEndTest1(const std::vector<armnn::BackendId>& defaultBackends)
+{
+    using namespace armnn;
+
+    const unsigned int blockSize = 2;
+
+    TensorShape inputShape{1, 2, 2, 1};
+    TensorInfo inputTensorInfo(inputShape, DataType::Float32);
+
+    TensorShape outputShape{1, 1, 1, 4};
+    TensorInfo outputTensorInfo(outputShape, DataType::Float32);
+
+    std::vector<float> inputData = std::vector<float>(
+    {
+        1.0f, 2.0f, 3.0f, 4.0f
+    });
+
+    std::vector<float> expectedOutputData = std::vector<float>(
+    {
+        1.0f, 2.0f, 3.0f, 4.0f
+    });
+
+    SpaceToDepthEndToEnd(defaultBackends,
+                         DataLayout::NCHW,
+                         inputTensorInfo,
+                         outputTensorInfo,
+                         inputData,
+                         expectedOutputData,
+                         blockSize);
+}
+
+void SpaceToDepthNhwcEndToEndTest2(const std::vector<armnn::BackendId>& defaultBackends)
+{
+    using namespace armnn;
+
+    const unsigned int blockSize = 2;
+
+    TensorShape inputShape{1, 2, 2, 2};
+    TensorShape outputShape{1, 1, 1, 8};
+
+    TensorInfo outputTensorInfo(outputShape, DataType::Float32);
+    TensorInfo inputTensorInfo(inputShape, DataType::Float32);
+
+    std::vector<float> inputData = std::vector<float>(
+    {
+        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
+    });
+
+    std::vector<float> expectedOutputData = std::vector<float>(
+    {
+        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
+    });
+
+    SpaceToDepthEndToEnd(defaultBackends,
+                         DataLayout::NHWC,
+                         inputTensorInfo,
+                         outputTensorInfo,
+                         inputData,
+                         expectedOutputData,
+                         blockSize);
+}
+
+void SpaceToDepthNchwEndToEndTest2(const std::vector<armnn::BackendId>& defaultBackends)
+{
+    using namespace armnn;
+
+    const unsigned int blockSize = 2;
+
+    TensorShape inputShape{1, 2, 2, 2};
+    TensorShape outputShape{1, 1, 1, 8};
+
+    TensorInfo inputTensorInfo(inputShape, DataType::Float32);
+    TensorInfo outputTensorInfo(outputShape, DataType::Float32);
+
+
+    std::vector<float> inputData = std::vector<float>(
+    {
+        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
+    });
+
+    std::vector<float> expectedOutputData = std::vector<float>(
+    {
+        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
+    });
+
+    SpaceToDepthEndToEnd(defaultBackends,
+                         DataLayout::NCHW,
+                         inputTensorInfo,
+                         outputTensorInfo,
+                         inputData,
+                         expectedOutputData,
+                         blockSize);
+}
diff --git a/src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp
index fd442a88e8..e765c4126d 100644
--- a/src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp
+++ b/src/backends/backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp
@@ -2,225 +2,17 @@
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
-#pragma once
-
-#include "ResolveType.hpp"
-#include "DataLayoutIndexed.hpp"
-#include "EndToEndTestImpl.hpp"
-
-#include "armnn/INetwork.hpp"
 
-#include "backendsCommon/test/CommonTestUtils.hpp"
+#pragma once
 
-#include <Permute.hpp>
-#include <boost/test/unit_test.hpp>
+#include <armnn/BackendId.hpp>
 
 #include <vector>
 
-namespace
-{
-template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
-void PermuteDataToNCHW(const std::vector<armnn::BackendId>& backends,
-                       const armnn::DataLayout& dataLayout,
-                       TensorInfo& tensorInfo,
-                       std::vector<T>& data)
-{
-    const armnn::PermutationVector NHWCToNCHW = {0, 2, 3, 1};
-
-    tensorInfo = armnnUtils::Permuted(tensorInfo, NHWCToNCHW);
-
-    std::vector<T> tmp(data.size());
-    armnnUtils::Permute(tensorInfo.GetShape(), NHWCToNCHW, data.data(), tmp.data(), sizeof(T));
-
-    data = tmp;
-}
-
-template<typename armnn::DataType DataType>
-armnn::INetworkPtr CreateSpaceToDepthNetwork(const armnn::TensorShape& inputShape,
-                                             const armnn::TensorShape& outputShape,
-                                             const armnn::DataLayout dataLayout,
-                                             unsigned int blockSize,
-                                             const float qScale = 1.0f,
-                                             const int32_t qOffset = 0)
-{
-    using namespace armnn;
-    // Builds up the structure of the network.
-    INetworkPtr net(INetwork::Create());
-
-    TensorInfo inputTensorInfo(inputShape, DataType, qScale, qOffset);
-
-    armnnUtils::DataLayoutIndexed dimensionIndices(dataLayout);
-    if (inputShape[dimensionIndices.GetHeightIndex()] % blockSize!=0
-        || inputShape[dimensionIndices.GetWidthIndex()] % blockSize!=0)
-    {
-        throw InvalidArgumentException("Input shape must be divisible by block size in all spatial dimensions");
-    }
-
-    SpaceToDepthDescriptor spaceToDepthDesc;
-    spaceToDepthDesc.m_BlockSize = blockSize;
-    spaceToDepthDesc.m_DataLayout = dataLayout;
-
-    IConnectableLayer* SpaceToDepth = net->AddSpaceToDepthLayer(spaceToDepthDesc, "SpaceToDepth");
-    IConnectableLayer* input        = net->AddInputLayer(0, "input");
-    Connect(input, SpaceToDepth, inputTensorInfo, 0, 0);
-
-    TensorInfo outputTensorInfo(outputShape, DataType, qScale, qOffset);
-    IConnectableLayer* output = net->AddOutputLayer(0, "output");
-    Connect(SpaceToDepth, output, outputTensorInfo, 0, 0);
-
-    return net;
-}
-
-void SpaceToDepthEndToEnd(const std::vector<armnn::BackendId>& backends,
-                          const armnn::DataLayout& dataLayout,
-                          TensorInfo& inputTensorInfo,
-                          TensorInfo& outputTensorInfo,
-                          std::vector<float>& inputData,
-                          std::vector<float>& expectedOutputData,
-                          const unsigned int blockSize)
-{
-    using namespace armnn;
-
-    if (dataLayout == armnn::DataLayout::NCHW)
-    {
-        PermuteDataToNCHW<armnn::DataType::Float32>(backends, dataLayout, inputTensorInfo, inputData);
-        PermuteDataToNCHW<armnn::DataType::Float32>(backends, dataLayout, outputTensorInfo, expectedOutputData);
-    }
-
-    // Builds up the structure of the network
-    INetworkPtr net = CreateSpaceToDepthNetwork<armnn::DataType::Float32>(
-            inputTensorInfo.GetShape(),
-            outputTensorInfo.GetShape(),
-            dataLayout,
-            blockSize);
-
-    BOOST_TEST_CHECKPOINT("Create a network");
-
-    std::map<int, std::vector<float>> inputTensorData = { { 0, inputData } };
-    std::map<int, std::vector<float>> expectedOutputTensorData = { { 0, expectedOutputData } };
-
-    EndToEndLayerTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
-            move(net),
-            inputTensorData,
-            expectedOutputTensorData,
-            backends);
-}
-
-void SpaceToDepthNHWCEndToEndTest1(const std::vector<armnn::BackendId>& defaultBackends)
-{
-    const unsigned int blockSize = 2;
-
-    armnn::TensorShape inputShape{1, 2, 2, 1};
-    armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Float32);
-
-    armnn::TensorShape outputShape{1, 1, 1, 4};
-    armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
-
-    std::vector<float> inputData = std::vector<float>(
-    {
-        1.0f, 2.0f, 3.0f, 4.0f
-    });
-
-    std::vector<float> expectedOutputData = std::vector<float>(
-    {
-        1.0f, 2.0f, 3.0f, 4.0f
-    });
-
-    SpaceToDepthEndToEnd(defaultBackends,
-                         armnn::DataLayout::NHWC,
-                         inputTensorInfo,
-                         outputTensorInfo,
-                         inputData,
-                         expectedOutputData,
-                         blockSize);
-}
-
-void SpaceToDepthNCHWEndToEndTest1(const std::vector<armnn::BackendId>& defaultBackends)
-{
-    const unsigned int blockSize = 2;
-
-    armnn::TensorShape inputShape{1, 2, 2, 1};
-    armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Float32);
-
-    armnn::TensorShape outputShape{1, 1, 1, 4};
-    armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
-
-    std::vector<float> inputData = std::vector<float>(
-    {
-        1.0f, 2.0f, 3.0f, 4.0f
-    });
-
-    std::vector<float> expectedOutputData = std::vector<float>(
-    {
-        1.0f, 2.0f, 3.0f, 4.0f
-    });
-
-    SpaceToDepthEndToEnd(defaultBackends,
-                         armnn::DataLayout::NCHW,
-                         inputTensorInfo,
-                         outputTensorInfo,
-                         inputData,
-                         expectedOutputData,
-                         blockSize);
-}
-
-void SpaceToDepthNHWCEndToEndTest2(const std::vector<armnn::BackendId>& defaultBackends)
-{
-    const unsigned int blockSize = 2;
-
-    armnn::TensorShape inputShape{1, 2, 2, 2};
-    armnn::TensorShape outputShape{1, 1, 1, 8};
-
-    armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
-    armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Float32);
-
-    std::vector<float> inputData = std::vector<float>(
-    {
-        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
-    });
-
-    std::vector<float> expectedOutputData = std::vector<float>(
-    {
-        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
-    });
-
-    SpaceToDepthEndToEnd(defaultBackends,
-                         armnn::DataLayout::NHWC,
-                         inputTensorInfo,
-                         outputTensorInfo,
-                         inputData,
-                         expectedOutputData,
-                         blockSize);
-}
-
-void SpaceToDepthNCHWEndToEndTest2(const std::vector<armnn::BackendId>& defaultBackends)
-{
-    const unsigned int blockSize = 2;
-
-    armnn::TensorShape inputShape{1, 2, 2, 2};
-    armnn::TensorShape outputShape{1, 1, 1, 8};
-
-    armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Float32);
-    armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
-
-
-    std::vector<float> inputData = std::vector<float>(
-    {
-        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
-    });
+void SpaceToDepthNhwcEndToEndTest1(const std::vector<armnn::BackendId>& defaultBackends);
 
-    std::vector<float> expectedOutputData = std::vector<float>(
-    {
-        1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f
-    });
+void SpaceToDepthNchwEndToEndTest1(const std::vector<armnn::BackendId>& defaultBackends);
 
-    SpaceToDepthEndToEnd(defaultBackends,
-                         armnn::DataLayout::NCHW,
-                         inputTensorInfo,
-                         outputTensorInfo,
-                         inputData,
-                         expectedOutputData,
-                         blockSize);
-}
+void SpaceToDepthNhwcEndToEndTest2(const std::vector<armnn::BackendId>& defaultBackends);
 
-} // anonymous namespace
+void SpaceToDepthNchwEndToEndTest2(const std::vector<armnn::BackendId>& defaultBackends);
diff --git a/src/backends/backendsCommon/test/layerTests/DepthToSpaceTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/DepthToSpaceTestImpl.cpp
index 9588f560ef..e21a4b64f8 100644
--- a/src/backends/backendsCommon/test/layerTests/DepthToSpaceTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/DepthToSpaceTestImpl.cpp
@@ -9,6 +9,7 @@
 
 #include <armnn/ArmNN.hpp>
 
+#include <backendsCommon/test/DataLayoutUtils.hpp>
 #include <backendsCommon/test/TensorCopyUtils.hpp>
 #include <backendsCommon/test/WorkloadTestUtils.hpp>
 
@@ -29,22 +30,10 @@ LayerTestResult<T, 4> DepthToSpaceTestImpl(
     const float qScale = 1.0f,
     const int32_t qOffset = 0)
 {
-    const armnn::PermutationVector permVector{0, 2, 3, 1};
-
     if (descriptor.m_Parameters.m_DataLayout == armnn::DataLayout::NCHW)
     {
-        inputInfo  = armnnUtils::Permuted(inputInfo, permVector);
-        outputInfo = armnnUtils::Permuted(outputInfo, permVector);
-
-        constexpr size_t typeSize = sizeof(float);
-
-        std::vector<float> inputTmp(inputData.size());
-        armnnUtils::Permute(inputInfo.GetShape(), permVector, inputData.data(), inputTmp.data(), typeSize);
-        inputData = inputTmp;
-
-        std::vector<float> outputTmp(expectedOutputData.size());
-        armnnUtils::Permute(outputInfo.GetShape(), permVector, expectedOutputData.data(), outputTmp.data(), typeSize);
-        expectedOutputData = outputTmp;
+        PermuteTensorNhwcToNchw<float>(inputInfo, inputData);
+        PermuteTensorNhwcToNchw<float>(outputInfo, expectedOutputData);
     }
 
     if(armnn::IsQuantizedType<T>())
diff --git a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp
index 6191adf61f..7391f9c198 100644
--- a/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/TransposeConvolution2dTestImpl.hpp
@@ -12,7 +12,7 @@
 
 #include <backendsCommon/CpuTensorHandle.hpp>
 
-#include <backendsCommon/test/CommonTestUtils.hpp>
+#include <backendsCommon/test/DataLayoutUtils.hpp>
 #include <backendsCommon/test/QuantizeHelper.hpp>
 #include <backendsCommon/test/TensorCopyUtils.hpp>
 #include <backendsCommon/test/WorkloadTestUtils.hpp>
@@ -194,27 +194,16 @@ LayerTestResult<T, 4> TransposeConvolution2dTest(
 }
 
 template<typename T>
-void SwizzleData(const armnn::TensorInfo& inputInfo,
+void SwizzleData(armnn::TensorInfo& inputInfo,
                  std::vector<T>& inputData,
-                 const armnn::TensorInfo& outputInfo,
+                 armnn::TensorInfo& outputInfo,
                  std::vector<T>& outputData,
-                 const armnn::TensorInfo& weightsInfo,
+                 armnn::TensorInfo& weightsInfo,
                  std::vector<T>& weightsData)
 {
-    constexpr size_t dataTypeSize = sizeof(float);
-    const armnn::PermutationVector nchwToNhwc = { 0, 3, 1, 2 };
-
-    std::vector<T> tmp(inputData.size());
-    armnnUtils::Permute(inputInfo.GetShape(), nchwToNhwc, inputData.data(), tmp.data(), dataTypeSize);
-    inputData = tmp;
-
-    tmp.resize(weightsData.size());
-    armnnUtils::Permute(weightsInfo.GetShape(), nchwToNhwc, weightsData.data(), tmp.data(), dataTypeSize);
-    weightsData = tmp;
-
-    tmp.resize(outputData.size());
-    armnnUtils::Permute(outputInfo.GetShape(), nchwToNhwc, outputData.data(), tmp.data(), dataTypeSize);
-    outputData = tmp;
+    PermuteTensorNchwToNhwc<T>(inputInfo, inputData);
+    PermuteTensorNchwToNhwc<T>(outputInfo, outputData);
+    PermuteTensorNchwToNhwc<T>(weightsInfo, weightsData);
 }
 
 } // anonymous namespace
@@ -240,9 +229,9 @@ LayerTestResult<T, 4> SimpleTransposeConvolution2dTest(
     constexpr unsigned int wWeights = 3u;
     constexpr unsigned int hWeights = wWeights;
 
-    TensorShape inputShape   = MakeTensorShape(batches, channels, hInput, wInput, layout);
-    TensorShape outputShape  = MakeTensorShape(batches, channels, hOutput, wOutput, layout);
-    TensorShape weightsShape = MakeTensorShape(batches, channels, hWeights, wWeights, layout);
+    TensorShape inputShape   = { batches, channels, hInput,   wInput   };
+    TensorShape outputShape  = { batches, channels, hOutput,  wOutput  };
+    TensorShape weightsShape = { batches, channels, hWeights, wWeights };
 
     TensorInfo inputInfo(inputShape, ArmnnType);
     TensorInfo outputInfo(outputShape, ArmnnType);
@@ -327,9 +316,9 @@ LayerTestResult<T, 4> PaddedTransposeConvolution2dTest(
     constexpr unsigned int wWeights = 3u;
     constexpr unsigned int hWeights = wWeights;
 
-    TensorShape inputShape   = MakeTensorShape(batches, channels, hInput, wInput, layout);
-    TensorShape outputShape  = MakeTensorShape(batches, channels, hOutput, wOutput, layout);
-    TensorShape weightsShape = MakeTensorShape(batches, channels, hWeights, wWeights, layout);
+    TensorShape inputShape   = { batches, channels, hInput,   wInput   };
+    TensorShape outputShape  = { batches, channels, hOutput,  wOutput  };
+    TensorShape weightsShape = { batches, channels, hWeights, wWeights };
 
     TensorInfo inputInfo(inputShape, ArmnnType);
     TensorInfo outputInfo(outputShape, ArmnnType);
@@ -416,9 +405,9 @@ LayerTestResult<T, 4> StridedTransposeConvolution2dTest(
     constexpr unsigned int wWeights = 3u;
     constexpr unsigned int hWeights = wWeights;
 
-    TensorShape inputShape   = MakeTensorShape(batches, channels, hInput, wInput, layout);
-    TensorShape outputShape  = MakeTensorShape(batches, channels, hOutput, wOutput, layout);
-    TensorShape weightsShape = MakeTensorShape(batches, channels, hWeights, wWeights, layout);
+    TensorShape inputShape   = { batches, channels, hInput,   wInput   };
+    TensorShape outputShape  = { batches, channels, hOutput,  wOutput  };
+    TensorShape weightsShape = { batches, channels, hWeights, wWeights };
 
     TensorInfo inputInfo(inputShape, ArmnnType);
     TensorInfo outputInfo(outputShape, ArmnnType);
@@ -492,11 +481,11 @@ LayerTestResult<T, 4> MultiChannelTransposeConvolution2dTest(
 {
     using namespace armnn;
 
-    TensorShape inputShape   = MakeTensorShape(1, 1, 2, 2, layout);
-    TensorShape outputShape  = MakeTensorShape(1, 2, 5, 5, layout);
+    TensorShape inputShape   = { 1, 1, 2, 2 };
+    TensorShape outputShape  = { 1, 2, 5, 5 };
 
     // OIHW for NCHW; OHWI for NHWC
-    TensorShape weightsShape = MakeTensorShape(2, 1, 3, 3, layout);
+    TensorShape weightsShape = { 2, 1, 3, 3 };
     TensorShape biasesShape  = { 2 };
 
     TensorInfo inputInfo(inputShape, ArmnnType);
diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp
index b1e51c648f..d5d1ad513f 100644
--- a/src/backends/cl/test/ClEndToEndTests.cpp
+++ b/src/backends/cl/test/ClEndToEndTests.cpp
@@ -8,6 +8,7 @@
 #include <backendsCommon/test/AbsEndToEndTestImpl.hpp>
 #include <backendsCommon/test/ArithmeticTestImpl.hpp>
 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
+#include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
 #include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp>
@@ -63,6 +64,48 @@ BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Uint8Test)
     ConcatDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
+// DepthToSpace
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+// Dequantize
 BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
 {
     DequantizeEndToEndSimple<armnn::DataType::QuantisedAsymm8>(defaultBackends);
@@ -123,24 +166,24 @@ BOOST_AUTO_TEST_CASE(ClPreluEndToEndTestUint8)
     PreluEndToEndPositiveTest<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNHWCEndToEndTest1)
+BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest1)
 {
-    SpaceToDepthNHWCEndToEndTest1(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest1(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNCHWEndToEndTest1)
+BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest1)
 {
-    SpaceToDepthNCHWEndToEndTest1(defaultBackends);
+    SpaceToDepthNchwEndToEndTest1(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNHWCEndToEndTest2)
+BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest2)
 {
-    SpaceToDepthNHWCEndToEndTest2(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest2(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNCHWEndToEndTest2)
+BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest2)
 {
-    SpaceToDepthNCHWEndToEndTest2(defaultBackends);
+    SpaceToDepthNchwEndToEndTest2(defaultBackends);
 }
 
 BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndTest)
diff --git a/src/backends/neon/test/NeonEndToEndTests.cpp b/src/backends/neon/test/NeonEndToEndTests.cpp
index 3296918117..9d7fc9d4b9 100644
--- a/src/backends/neon/test/NeonEndToEndTests.cpp
+++ b/src/backends/neon/test/NeonEndToEndTests.cpp
@@ -8,6 +8,7 @@
 #include <backendsCommon/test/AbsEndToEndTestImpl.hpp>
 #include <backendsCommon/test/ArithmeticTestImpl.hpp>
 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
+#include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
 #include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp>
@@ -143,6 +144,48 @@ BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim3Uint8Test)
     ConcatDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
+// DepthToSpace
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+// Dequantize
 BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
 {
     DequantizeEndToEndSimple<armnn::DataType::QuantisedAsymm8>(defaultBackends);
@@ -163,24 +206,24 @@ BOOST_AUTO_TEST_CASE(NeonPreluEndToEndTestUint8Test)
     PreluEndToEndPositiveTest<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNHWCEndToEndTest1)
+BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNhwcEndToEndTest1)
 {
-    SpaceToDepthNHWCEndToEndTest1(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest1(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNCHWEndToEndTest1)
+BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNchwEndToEndTest1)
 {
-    SpaceToDepthNCHWEndToEndTest1(defaultBackends);
+    SpaceToDepthNchwEndToEndTest1(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNHWCEndToEndTest2)
+BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNhwcEndToEndTest2)
 {
-    SpaceToDepthNHWCEndToEndTest2(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest2(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNCHWEndToEndTest2)
+BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNchwEndToEndTest2)
 {
-    SpaceToDepthNCHWEndToEndTest2(defaultBackends);
+    SpaceToDepthNchwEndToEndTest2(defaultBackends);
 }
 
 BOOST_AUTO_TEST_CASE(NeonSplitter1dEndToEndTest)
diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp
index b670015f77..c60dbbd7c7 100644
--- a/src/backends/reference/test/RefEndToEndTests.cpp
+++ b/src/backends/reference/test/RefEndToEndTests.cpp
@@ -9,6 +9,7 @@
 #include <backendsCommon/test/ArithmeticTestImpl.hpp>
 #include <backendsCommon/test/BatchToSpaceNdEndToEndTestImpl.hpp>
 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
+#include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
 #include <backendsCommon/test/DetectionPostProcessEndToEndTestImpl.hpp>
 #include <backendsCommon/test/GatherEndToEndTestImpl.hpp>
@@ -550,6 +551,48 @@ BOOST_AUTO_TEST_CASE(RefGatherMultiDimInt16Test)
     GatherMultiDimEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends);
 }
 
+// DepthToSpace
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NCHW);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16)
+{
+    DepthToSpaceEndToEnd<armnn::DataType::QuantisedSymm16>(defaultBackends, armnn::DataLayout::NHWC);
+}
+
+// Dequantize
 BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
 {
     DequantizeEndToEndSimple<armnn::DataType::QuantisedAsymm8>(defaultBackends);
@@ -749,25 +792,25 @@ BOOST_AUTO_TEST_CASE(RefPreluEndToEndTestQSymm16)
     PreluEndToEndPositiveTest<armnn::DataType::QuantisedSymm16>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSpaceToDepthNHWCEndToEndTest1)
+BOOST_AUTO_TEST_CASE(RefSpaceToDepthNhwcEndToEndTest1)
 {
-    SpaceToDepthNHWCEndToEndTest1(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest1(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSpaceToDepthNCHWEndToEndTest1)
+BOOST_AUTO_TEST_CASE(RefSpaceToDepthNchwEndToEndTest1)
 {
-    SpaceToDepthNCHWEndToEndTest1(defaultBackends);
+    SpaceToDepthNchwEndToEndTest1(defaultBackends);
 
 }
 
-BOOST_AUTO_TEST_CASE(RefSpaceToDepthNHWCEndToEndTest2)
+BOOST_AUTO_TEST_CASE(RefSpaceToDepthNhwcEndToEndTest2)
 {
-    SpaceToDepthNHWCEndToEndTest2(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest2(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSpaceToDepthNCHWEndToEndTest2)
+BOOST_AUTO_TEST_CASE(RefSpaceToDepthNchwEndToEndTest2)
 {
-    SpaceToDepthNCHWEndToEndTest2(defaultBackends);
+    SpaceToDepthNchwEndToEndTest2(defaultBackends);
 }
 
 BOOST_AUTO_TEST_CASE(RefSplitter1dEndToEndTest)