diff --git a/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp
index f9fbcf5..6c4c177 100644
--- a/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp
+++ b/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp
@@ -45,7 +45,7 @@
     }
     splitterDimSizes[splitAxis] /= numSplit;
 
-    SplitterDescriptor splitDesc(numSplit);
+    SplitterDescriptor splitDesc(numSplit, inputShape.GetNumDimensions());
     for (unsigned int g = 0; g < numSplit; ++g)
     {
         // Set the size of the views.
@@ -71,7 +71,244 @@
 }
 
 template<armnn::DataType ArmnnType>
-void SplitterDim0EndToEnd(const std::vector<BackendId>& backends)
+void Splitter1dEndToEnd(const std::vector<BackendId>& backends)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    unsigned int splitAxis = 0;
+    unsigned int numSplit = 2;
+    const TensorShape& inputShape = { 4 };
+    const std::vector<TensorShape> outputShapes{{ 2 }, { 2 }};
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{ 1, 2, 3, 4 };
+
+    std::vector<T> expectedOutput0{ 1, 2 };
+    std::vector<T> expectedOutput1{ 3, 4 };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 }, {1, expectedOutput1} };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnType>
+void Splitter2dDim0EndToEnd(const std::vector<BackendId>& backends)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    unsigned int splitAxis = 0;
+    unsigned int numSplit = 2;
+    const TensorShape& inputShape = { 4, 3 };
+    const std::vector<TensorShape> outputShapes{{ 2, 3 }, { 2, 3 }};
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{
+            1, 2,
+            3, 4,
+            5, 6,
+            7, 8,
+            9, 10,
+            11, 12
+    };
+
+    std::vector<T> expectedOutput0{ 1, 2, 3, 4, 5, 6 };
+    std::vector<T> expectedOutput1{ 7, 8, 9, 10, 11, 12 };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 }, {1, expectedOutput1} };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnType>
+void Splitter2dDim1EndToEnd(const std::vector<BackendId>& backends)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    unsigned int splitAxis = 1;
+    unsigned int numSplit = 3;
+    const TensorShape& inputShape = { 4, 3 };
+    const std::vector<TensorShape> outputShapes{{ 4, 1 }, { 4, 1 }, { 4, 1 }};
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{
+            1, 2,
+            3, 4,
+            5, 6,
+            7, 8,
+            9, 10,
+            11, 12
+    };
+
+    std::vector<T> expectedOutput0{ 1, 4, 7, 10 };
+    std::vector<T> expectedOutput1{ 2, 5, 8, 11 };
+    std::vector<T> expectedOutput2{ 3, 6, 9, 12 };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
+                                                         { 1, expectedOutput1 },
+                                                         { 2, expectedOutput2 } };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnType>
+void Splitter3dDim0EndToEnd(const std::vector<BackendId>& backends)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    unsigned int splitAxis = 0;
+    unsigned int numSplit = 2;
+    const TensorShape& inputShape = { 2, 4, 3 };
+    const std::vector<TensorShape> outputShapes{{ 1, 4, 3 }, { 1, 4, 3 }};
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{
+            1, 2, 3,
+            4, 5, 6,
+            7, 8, 9,
+            10, 11, 12,
+            13, 14, 15,
+            16, 17, 18,
+            19, 20, 21,
+            22, 23, 24
+    };
+
+    std::vector<T> expectedOutput0{
+            1, 2, 3,
+            4, 5, 6,
+            7, 8, 9,
+            10, 11, 12
+    };
+    std::vector<T> expectedOutput1{
+            13, 14, 15,
+            16, 17, 18,
+            19, 20, 21,
+            22, 23, 24
+    };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
+                                                         { 1, expectedOutput1 } };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnType>
+void Splitter3dDim1EndToEnd(const std::vector<BackendId>& backends)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    unsigned int splitAxis = 1;
+    unsigned int numSplit = 2;
+    const TensorShape& inputShape = { 2, 4, 3 };
+    const std::vector<TensorShape> outputShapes{{ 2, 2, 3 }, { 2, 2, 3 }};
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{
+            1, 2, 3,
+            4, 5, 6,
+            7, 8, 9,
+            10, 11, 12,
+            13, 14, 15,
+            16, 17, 18,
+            19, 20, 21,
+            22, 23, 24
+    };
+
+    std::vector<T> expectedOutput0{
+            1, 2, 3,
+            4, 5, 6,
+            13, 14, 15,
+            16, 17, 18
+    };
+    std::vector<T> expectedOutput1{
+            7, 8, 9,
+            10, 11, 12,
+            19, 20, 21,
+            22, 23, 24
+    };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
+                                                         { 1, expectedOutput1 } };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnType>
+void Splitter3dDim2EndToEnd(const std::vector<BackendId>& backends)
+{
+    using namespace armnn;
+    using T = ResolveType<ArmnnType>;
+
+    unsigned int splitAxis = 2;
+    unsigned int numSplit = 3;
+    const TensorShape& inputShape = { 2, 4, 3 };
+    const std::vector<TensorShape> outputShapes{{ 2, 4, 1 }, { 2, 4, 1 }, { 2, 4, 1 }};
+
+    // Builds up the structure of the network
+    INetworkPtr net = CreateSplitterNetwork<ArmnnType>(inputShape, outputShapes, splitAxis, numSplit);
+
+    BOOST_TEST_CHECKPOINT("create a network");
+
+    // Creates structures for input & output.
+    std::vector<T> inputData{
+            1, 2, 3,
+            4, 5, 6,
+            7, 8, 9,
+            10, 11, 12,
+            13, 14, 15,
+            16, 17, 18,
+            19, 20, 21,
+            22, 23, 24
+    };
+
+    std::vector<T> expectedOutput0{ 1, 4, 7, 10, 13, 16, 19, 22 };
+    std::vector<T> expectedOutput1{ 2, 5, 8, 11, 14, 17, 20, 23 };
+    std::vector<T> expectedOutput2{ 3, 6, 9, 12, 15, 18, 21, 24 };
+
+    std::map<int, std::vector<T>> inputTensorData = { { 0, inputData } };
+    std::map<int, std::vector<T>> expectedOutputData = { { 0, expectedOutput0 },
+                                                         { 1, expectedOutput1 },
+                                                         { 2, expectedOutput2 } };
+
+    EndToEndLayerTestImpl<ArmnnType, ArmnnType>(move(net), inputTensorData, expectedOutputData, backends);
+}
+
+template<armnn::DataType ArmnnType>
+void Splitter4dDim0EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
     using T = ResolveType<ArmnnType>;
