diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp
index edee368..9e0137e 100644
--- a/src/backends/cl/test/ClEndToEndTests.cpp
+++ b/src/backends/cl/test/ClEndToEndTests.cpp
@@ -21,14 +21,14 @@
 #include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
 #include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
 
-BOOST_AUTO_TEST_SUITE(ClEndToEnd)
-
-std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::GpuAcc};
+TEST_SUITE("ClEndToEnd")
+{
+std::vector<armnn::BackendId> clDefaultBackends = {armnn::Compute::GpuAcc};
 
 // Abs
-BOOST_AUTO_TEST_CASE(ClAbsEndToEndTestFloat32)
+TEST_CASE("ClAbsEndToEndTestFloat32")
 {
     std::vector<float> expectedOutput =
     {
@@ -36,482 +36,482 @@
         3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
     };
 
-    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
+    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
                                                              UnaryOperation::Abs,
                                                              expectedOutput);
 }
 
 // Constant
-BOOST_AUTO_TEST_CASE(ConstantUsage_Cl_Float32)
+TEST_CASE("ConstantUsage_Cl_Float32")
 {
-    ConstantUsageFloat32Test(defaultBackends);
+    ConstantUsageFloat32Test(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Test)
+TEST_CASE("ClConcatEndToEndDim0Test")
 {
-    ConcatDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ConcatDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Uint8Test)
+TEST_CASE("ClConcatEndToEndDim0Uint8Test")
 {
-    ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Test)
+TEST_CASE("ClConcatEndToEndDim1Test")
 {
-    ConcatDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ConcatDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Uint8Test)
+TEST_CASE("ClConcatEndToEndDim1Uint8Test")
 {
-    ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Test)
+TEST_CASE("ClConcatEndToEndDim3Test")
 {
-    ConcatDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ConcatDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Uint8Test)
+TEST_CASE("ClConcatEndToEndDim3Uint8Test")
 {
-    ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
 // DepthToSpace
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32)
+TEST_CASE("DephtToSpaceEndToEndNchwFloat32")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NCHW);
 }
 
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16)
+TEST_CASE("DephtToSpaceEndToEndNchwFloat16")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NCHW);
 }
 
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8)
+TEST_CASE("DephtToSpaceEndToEndNchwUint8")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
+    DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NCHW);
 }
 
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16)
+TEST_CASE("DephtToSpaceEndToEndNchwInt16")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
+    DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NCHW);
 }
 
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32)
+TEST_CASE("DephtToSpaceEndToEndNhwcFloat32")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+    DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC);
 }
 
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16)
+TEST_CASE("DephtToSpaceEndToEndNhwcFloat16")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
+    DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NHWC);
 }
 
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8)
+TEST_CASE("DephtToSpaceEndToEndNhwcUint8")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
+    DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NHWC);
 }
 
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16)
+TEST_CASE("DephtToSpaceEndToEndNhwcInt16")
 {
-    DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
+    DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NHWC);
 }
 
 // Dequantize
-BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
+TEST_CASE("DequantizeEndToEndSimpleTest")
 {
-    DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
+    DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetTest)
+TEST_CASE("DequantizeEndToEndOffsetTest")
 {
-    DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(defaultBackends);
+    DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClStridedSliceInvalidSliceEndToEndTest)
+TEST_CASE("ClStridedSliceInvalidSliceEndToEndTest")
 {
-    StridedSliceInvalidSliceEndToEndTest(defaultBackends);
+    StridedSliceInvalidSliceEndToEndTest(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat32)
+TEST_CASE("ClEluEndToEndTestFloat32")
 {
-    EluEndToEndTest<armnn::DataType::Float32>(defaultBackends);
+    EluEndToEndTest<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat16)
+TEST_CASE("ClEluEndToEndTestFloat16")
 {
-    EluEndToEndTest<armnn::DataType::Float16>(defaultBackends);
+    EluEndToEndTest<armnn::DataType::Float16>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndTest)
+TEST_CASE("ClGreaterSimpleEndToEndTest")
 {
     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 
-    ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
+    ComparisonSimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
                                                        ComparisonOperation::Greater,
                                                        expectedOutput);
 }
 
-BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndUint8Test)
+TEST_CASE("ClGreaterSimpleEndToEndUint8Test")
 {
     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 
-    ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
+    ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
                                                                ComparisonOperation::Greater,
                                                                expectedOutput);
 }
 
-BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndTest)
+TEST_CASE("ClGreaterBroadcastEndToEndTest")
 {
     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
                                                 1, 1, 1, 1, 1, 1 });
 
-    ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends,
+    ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
                                                           ComparisonOperation::Greater,
                                                           expectedOutput);
 }
 
-BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndUint8Test)
+TEST_CASE("ClGreaterBroadcastEndToEndUint8Test")
 {
     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
                                                 1, 1, 1, 1, 1, 1 });
 
