From 0f072ab1bf503d17b874db89a9f45f123f7c2fcc Mon Sep 17 00:00:00 2001 From: Narumol Prangnawarat Date: Wed, 29 May 2019 14:12:46 +0100 Subject: IVGCVSW-2771 Add more end to end tests for splitter on Cl, Neon, Ref to cover different number of dimensions and split axis Signed-off-by: Narumol Prangnawarat Change-Id: Ia9a111c8dcfc08d04b54aa770d1ae5312c6b1c93 --- .../test/SplitterEndToEndTestImpl.hpp | 247 ++++++++++++++++++++- src/backends/cl/test/ClEndToEndTests.cpp | 91 ++++++-- src/backends/neon/test/NeonEndToEndTests.cpp | 92 ++++++-- src/backends/reference/test/RefEndToEndTests.cpp | 92 ++++++-- 4 files changed, 469 insertions(+), 53 deletions(-) diff --git a/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp index f9fbcf55cb..6c4c1772b6 100644 --- a/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp +++ b/src/backends/backendsCommon/test/SplitterEndToEndTestImpl.hpp @@ -45,7 +45,7 @@ INetworkPtr CreateSplitterNetwork(const TensorShape& inputShape, } 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 @@ INetworkPtr CreateSplitterNetwork(const TensorShape& inputShape, } template -void SplitterDim0EndToEnd(const std::vector& backends) +void Splitter1dEndToEnd(const std::vector& backends) +{ + using namespace armnn; + using T = ResolveType; + + unsigned int splitAxis = 0; + unsigned int numSplit = 2; + const TensorShape& inputShape = { 4 }; + const std::vector outputShapes{{ 2 }, { 2 }}; + + // Builds up the structure of the network + INetworkPtr net = CreateSplitterNetwork(inputShape, outputShapes, splitAxis, numSplit); + + BOOST_TEST_CHECKPOINT("create a network"); + + // Creates structures for input & output. + std::vector inputData{ 1, 2, 3, 4 }; + + std::vector expectedOutput0{ 1, 2 }; + std::vector expectedOutput1{ 3, 4 }; + + std::map> inputTensorData = { { 0, inputData } }; + std::map> expectedOutputData = { { 0, expectedOutput0 }, {1, expectedOutput1} }; + + EndToEndLayerTestImpl(move(net), inputTensorData, expectedOutputData, backends); +} + +template +void Splitter2dDim0EndToEnd(const std::vector& backends) +{ + using namespace armnn; + using T = ResolveType; + + unsigned int splitAxis = 0; + unsigned int numSplit = 2; + const TensorShape& inputShape = { 4, 3 }; + const std::vector outputShapes{{ 2, 3 }, { 2, 3 }}; + + // Builds up the structure of the network + INetworkPtr net = CreateSplitterNetwork(inputShape, outputShapes, splitAxis, numSplit); + + BOOST_TEST_CHECKPOINT("create a network"); + + // Creates structures for input & output. + std::vector inputData{ + 1, 2, + 3, 4, + 5, 6, + 7, 8, + 9, 10, + 11, 12 + }; + + std::vector expectedOutput0{ 1, 2, 3, 4, 5, 6 }; + std::vector expectedOutput1{ 7, 8, 9, 10, 11, 12 }; + + std::map> inputTensorData = { { 0, inputData } }; + std::map> expectedOutputData = { { 0, expectedOutput0 }, {1, expectedOutput1} }; + + EndToEndLayerTestImpl(move(net), inputTensorData, expectedOutputData, backends); +} + +template +void Splitter2dDim1EndToEnd(const std::vector& backends) +{ + using namespace armnn; + using T = ResolveType; + + unsigned int splitAxis = 1; + unsigned int numSplit = 3; + const TensorShape& inputShape = { 4, 3 }; + const std::vector outputShapes{{ 4, 1 }, { 4, 1 }, { 4, 1 }}; + + // Builds up the structure of the network + INetworkPtr net = CreateSplitterNetwork(inputShape, outputShapes, splitAxis, numSplit); + + BOOST_TEST_CHECKPOINT("create a network"); + + // Creates structures for input & output. + std::vector inputData{ + 1, 2, + 3, 4, + 5, 6, + 7, 8, + 9, 10, + 11, 12 + }; + + std::vector expectedOutput0{ 1, 4, 7, 10 }; + std::vector expectedOutput1{ 2, 5, 8, 11 }; + std::vector expectedOutput2{ 3, 6, 9, 12 }; + + std::map> inputTensorData = { { 0, inputData } }; + std::map> expectedOutputData = { { 0, expectedOutput0 }, + { 1, expectedOutput1 }, + { 2, expectedOutput2 } }; + + EndToEndLayerTestImpl(move(net), inputTensorData, expectedOutputData, backends); +} + +template +void Splitter3dDim0EndToEnd(const std::vector& backends) +{ + using namespace armnn; + using T = ResolveType; + + unsigned int splitAxis = 0; + unsigned int numSplit = 2; + const TensorShape& inputShape = { 2, 4, 3 }; + const std::vector outputShapes{{ 1, 4, 3 }, { 1, 4, 3 }}; + + // Builds up the structure of the network + INetworkPtr net = CreateSplitterNetwork(inputShape, outputShapes, splitAxis, numSplit); + + BOOST_TEST_CHECKPOINT("create a network"); + + // Creates structures for input & output. + std::vector 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 expectedOutput0{ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9, + 10, 11, 12 + }; + std::vector expectedOutput1{ + 13, 14, 15, + 16, 17, 18, + 19, 20, 21, + 22, 23, 24 + }; + + std::map> inputTensorData = { { 0, inputData } }; + std::map> expectedOutputData = { { 0, expectedOutput0 }, + { 1, expectedOutput1 } }; + + EndToEndLayerTestImpl(move(net), inputTensorData, expectedOutputData, backends); +} + +template +void Splitter3dDim1EndToEnd(const std::vector& backends) +{ + using namespace armnn; + using T = ResolveType; + + unsigned int splitAxis = 1; + unsigned int numSplit = 2; + const TensorShape& inputShape = { 2, 4, 3 }; + const std::vector outputShapes{{ 2, 2, 3 }, { 2, 2, 3 }}; + + // Builds up the structure of the network + INetworkPtr net = CreateSplitterNetwork(inputShape, outputShapes, splitAxis, numSplit); + + BOOST_TEST_CHECKPOINT("create a network"); + + // Creates structures for input & output. + std::vector 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 expectedOutput0{ + 1, 2, 3, + 4, 5, 6, + 13, 14, 15, + 16, 17, 18 + }; + std::vector expectedOutput1{ + 7, 8, 9, + 10, 11, 12, + 19, 20, 21, + 22, 23, 24 + }; + + std::map> inputTensorData = { { 0, inputData } }; + std::map> expectedOutputData = { { 0, expectedOutput0 }, + { 1, expectedOutput1 } }; + + EndToEndLayerTestImpl(move(net), inputTensorData, expectedOutputData, backends); +} + +template +void Splitter3dDim2EndToEnd(const std::vector& backends) +{ + using namespace armnn; + using T = ResolveType; + + unsigned int splitAxis = 2; + unsigned int numSplit = 3; + const TensorShape& inputShape = { 2, 4, 3 }; + const std::vector outputShapes{{ 2, 4, 1 }, { 2, 4, 1 }, { 2, 4, 1 }}; + + // Builds up the structure of the network + INetworkPtr net = CreateSplitterNetwork(inputShape, outputShapes, splitAxis, numSplit); + + BOOST_TEST_CHECKPOINT("create a network"); + + // Creates structures for input & output. + std::vector 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 expectedOutput0{ 1, 4, 7, 10, 13, 16, 19, 22 }; + std::vector expectedOutput1{ 2, 5, 8, 11, 14, 17, 20, 23 }; + std::vector expectedOutput2{ 3, 6, 9, 12, 15, 18, 21, 24 }; + + std::map> inputTensorData = { { 0, inputData } }; + std::map> expectedOutputData = { { 0, expectedOutput0 }, + { 1, expectedOutput1 }, + { 2, expectedOutput2 } }; + + EndToEndLayerTestImpl(move(net), inputTensorData, expectedOutputData, backends); +} + +template +void Splitter4dDim0EndToEnd(const std::vector& backends) { using namespace armnn; using T = ResolveType; @@ -151,7 +388,7 @@ void SplitterDim0EndToEnd(const std::vector& backends) } template -void SplitterDim1EndToEnd(const std::vector& backends) +void Splitter4dDim1EndToEnd(const std::vector& backends) { using namespace armnn; using T = ResolveType; @@ -231,7 +468,7 @@ void SplitterDim1EndToEnd(const std::vector& backends) } template -void SplitterDim2EndToEnd(const std::vector& backends) +void Splitter4dDim2EndToEnd(const std::vector& backends) { using namespace armnn; using T = ResolveType; @@ -311,7 +548,7 @@ void SplitterDim2EndToEnd(const std::vector& backends) } template> -void SplitterDim3EndToEnd(const std::vector& backends) +void Splitter4dDim3EndToEnd(const std::vector& backends) { using namespace armnn; diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp index 3235f26334..990a156acf 100644 --- a/src/backends/cl/test/ClEndToEndTests.cpp +++ b/src/backends/cl/test/ClEndToEndTests.cpp @@ -89,45 +89,104 @@ BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndUint8Test) expectedOutput); } -BOOST_AUTO_TEST_CASE(ClSplitDim0EndToEndTest) +BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndTest) { - SplitterDim0EndToEnd(defaultBackends); + Splitter1dEndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitDim1EndToEndTest) +BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndUint8Test) { - SplitterDim1EndToEnd(defaultBackends); + Splitter1dEndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitDim2EndToEndTest) +BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndTest) { - SplitterDim2EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitDim3EndToEndTest) +BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndTest) { - SplitterDim3EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitDim0EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndUint8Test) { - SplitterDim0EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitDim1EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndUint8Test) { - SplitterDim1EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitDim2EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndTest) { - SplitterDim2EndToEnd(defaultBackends); + Splitter3dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitDim3EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndTest) { - SplitterDim3EndToEnd(defaultBackends); + Splitter3dDim1EndToEnd(defaultBackends); } +BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndTest) +{ + Splitter3dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndUint8Test) +{ + Splitter3dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndUint8Test) +{ + Splitter3dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndUint8Test) +{ + Splitter3dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndTest) +{ + Splitter4dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndTest) +{ + Splitter4dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndTest) +{ + Splitter4dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndTest) +{ + Splitter4dDim3EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndUint8Test) +{ + Splitter4dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndUint8Test) +{ + Splitter4dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndUint8Test) +{ + Splitter4dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndUint8Test) +{ + Splitter4dDim3EndToEnd(defaultBackends); +} BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/neon/test/NeonEndToEndTests.cpp b/src/backends/neon/test/NeonEndToEndTests.cpp index 15f5fc330e..d0aa2339b3 100644 --- a/src/backends/neon/test/NeonEndToEndTests.cpp +++ b/src/backends/neon/test/NeonEndToEndTests.cpp @@ -123,44 +123,104 @@ BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim3Uint8Test) ConcatDim3EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim0EndToEndTest) +BOOST_AUTO_TEST_CASE(NeonSplitter1dEndToEndTest) { - SplitterDim0EndToEnd(defaultBackends); + Splitter1dEndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim1EndToEndTest) +BOOST_AUTO_TEST_CASE(NeonSplitter1dEndToEndUint8Test) { - SplitterDim1EndToEnd(defaultBackends); + Splitter1dEndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim2EndToEndTest) +BOOST_AUTO_TEST_CASE(NeonSplitter2dDim0EndToEndTest) { - SplitterDim2EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim3EndToEndTest) +BOOST_AUTO_TEST_CASE(NeonSplitter2dDim1EndToEndTest) { - SplitterDim3EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim0EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(NeonSplitter2dDim0EndToEndUint8Test) { - SplitterDim0EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim1EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(NeonSplitter2dDim1EndToEndUint8Test) { - SplitterDim1EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim2EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(NeonSplitter3dDim0EndToEndTest) { - SplitterDim2EndToEnd(defaultBackends); + Splitter3dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(NeonSplitDim3EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(NeonSplitter3dDim1EndToEndTest) { - SplitterDim3EndToEnd(defaultBackends); + Splitter3dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter3dDim2EndToEndTest) +{ + Splitter3dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter3dDim0EndToEndUint8Test) +{ + Splitter3dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter3dDim1EndToEndUint8Test) +{ + Splitter3dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter3dDim2EndToEndUint8Test) +{ + Splitter3dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim0EndToEndTest) +{ + Splitter4dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim1EndToEndTest) +{ + Splitter4dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim2EndToEndTest) +{ + Splitter4dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim3EndToEndTest) +{ + Splitter4dDim3EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim0EndToEndUint8Test) +{ + Splitter4dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim1EndToEndUint8Test) +{ + Splitter4dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim2EndToEndUint8Test) +{ + Splitter4dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(NeonSplitter4dDim3EndToEndUint8Test) +{ + Splitter4dDim3EndToEnd(defaultBackends); } BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp index 2b7fb774b5..a0f10286d5 100644 --- a/src/backends/reference/test/RefEndToEndTests.cpp +++ b/src/backends/reference/test/RefEndToEndTests.cpp @@ -620,44 +620,104 @@ BOOST_AUTO_TEST_CASE(RefDetectionPostProcessFastNmsUint8Test) 1.0f, 1, 0.01f, 0, 0.5f, 0); } -BOOST_AUTO_TEST_CASE(RefSplitDim0EndToEndTest) +BOOST_AUTO_TEST_CASE(RefSplitter1dEndToEndTest) { - SplitterDim0EndToEnd(defaultBackends); + Splitter1dEndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(RefSplitDim1EndToEndTest) +BOOST_AUTO_TEST_CASE(RefSplitter1dEndToEndUint8Test) { - SplitterDim1EndToEnd(defaultBackends); + Splitter1dEndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(RefSplitDim2EndToEndTest) +BOOST_AUTO_TEST_CASE(RefSplitter2dDim0EndToEndTest) { - SplitterDim2EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(RefSplitDim3EndToEndTest) +BOOST_AUTO_TEST_CASE(RefSplitter2dDim1EndToEndTest) { - SplitterDim3EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(RefSplitDim0EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(RefSplitter2dDim0EndToEndUint8Test) { - SplitterDim0EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(RefSplitDim1EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(RefSplitter2dDim1EndToEndUint8Test) { - SplitterDim1EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(RefSplitDim2EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(RefSplitter3dDim0EndToEndTest) { - SplitterDim2EndToEnd(defaultBackends); + Splitter3dDim0EndToEnd(defaultBackends); } -BOOST_AUTO_TEST_CASE(RefSplitDim3EndToEndUint8Test) +BOOST_AUTO_TEST_CASE(RefSplitter3dDim1EndToEndTest) { - SplitterDim3EndToEnd(defaultBackends); + Splitter3dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter3dDim2EndToEndTest) +{ + Splitter3dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter3dDim0EndToEndUint8Test) +{ + Splitter3dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter3dDim1EndToEndUint8Test) +{ + Splitter3dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter3dDim2EndToEndUint8Test) +{ + Splitter3dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim0EndToEndTest) +{ + Splitter4dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim1EndToEndTest) +{ + Splitter4dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim2EndToEndTest) +{ + Splitter4dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim3EndToEndTest) +{ + Splitter4dDim3EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim0EndToEndUint8Test) +{ + Splitter4dDim0EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim1EndToEndUint8Test) +{ + Splitter4dDim1EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim2EndToEndUint8Test) +{ + Splitter4dDim2EndToEnd(defaultBackends); +} + +BOOST_AUTO_TEST_CASE(RefSplitter4dDim3EndToEndUint8Test) +{ + Splitter4dDim3EndToEnd(defaultBackends); } BOOST_AUTO_TEST_SUITE_END() -- cgit v1.2.1