@@ -151,7 +388,7 @@
 }
 
 template<armnn::DataType ArmnnType>
-void SplitterDim1EndToEnd(const std::vector<BackendId>& backends)
+void Splitter4dDim1EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
     using T = ResolveType<ArmnnType>;
@@ -231,7 +468,7 @@
 }
 
 template<armnn::DataType ArmnnType>
-void SplitterDim2EndToEnd(const std::vector<BackendId>& backends)
+void Splitter4dDim2EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
     using T = ResolveType<ArmnnType>;
@@ -311,7 +548,7 @@
 }
 
 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
-void SplitterDim3EndToEnd(const std::vector<BackendId>& backends)
+void Splitter4dDim3EndToEnd(const std::vector<BackendId>& backends)
 {
     using namespace armnn;
 
diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp
index 3235f26..990a156 100644
--- a/src/backends/cl/test/ClEndToEndTests.cpp
+++ b/src/backends/cl/test/ClEndToEndTests.cpp
@@ -89,45 +89,104 @@
                                                                                             expectedOutput);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim0EndToEndTest)
+BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndTest)
 {
-    SplitterDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim1EndToEndTest)
+BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndUint8Test)
 {
-    SplitterDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim2EndToEndTest)
+BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndTest)
 {
-    SplitterDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim3EndToEndTest)
+BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndTest)
 {
-    SplitterDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim0EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndUint8Test)
 {
-    SplitterDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim1EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndUint8Test)
 {
-    SplitterDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim2EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndTest)
 {
-    SplitterDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitDim3EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndTest)
 {
-    SplitterDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
+BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndTest)
+{
+    Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndUint8Test)
+{
+    Splitter3dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndUint8Test)
+{
+    Splitter3dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndUint8Test)
+{
+    Splitter3dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndTest)
+{
+    Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndTest)
+{
+    Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndTest)
+{
+    Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndTest)
+{
+    Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndUint8Test)
+{
+    Splitter4dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndUint8Test)
+{
+    Splitter4dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndUint8Test)
+{
+    Splitter4dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndUint8Test)
+{
+    Splitter4dDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/backends/neon/test/NeonEndToEndTests.cpp b/src/backends/neon/test/NeonEndToEndTests.cpp
index 15f5fc3..d0aa233 100644
--- a/src/backends/neon/test/NeonEndToEndTests.cpp
+++ b/src/backends/neon/test/NeonEndToEndTests.cpp
@@ -123,44 +123,104 @@
     ConcatDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim0EndToEndTest)