-    ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
+    ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
                                                                   ComparisonOperation::Greater,
                                                                   expectedOutput);
 }
 
 // HardSwish
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat32)
+TEST_CASE("ClHardSwishEndToEndTestFloat32")
 {
-    HardSwishEndToEndTest<armnn::DataType::Float32>(defaultBackends);
+    HardSwishEndToEndTest<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat16)
+TEST_CASE("ClHardSwishEndToEndTestFloat16")
 {
-    HardSwishEndToEndTest<armnn::DataType::Float16>(defaultBackends);
+    HardSwishEndToEndTest<armnn::DataType::Float16>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmS8)
+TEST_CASE("ClHardSwishEndToEndTestQAsymmS8")
 {
-    HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(defaultBackends);
+    HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmU8)
+TEST_CASE("ClHardSwishEndToEndTestQAsymmU8")
 {
-    HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(defaultBackends);
+    HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQSymmS16)
+TEST_CASE("ClHardSwishEndToEndTestQSymmS16")
 {
-    HardSwishEndToEndTest<armnn::DataType::QSymmS16>(defaultBackends);
+    HardSwishEndToEndTest<armnn::DataType::QSymmS16>(clDefaultBackends);
 }
 
 // InstanceNormalization
-BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest1)
+TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest1")
 {
-    InstanceNormalizationNhwcEndToEndTest1(defaultBackends);
+    InstanceNormalizationNhwcEndToEndTest1(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest1)
+TEST_CASE("ClInstanceNormalizationNchwEndToEndTest1")
 {
-    InstanceNormalizationNchwEndToEndTest1(defaultBackends);
+    InstanceNormalizationNchwEndToEndTest1(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest2)
+TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest2")
 {
-    InstanceNormalizationNhwcEndToEndTest2(defaultBackends);
+    InstanceNormalizationNhwcEndToEndTest2(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest2)
+TEST_CASE("ClInstanceNormalizationNchwEndToEndTest2")
 {
-    InstanceNormalizationNchwEndToEndTest2(defaultBackends);
+    InstanceNormalizationNchwEndToEndTest2(clDefaultBackends);
 }
 
 // Fill
-BOOST_AUTO_TEST_CASE(ClFillEndToEndTest)
+TEST_CASE("ClFillEndToEndTest")
 {
-    FillEndToEnd<armnn::DataType::Float32>(defaultBackends);
+    FillEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(RefFillEndToEndTestFloat16)
+TEST_CASE("RefFillEndToEndTestFloat16")
 {
-    FillEndToEnd<armnn::DataType::Float16>(defaultBackends);
+    FillEndToEnd<armnn::DataType::Float16>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClFillEndToEndTestInt32)
+TEST_CASE("ClFillEndToEndTestInt32")
 {
-    FillEndToEnd<armnn::DataType::Signed32>(defaultBackends);
+    FillEndToEnd<armnn::DataType::Signed32>(clDefaultBackends);
 }
 
 // Prelu
-BOOST_AUTO_TEST_CASE(ClPreluEndToEndFloat32Test)
+TEST_CASE("ClPreluEndToEndFloat32Test")
 {
-    PreluEndToEndNegativeTest<armnn::DataType::Float32>(defaultBackends);
+    PreluEndToEndNegativeTest<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClPreluEndToEndTestUint8)
+TEST_CASE("ClPreluEndToEndTestUint8")
 {
-    PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(defaultBackends);
+    PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest1)
+TEST_CASE("ClSpaceToDepthNhwcEndToEndTest1")
 {
-    SpaceToDepthNhwcEndToEndTest1(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest1(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest1)
+TEST_CASE("ClSpaceToDepthNchwEndToEndTest1")
 {
-    SpaceToDepthNchwEndToEndTest1(defaultBackends);
+    SpaceToDepthNchwEndToEndTest1(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest2)
+TEST_CASE("ClSpaceToDepthNhwcEndToEndTest2")
 {
-    SpaceToDepthNhwcEndToEndTest2(defaultBackends);
+    SpaceToDepthNhwcEndToEndTest2(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest2)
+TEST_CASE("ClSpaceToDepthNchwEndToEndTest2")
 {
-    SpaceToDepthNchwEndToEndTest2(defaultBackends);
+    SpaceToDepthNchwEndToEndTest2(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndTest)
+TEST_CASE("ClSplitter1dEndToEndTest")
 {
-    Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndUint8Test)
+TEST_CASE("ClSplitter1dEndToEndUint8Test")
 {
-    Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndTest)
+TEST_CASE("ClSplitter2dDim0EndToEndTest")
 {
-    Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndTest)
+TEST_CASE("ClSplitter2dDim1EndToEndTest")
 {
-    Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndUint8Test)
+TEST_CASE("ClSplitter2dDim0EndToEndUint8Test")
 {
-    Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndUint8Test)
+TEST_CASE("ClSplitter2dDim1EndToEndUint8Test")
 {
-    Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndTest)
+TEST_CASE("ClSplitter3dDim0EndToEndTest")
 {
-    Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter3dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndTest)
+TEST_CASE("ClSplitter3dDim1EndToEndTest")
 {
-    Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter3dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndTest)
+TEST_CASE("ClSplitter3dDim2EndToEndTest")
 {
-    Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter3dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndUint8Test)
+TEST_CASE("ClSplitter3dDim0EndToEndUint8Test")
 {
-    Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndUint8Test)
+TEST_CASE("ClSplitter3dDim1EndToEndUint8Test")
 {
-    Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndUint8Test)
+TEST_CASE("ClSplitter3dDim2EndToEndUint8Test")
 {
-    Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndTest)
+TEST_CASE("ClSplitter4dDim0EndToEndTest")
 {
-    Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter4dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndTest)
+TEST_CASE("ClSplitter4dDim1EndToEndTest")
 {
-    Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter4dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndTest)
+TEST_CASE("ClSplitter4dDim2EndToEndTest")
 {
-    Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter4dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndTest)
+TEST_CASE("ClSplitter4dDim3EndToEndTest")
 {
-    Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    Splitter4dDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim0EndToEndUint8Test")
 {
-    Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim1EndToEndUint8Test")
 {
-    Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim2EndToEndUint8Test")
 {
-    Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim3EndToEndUint8Test")
 {
-    Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
 // TransposeConvolution2d
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNchwTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndFloatNchwTest")
 {
     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
-        defaultBackends, armnn::DataLayout::NCHW);
+        clDefaultBackends, armnn::DataLayout::NCHW);
 }
 
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NchwTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndUint8NchwTest")
 {
     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
-        defaultBackends, armnn::DataLayout::NCHW);
+        clDefaultBackends, armnn::DataLayout::NCHW);
 }
 
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNhwcTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndFloatNhwcTest")
 {
     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
-        defaultBackends, armnn::DataLayout::NHWC);
+        clDefaultBackends, armnn::DataLayout::NHWC);
 }
 
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NhwcTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndUint8NhwcTest")
 {
     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
-        defaultBackends, armnn::DataLayout::NHWC);
+        clDefaultBackends, armnn::DataLayout::NHWC);
 }
 
-BOOST_AUTO_TEST_CASE(ClQuantizedLstmEndToEndTest)
+TEST_CASE("ClQuantizedLstmEndToEndTest")
 {
-    QuantizedLstmEndToEnd(defaultBackends);
+    QuantizedLstmEndToEnd(clDefaultBackends);
 }
 
 // ArgMinMax
-BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTest)
+TEST_CASE("ClArgMaxSimpleTest")
 {
-    ArgMaxEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
+    ArgMaxEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinSimpleTest)
+TEST_CASE("ClArgMinSimpleTest")
 {
-    ArgMinEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
+    ArgMinEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis0Test)
+TEST_CASE("ClArgMaxAxis0Test")
 {
-    ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis0Test)
+TEST_CASE("ClArgMinAxis0Test")
 {
-    ArgMinAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMinAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis1Test)
+TEST_CASE("ClArgMaxAxis1Test")
 {
-    ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis1Test)
+TEST_CASE("ClArgMinAxis1Test")
 {
-    ArgMinAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMinAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis2Test)
+TEST_CASE("ClArgMaxAxis2Test")
 {
-    ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis2Test)
+TEST_CASE("ClArgMinAxis2Test")
 {
-    ArgMinAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMinAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis3Test)
+TEST_CASE("ClArgMaxAxis3Test")
 {
-    ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis3Test)
+TEST_CASE("ClArgMinAxis3Test")
 {
-    ArgMinAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+    ArgMinAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTestQAsymmU8)
+TEST_CASE("ClArgMaxSimpleTestQAsymmU8")
 {
-    ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinSimpleTestQAsymmU8)
+TEST_CASE("ClArgMinSimpleTestQAsymmU8")
 {
-    ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis0TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis0TestQAsymmU8")
 {
-    ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis0TestQAsymmU8)
+TEST_CASE("ClArgMinAxis0TestQAsymmU8")
 {
-    ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis1TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis1TestQAsymmU8")
 {
-    ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis1TestQAsymmU8)
+TEST_CASE("ClArgMinAxis1TestQAsymmU8")
 {
-    ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis2TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis2TestQAsymmU8")
 {
-    ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis2TestQAsymmU8)
+TEST_CASE("ClArgMinAxis2TestQAsymmU8")
 {
-    ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis3TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis3TestQAsymmU8")
 {
-    ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClArgMinAxis3TestQAsymmU8)
+TEST_CASE("ClArgMinAxis3TestQAsymmU8")
 {
-    ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+    ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_CASE(ClQLstmEndToEndTest)
+TEST_CASE("ClQLstmEndToEndTest")
 {
-    QLstmEndToEnd(defaultBackends);
+    QLstmEndToEnd(clDefaultBackends);
 }
 
-BOOST_AUTO_TEST_SUITE_END()
+}