+BOOST_AUTO_TEST_CASE(NeonSplitter1dEndToEndTest)
 {
-    SplitterDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim1EndToEndTest)
+BOOST_AUTO_TEST_CASE(NeonSplitter1dEndToEndUint8Test)
 {
-    SplitterDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim2EndToEndTest)
+BOOST_AUTO_TEST_CASE(NeonSplitter2dDim0EndToEndTest)
 {
-    SplitterDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim3EndToEndTest)
+BOOST_AUTO_TEST_CASE(NeonSplitter2dDim1EndToEndTest)
 {
-    SplitterDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim0EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(NeonSplitter2dDim0EndToEndUint8Test)
 {
-    SplitterDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim1EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(NeonSplitter2dDim1EndToEndUint8Test)
 {
-    SplitterDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim2EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(NeonSplitter3dDim0EndToEndTest)
 {
-    SplitterDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(NeonSplitDim3EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(NeonSplitter3dDim1EndToEndTest)
 {
-    SplitterDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter3dDim2EndToEndTest)
+{
+    Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter3dDim0EndToEndUint8Test)
+{
+    Splitter3dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter3dDim1EndToEndUint8Test)
+{
+    Splitter3dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter3dDim2EndToEndUint8Test)
+{
+    Splitter3dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim0EndToEndTest)
+{
+    Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim1EndToEndTest)
+{
+    Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim2EndToEndTest)
+{
+    Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim3EndToEndTest)
+{
+    Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim0EndToEndUint8Test)
+{
+    Splitter4dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim1EndToEndUint8Test)
+{
+    Splitter4dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim2EndToEndUint8Test)
+{
+    Splitter4dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(NeonSplitter4dDim3EndToEndUint8Test)
+{
+    Splitter4dDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp
index 2b7fb77..a0f1028 100644
--- a/src/backends/reference/test/RefEndToEndTests.cpp
+++ b/src/backends/reference/test/RefEndToEndTests.cpp
@@ -620,44 +620,104 @@
                                                                           1.0f, 1, 0.01f, 0, 0.5f, 0);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim0EndToEndTest)
+BOOST_AUTO_TEST_CASE(RefSplitter1dEndToEndTest)
 {
-    SplitterDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim1EndToEndTest)
+BOOST_AUTO_TEST_CASE(RefSplitter1dEndToEndUint8Test)
 {
-    SplitterDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim2EndToEndTest)
+BOOST_AUTO_TEST_CASE(RefSplitter2dDim0EndToEndTest)
 {
-    SplitterDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim3EndToEndTest)
+BOOST_AUTO_TEST_CASE(RefSplitter2dDim1EndToEndTest)
 {
-    SplitterDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim0EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(RefSplitter2dDim0EndToEndUint8Test)
 {
-    SplitterDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim1EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(RefSplitter2dDim1EndToEndUint8Test)
 {
-    SplitterDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim2EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(RefSplitter3dDim0EndToEndTest)
 {
-    SplitterDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefSplitDim3EndToEndUint8Test)
+BOOST_AUTO_TEST_CASE(RefSplitter3dDim1EndToEndTest)
 {
-    SplitterDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+    Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter3dDim2EndToEndTest)
+{
+    Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter3dDim0EndToEndUint8Test)
+{
+    Splitter3dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter3dDim1EndToEndUint8Test)
+{
+    Splitter3dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter3dDim2EndToEndUint8Test)
+{
+    Splitter3dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim0EndToEndTest)
+{
+    Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim1EndToEndTest)
+{
+    Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim2EndToEndTest)
+{
+    Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim3EndToEndTest)
+{
+    Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim0EndToEndUint8Test)
+{
+    Splitter4dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim1EndToEndUint8Test)
+{
+    Splitter4dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim2EndToEndUint8Test)
+{
+    Splitter4dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
+}
+
+BOOST_AUTO_TEST_CASE(RefSplitter4dDim3EndToEndUint8Test)
+{
+    Splitter4dDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 }
 
 BOOST_AUTO_TEST_SUITE_END()