IVGCVSW-5963 'Move unit tests to new framework'

* Used doctest in ArmNN unit tests

Signed-off-by: Sadik Armagan <sadik.armagan@arm.com>
Change-Id: Ia9cf5fc72775878885c5f864abf2c56b3a935f1a

1 files changed, 955 insertions, 953 deletions

diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp
index a4a25a84ad..e0629b3913 100644
--- a/src/profiling/test/ProfilingTests.cpp
+++ b/src/profiling/test/ProfilingTests.cpp
@@ -40,6 +40,8 @@
 #include <common/include/SocketConnectionException.hpp>
 #include <common/include/Packet.hpp>
 
+#include <doctest/doctest.h>
+
 #include <cstdint>
 #include <cstring>
 #include <iostream>
@@ -51,9 +53,9 @@
 using namespace armnn::profiling;
 using PacketType = MockProfilingConnection::PacketType;
 
-BOOST_AUTO_TEST_SUITE(ExternalProfiling)
-
-BOOST_AUTO_TEST_CASE(CheckCommandHandlerKeyComparisons)
+TEST_SUITE("ExternalProfiling")
+{
+TEST_CASE("CheckCommandHandlerKeyComparisons")
 {
     arm::pipe::CommandHandlerKey testKey1_0(1, 1, 1);
     arm::pipe::CommandHandlerKey testKey1_1(1, 1, 1);
@@ -66,28 +68,28 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandlerKeyComparisons)
     arm::pipe::CommandHandlerKey testKey4(0, 2, 2);
     arm::pipe::CommandHandlerKey testKey5(0, 0, 2);
 
-    BOOST_CHECK(testKey1_0 > testKey0);
-    BOOST_CHECK(testKey1_0 == testKey1_1);
-    BOOST_CHECK(testKey1_0 < testKey1_2);
+    CHECK(testKey1_0 > testKey0);
+    CHECK(testKey1_0 == testKey1_1);
+    CHECK(testKey1_0 < testKey1_2);
 
-    BOOST_CHECK(testKey1 < testKey4);
-    BOOST_CHECK(testKey1 > testKey3);
-    BOOST_CHECK(testKey1 <= testKey4);
-    BOOST_CHECK(testKey1 >= testKey3);
-    BOOST_CHECK(testKey1 <= testKey2);
-    BOOST_CHECK(testKey1 >= testKey2);
-    BOOST_CHECK(testKey1 == testKey2);
-    BOOST_CHECK(testKey1 == testKey1);
+    CHECK(testKey1 < testKey4);
+    CHECK(testKey1 > testKey3);
+    CHECK(testKey1 <= testKey4);
+    CHECK(testKey1 >= testKey3);
+    CHECK(testKey1 <= testKey2);
+    CHECK(testKey1 >= testKey2);
+    CHECK(testKey1 == testKey2);
+    CHECK(testKey1 == testKey1);
 
-    BOOST_CHECK(!(testKey1 == testKey5));
-    BOOST_CHECK(!(testKey1 != testKey1));
-    BOOST_CHECK(testKey1 != testKey5);
+    CHECK(!(testKey1 == testKey5));
+    CHECK(!(testKey1 != testKey1));
+    CHECK(testKey1 != testKey5);
 
-    BOOST_CHECK(testKey1 == testKey2 && testKey2 == testKey1);
-    BOOST_CHECK(testKey0 == testKey1 && testKey1 == testKey2 && testKey0 == testKey2);
+    CHECK((testKey1 == testKey2 && testKey2 == testKey1));
+    CHECK((testKey0 == testKey1 && testKey1 == testKey2 && testKey0 == testKey2));
 
-    BOOST_CHECK(testKey1.GetPacketId() == 1);
-    BOOST_CHECK(testKey1.GetVersion() == 1);
+    CHECK(testKey1.GetPacketId() == 1);
+    CHECK(testKey1.GetVersion() == 1);
 
     std::vector<arm::pipe::CommandHandlerKey> vect = {
         arm::pipe::CommandHandlerKey(0, 0, 1), arm::pipe::CommandHandlerKey(0, 2, 0),
@@ -103,10 +105,10 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandlerKeyComparisons)
         arm::pipe::CommandHandlerKey(0, 1, 1), arm::pipe::CommandHandlerKey(0, 2, 0),
         arm::pipe::CommandHandlerKey(0, 2, 0), arm::pipe::CommandHandlerKey(0, 2, 1) };
 
-    BOOST_CHECK(vect == expectedVect);
+    CHECK(vect == expectedVect);
 }
 
-BOOST_AUTO_TEST_CASE(CheckPacketKeyComparisons)
+TEST_CASE("CheckPacketKeyComparisons")
 {
     arm::pipe::PacketKey key0(0, 0);
     arm::pipe::PacketKey key1(0, 0);
@@ -116,22 +118,22 @@ BOOST_AUTO_TEST_CASE(CheckPacketKeyComparisons)
     arm::pipe::PacketKey key5(1, 0);
     arm::pipe::PacketKey key6(1, 1);
 
-    BOOST_CHECK(!(key0 < key1));
-    BOOST_CHECK(!(key0 > key1));
-    BOOST_CHECK(key0 <= key1);
-    BOOST_CHECK(key0 >= key1);
-    BOOST_CHECK(key0 == key1);
-    BOOST_CHECK(key0 < key2);
-    BOOST_CHECK(key2 < key3);
-    BOOST_CHECK(key3 > key0);
-    BOOST_CHECK(key4 == key5);
-    BOOST_CHECK(key4 > key0);
-    BOOST_CHECK(key5 < key6);
-    BOOST_CHECK(key5 <= key6);
-    BOOST_CHECK(key5 != key6);
+    CHECK(!(key0 < key1));
+    CHECK(!(key0 > key1));
+    CHECK(key0 <= key1);
+    CHECK(key0 >= key1);
+    CHECK(key0 == key1);
+    CHECK(key0 < key2);
+    CHECK(key2 < key3);
+    CHECK(key3 > key0);
+    CHECK(key4 == key5);
+    CHECK(key4 > key0);
+    CHECK(key5 < key6);
+    CHECK(key5 <= key6);
+    CHECK(key5 != key6);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCommandHandler)
+TEST_CASE("CheckCommandHandler")
 {
     arm::pipe::PacketVersionResolver packetVersionResolver;
     ProfilingStateMachine profilingStateMachine;
@@ -175,7 +177,7 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandler)
         std::this_thread::sleep_for(std::chrono::milliseconds(2));
     }
 
-    BOOST_CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::Active);
 
     // Close the thread again.
     commandHandler0.Stop();
@@ -206,7 +208,7 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandler)
     {
         if (timeSlept >= timeout)
         {
-            BOOST_FAIL("Timeout: The command handler loop did not stop after the timeout");
+            FAIL("Timeout: The command handler loop did not stop after the timeout");
         }
         std::this_thread::sleep_for(std::chrono::milliseconds(1));
         timeSlept ++;
@@ -214,14 +216,14 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandler)
 
     commandHandler1.Stop();
     // The state machine should never have received the ack so will still be in WaitingForAck.
-    BOOST_CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck);
 
     // Now try sending a bad connection acknowledged packet
     TestProfilingConnectionBadAckPacket testProfilingConnectionBadAckPacket;
     commandHandler1.Start(testProfilingConnectionBadAckPacket);
     commandHandler1.Stop();
     // This should also not change the state machine
-    BOOST_CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck);
 
     // Disable stop after timeout and now commandHandler1 should persist after a timeout
     commandHandler1.SetStopAfterTimeout(false);
@@ -240,7 +242,7 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandler)
     commandHandler1.Stop();
 
     // Even after the 3 exceptions the ack packet should have transitioned the command handler to active.
-    BOOST_CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::Active);
 
     // A command handler that gets exceptions other than timeouts should keep going.
     CommandHandler commandHandler2(1, false, commandHandlerRegistry, packetVersionResolver);
@@ -257,41 +259,41 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandler)
         std::this_thread::sleep_for(std::chrono::milliseconds(2));
     }
 
-    BOOST_CHECK(commandHandler2.IsRunning());
+    CHECK(commandHandler2.IsRunning());
     commandHandler2.Stop();
 }
 
-BOOST_AUTO_TEST_CASE(CheckEncodeVersion)
+TEST_CASE("CheckEncodeVersion")
 {
     arm::pipe::Version version1(12);
 
-    BOOST_CHECK(version1.GetMajor() == 0);
-    BOOST_CHECK(version1.GetMinor() == 0);
-    BOOST_CHECK(version1.GetPatch() == 12);
+    CHECK(version1.GetMajor() == 0);
+    CHECK(version1.GetMinor() == 0);
+    CHECK(version1.GetPatch() == 12);
 
     arm::pipe::Version version2(4108);
 
-    BOOST_CHECK(version2.GetMajor() == 0);
-    BOOST_CHECK(version2.GetMinor() == 1);
-    BOOST_CHECK(version2.GetPatch() == 12);
+    CHECK(version2.GetMajor() == 0);
+    CHECK(version2.GetMinor() == 1);
+    CHECK(version2.GetPatch() == 12);
 
     arm::pipe::Version version3(4198412);
 
-    BOOST_CHECK(version3.GetMajor() == 1);
-    BOOST_CHECK(version3.GetMinor() == 1);
-    BOOST_CHECK(version3.GetPatch() == 12);
+    CHECK(version3.GetMajor() == 1);
+    CHECK(version3.GetMinor() == 1);
+    CHECK(version3.GetPatch() == 12);
 
     arm::pipe::Version version4(0);
 
-    BOOST_CHECK(version4.GetMajor() == 0);
-    BOOST_CHECK(version4.GetMinor() == 0);
-    BOOST_CHECK(version4.GetPatch() == 0);
+    CHECK(version4.GetMajor() == 0);
+    CHECK(version4.GetMinor() == 0);
+    CHECK(version4.GetPatch() == 0);
 
     arm::pipe::Version version5(1, 0, 0);
-    BOOST_CHECK(version5.GetEncodedValue() == 4194304);
+    CHECK(version5.GetEncodedValue() == 4194304);
 }
 
-BOOST_AUTO_TEST_CASE(CheckPacketClass)
+TEST_CASE("CheckPacketClass")
 {
     uint32_t length                              = 4;
     std::unique_ptr<unsigned char[]> packetData0 = std::make_unique<unsigned char[]>(length);
@@ -300,35 +302,35 @@ BOOST_AUTO_TEST_CASE(CheckPacketClass)
 
     arm::pipe::Packet packetTest0(472580096, length, packetData0);
 
-    BOOST_CHECK(packetTest0.GetHeader() == 472580096);
-    BOOST_CHECK(packetTest0.GetPacketFamily() == 7);
-    BOOST_CHECK(packetTest0.GetPacketId() == 43);
-    BOOST_CHECK(packetTest0.GetLength() == length);
-    BOOST_CHECK(packetTest0.GetPacketType() == 3);
-    BOOST_CHECK(packetTest0.GetPacketClass() == 5);
+    CHECK(packetTest0.GetHeader() == 472580096);
+    CHECK(packetTest0.GetPacketFamily() == 7);
+    CHECK(packetTest0.GetPacketId() == 43);
+    CHECK(packetTest0.GetLength() == length);
+    CHECK(packetTest0.GetPacketType() == 3);
+    CHECK(packetTest0.GetPacketClass() == 5);
 
-    BOOST_CHECK_THROW(arm::pipe::Packet packetTest1(472580096, 0, packetData1), arm::pipe::InvalidArgumentException);
-    BOOST_CHECK_NO_THROW(arm::pipe::Packet packetTest2(472580096, 0, nullPacketData));
+    CHECK_THROWS_AS(arm::pipe::Packet packetTest1(472580096, 0, packetData1), arm::pipe::InvalidArgumentException);
+    CHECK_NOTHROW(arm::pipe::Packet packetTest2(472580096, 0, nullPacketData));
 
     arm::pipe::Packet packetTest3(472580096, 0, nullPacketData);
-    BOOST_CHECK(packetTest3.GetLength() == 0);
-    BOOST_CHECK(packetTest3.GetData() == nullptr);
+    CHECK(packetTest3.GetLength() == 0);
+    CHECK(packetTest3.GetData() == nullptr);
 
     const unsigned char* packetTest0Data = packetTest0.GetData();
     arm::pipe::Packet packetTest4(std::move(packetTest0));
 
-    BOOST_CHECK(packetTest0.GetData() == nullptr);
-    BOOST_CHECK(packetTest4.GetData() == packetTest0Data);
+    CHECK(packetTest0.GetData() == nullptr);
+    CHECK(packetTest4.GetData() == packetTest0Data);
 
-    BOOST_CHECK(packetTest4.GetHeader() == 472580096);
-    BOOST_CHECK(packetTest4.GetPacketFamily() == 7);
-    BOOST_CHECK(packetTest4.GetPacketId() == 43);
-    BOOST_CHECK(packetTest4.GetLength() == length);
-    BOOST_CHECK(packetTest4.GetPacketType() == 3);
-    BOOST_CHECK(packetTest4.GetPacketClass() == 5);
+    CHECK(packetTest4.GetHeader() == 472580096);
+    CHECK(packetTest4.GetPacketFamily() == 7);
+    CHECK(packetTest4.GetPacketId() == 43);
+    CHECK(packetTest4.GetLength() == length);
+    CHECK(packetTest4.GetPacketType() == 3);
+    CHECK(packetTest4.GetPacketClass() == 5);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCommandHandlerFunctor)
+TEST_CASE("CheckCommandHandlerFunctor")
 {
     // Hard code the version as it will be the same during a single profiling session
     uint32_t version = 1;
@@ -353,11 +355,11 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandlerFunctor)
 
     // Check the order of the map is correct
     auto it = registry.begin();
-    BOOST_CHECK(it->first == keyC);    // familyId == 5
+    CHECK(it->first == keyC);    // familyId == 5
     it++;
-    BOOST_CHECK(it->first == keyA);    // familyId == 7
+    CHECK(it->first == keyA);    // familyId == 7
     it++;
-    BOOST_CHECK(it->first == keyB);    // familyId == 8
+    CHECK(it->first == keyB);    // familyId == 8
 
     std::unique_ptr<unsigned char[]> packetDataA;
     std::unique_ptr<unsigned char[]> packetDataB;
@@ -370,24 +372,24 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandlerFunctor)
     // Check the correct operator of derived class is called
     registry.at(arm::pipe::CommandHandlerKey(
         packetA.GetPacketFamily(), packetA.GetPacketId(), version))->operator()(packetA);
-    BOOST_CHECK(testFunctorA.GetCount() == 1);
-    BOOST_CHECK(testFunctorB.GetCount() == 0);
-    BOOST_CHECK(testFunctorC.GetCount() == 0);
+    CHECK(testFunctorA.GetCount() == 1);
+    CHECK(testFunctorB.GetCount() == 0);
+    CHECK(testFunctorC.GetCount() == 0);
 
     registry.at(arm::pipe::CommandHandlerKey(
         packetB.GetPacketFamily(), packetB.GetPacketId(), version))->operator()(packetB);
-    BOOST_CHECK(testFunctorA.GetCount() == 1);
-    BOOST_CHECK(testFunctorB.GetCount() == 1);
-    BOOST_CHECK(testFunctorC.GetCount() == 0);
+    CHECK(testFunctorA.GetCount() == 1);
+    CHECK(testFunctorB.GetCount() == 1);
+    CHECK(testFunctorC.GetCount() == 0);
 
     registry.at(arm::pipe::CommandHandlerKey(
         packetC.GetPacketFamily(), packetC.GetPacketId(), version))->operator()(packetC);
-    BOOST_CHECK(testFunctorA.GetCount() == 1);
-    BOOST_CHECK(testFunctorB.GetCount() == 1);
-    BOOST_CHECK(testFunctorC.GetCount() == 1);
+    CHECK(testFunctorA.GetCount() == 1);
+    CHECK(testFunctorB.GetCount() == 1);
+    CHECK(testFunctorC.GetCount() == 1);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCommandHandlerRegistry)
+TEST_CASE("CheckCommandHandlerRegistry")
 {
     // Hard code the version as it will be the same during a single profiling session
     uint32_t version = 1;
@@ -414,32 +416,32 @@ BOOST_AUTO_TEST_CASE(CheckCommandHandlerRegistry)
 
     // Check the correct operator of derived class is called
     registry.GetFunctor(packetA.GetPacketFamily(), packetA.GetPacketId(), version)->operator()(packetA);
-    BOOST_CHECK(testFunctorA.GetCount() == 1);
-    BOOST_CHECK(testFunctorB.GetCount() == 0);
-    BOOST_CHECK(testFunctorC.GetCount() == 0);
+    CHECK(testFunctorA.GetCount() == 1);
+    CHECK(testFunctorB.GetCount() == 0);
+    CHECK(testFunctorC.GetCount() == 0);
 
     registry.GetFunctor(packetB.GetPacketFamily(), packetB.GetPacketId(), version)->operator()(packetB);
-    BOOST_CHECK(testFunctorA.GetCount() == 1);
-    BOOST_CHECK(testFunctorB.GetCount() == 1);
-    BOOST_CHECK(testFunctorC.GetCount() == 0);
+    CHECK(testFunctorA.GetCount() == 1);
+    CHECK(testFunctorB.GetCount() == 1);
+    CHECK(testFunctorC.GetCount() == 0);
 
     registry.GetFunctor(packetC.GetPacketFamily(), packetC.GetPacketId(), version)->operator()(packetC);
-    BOOST_CHECK(testFunctorA.GetCount() == 1);
-    BOOST_CHECK(testFunctorB.GetCount() == 1);
-    BOOST_CHECK(testFunctorC.GetCount() == 1);
+    CHECK(testFunctorA.GetCount() == 1);
+    CHECK(testFunctorB.GetCount() == 1);
+    CHECK(testFunctorC.GetCount() == 1);
 
     // Re-register an existing key with a new function
     registry.RegisterFunctor(&testFunctorC, testFunctorA.GetFamilyId(), testFunctorA.GetPacketId(), version);
     registry.GetFunctor(packetA.GetPacketFamily(), packetA.GetPacketId(), version)->operator()(packetC);
-    BOOST_CHECK(testFunctorA.GetCount() == 1);
-    BOOST_CHECK(testFunctorB.GetCount() == 1);
-    BOOST_CHECK(testFunctorC.GetCount() == 2);
+    CHECK(testFunctorA.GetCount() == 1);
+    CHECK(testFunctorB.GetCount() == 1);
+    CHECK(testFunctorC.GetCount() == 2);
 
     // Check that non-existent key returns nullptr for its functor
-    BOOST_CHECK_THROW(registry.GetFunctor(0, 0, 0), arm::pipe::ProfilingException);
+    CHECK_THROWS_AS(registry.GetFunctor(0, 0, 0), arm::pipe::ProfilingException);
 }
 
-BOOST_AUTO_TEST_CASE(CheckPacketVersionResolver)
+TEST_CASE("CheckPacketVersionResolver")
 {
     // Set up random number generator for generating packetId values
     std::random_device device;
@@ -460,7 +462,7 @@ BOOST_AUTO_TEST_CASE(CheckPacketVersionResolver)
         const uint32_t packetId = distribution(generator);
         arm::pipe::Version resolvedVersion = packetVersionResolver.ResolvePacketVersion(familyId, packetId);
 
-        BOOST_TEST(resolvedVersion == expectedVersion);
+        CHECK(resolvedVersion == expectedVersion);
     }
 }
 
@@ -471,64 +473,64 @@ void ProfilingCurrentStateThreadImpl(ProfilingStateMachine& states)
     states.TransitionToState(newState);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingStateMachine)
+TEST_CASE("CheckProfilingStateMachine")
 {
     ProfilingStateMachine profilingState1(ProfilingState::Uninitialised);
     profilingState1.TransitionToState(ProfilingState::Uninitialised);
-    BOOST_CHECK(profilingState1.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingState1.GetCurrentState() == ProfilingState::Uninitialised);
 
     ProfilingStateMachine profilingState2(ProfilingState::Uninitialised);
     profilingState2.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK(profilingState2.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingState2.GetCurrentState() == ProfilingState::NotConnected);
 
     ProfilingStateMachine profilingState3(ProfilingState::NotConnected);
     profilingState3.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK(profilingState3.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingState3.GetCurrentState() == ProfilingState::NotConnected);
 
     ProfilingStateMachine profilingState4(ProfilingState::NotConnected);
     profilingState4.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK(profilingState4.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingState4.GetCurrentState() == ProfilingState::WaitingForAck);
 
     ProfilingStateMachine profilingState5(ProfilingState::WaitingForAck);
     profilingState5.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK(profilingState5.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingState5.GetCurrentState() == ProfilingState::WaitingForAck);
 
     ProfilingStateMachine profilingState6(ProfilingState::WaitingForAck);
     profilingState6.TransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingState6.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingState6.GetCurrentState() == ProfilingState::Active);
 
     ProfilingStateMachine profilingState7(ProfilingState::Active);
     profilingState7.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK(profilingState7.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingState7.GetCurrentState() == ProfilingState::NotConnected);
 
     ProfilingStateMachine profilingState8(ProfilingState::Active);
     profilingState8.TransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingState8.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingState8.GetCurrentState() == ProfilingState::Active);
 
     ProfilingStateMachine profilingState9(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(profilingState9.TransitionToState(ProfilingState::WaitingForAck), armnn::Exception);
+    CHECK_THROWS_AS(profilingState9.TransitionToState(ProfilingState::WaitingForAck), armnn::Exception);
 
     ProfilingStateMachine profilingState10(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(profilingState10.TransitionToState(ProfilingState::Active), armnn::Exception);
+    CHECK_THROWS_AS(profilingState10.TransitionToState(ProfilingState::Active), armnn::Exception);
 
     ProfilingStateMachine profilingState11(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(profilingState11.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
+    CHECK_THROWS_AS(profilingState11.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
 
     ProfilingStateMachine profilingState12(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(profilingState12.TransitionToState(ProfilingState::Active), armnn::Exception);
+    CHECK_THROWS_AS(profilingState12.TransitionToState(ProfilingState::Active), armnn::Exception);
 
     ProfilingStateMachine profilingState13(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(profilingState13.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
+    CHECK_THROWS_AS(profilingState13.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
 
     ProfilingStateMachine profilingState14(ProfilingState::WaitingForAck);
     profilingState14.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK(profilingState14.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingState14.GetCurrentState() == ProfilingState::NotConnected);
 
     ProfilingStateMachine profilingState15(ProfilingState::Active);
-    BOOST_CHECK_THROW(profilingState15.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
+    CHECK_THROWS_AS(profilingState15.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
 
     ProfilingStateMachine profilingState16(armnn::profiling::ProfilingState::Active);
-    BOOST_CHECK_THROW(profilingState16.TransitionToState(ProfilingState::WaitingForAck), armnn::Exception);
+    CHECK_THROWS_AS(profilingState16.TransitionToState(ProfilingState::WaitingForAck), armnn::Exception);
 
     ProfilingStateMachine profilingState17(ProfilingState::Uninitialised);
 
@@ -544,7 +546,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingStateMachine)
     thread4.join();
     thread5.join();
 
-    BOOST_TEST((profilingState17.GetCurrentState() == ProfilingState::NotConnected));
+    CHECK((profilingState17.GetCurrentState() == ProfilingState::NotConnected));
 }
 
 void CaptureDataWriteThreadImpl(Holder& holder, uint32_t capturePeriod, const std::vector<uint16_t>& counterIds)
@@ -557,7 +559,7 @@ void CaptureDataReadThreadImpl(const Holder& holder, CaptureData& captureData)
     captureData = holder.GetCaptureData();
 }
 
-BOOST_AUTO_TEST_CASE(CheckCaptureDataHolder)
+TEST_CASE("CheckCaptureDataHolder")
 {
     std::map<uint32_t, std::vector<uint16_t>> periodIdMap;
     std::vector<uint16_t> counterIds;
@@ -571,14 +573,14 @@ BOOST_AUTO_TEST_CASE(CheckCaptureDataHolder)
     // Verify the read and write threads set the holder correctly
     // and retrieve the expected values
     Holder holder;
-    BOOST_CHECK((holder.GetCaptureData()).GetCapturePeriod() == 0);
-    BOOST_CHECK(((holder.GetCaptureData()).GetCounterIds()).empty());
+    CHECK((holder.GetCaptureData()).GetCapturePeriod() == 0);
+    CHECK(((holder.GetCaptureData()).GetCounterIds()).empty());
 
     // Check Holder functions
     std::thread thread1(CaptureDataWriteThreadImpl, std::ref(holder), 2, std::ref(periodIdMap[2]));
     thread1.join();
-    BOOST_CHECK((holder.GetCaptureData()).GetCapturePeriod() == 2);
-    BOOST_CHECK((holder.GetCaptureData()).GetCounterIds() == periodIdMap[2]);
+    CHECK((holder.GetCaptureData()).GetCapturePeriod() == 2);
+    CHECK((holder.GetCaptureData()).GetCounterIds() == periodIdMap[2]);
     // NOTE: now that we have some initial values in the holder we don't have to worry
     //       in the multi-threaded section below about a read thread accessing the holder
     //       before any write thread has gotten to it so we read period = 0, counterIds empty
@@ -588,8 +590,8 @@ BOOST_AUTO_TEST_CASE(CheckCaptureDataHolder)
     CaptureData captureData;
     std::thread thread2(CaptureDataReadThreadImpl, std::ref(holder), std::ref(captureData));
     thread2.join();
-    BOOST_CHECK(captureData.GetCapturePeriod() == 2);
-    BOOST_CHECK(captureData.GetCounterIds() == periodIdMap[2]);
+    CHECK(captureData.GetCapturePeriod() == 2);
+    CHECK(captureData.GetCounterIds() == periodIdMap[2]);
 
     std::map<uint32_t, CaptureData> captureDataIdMap;
     for (uint32_t i = 0; i < numThreads; ++i)
@@ -606,8 +608,8 @@ BOOST_AUTO_TEST_CASE(CheckCaptureDataHolder)
             std::thread(CaptureDataWriteThreadImpl, std::ref(holder), i, std::ref(periodIdMap[i])));
 
         // Verify that the CaptureData goes into the thread in a virgin state
-        BOOST_CHECK(captureDataIdMap.at(i).GetCapturePeriod() == 0);
-        BOOST_CHECK(captureDataIdMap.at(i).GetCounterIds().empty());
+        CHECK(captureDataIdMap.at(i).GetCapturePeriod() == 0);
+        CHECK(captureDataIdMap.at(i).GetCounterIds().empty());
         readThreadsVect.emplace_back(
             std::thread(CaptureDataReadThreadImpl, std::ref(holder), std::ref(captureDataIdMap.at(i))));
     }
@@ -623,70 +625,70 @@ BOOST_AUTO_TEST_CASE(CheckCaptureDataHolder)
     for (uint32_t i = 0; i < numThreads; ++i)
     {
         CaptureData perThreadCaptureData = captureDataIdMap.at(i);
-        BOOST_CHECK(perThreadCaptureData.GetCounterIds() == periodIdMap.at(perThreadCaptureData.GetCapturePeriod()));
+        CHECK(perThreadCaptureData.GetCounterIds() == periodIdMap.at(perThreadCaptureData.GetCapturePeriod()));
     }
 }
 
-BOOST_AUTO_TEST_CASE(CaptureDataMethods)
+TEST_CASE("CaptureDataMethods")
 {
     // Check CaptureData setter and getter functions
     std::vector<uint16_t> counterIds = { 42, 29, 13 };
     CaptureData captureData;
-    BOOST_CHECK(captureData.GetCapturePeriod() == 0);
-    BOOST_CHECK((captureData.GetCounterIds()).empty());
+    CHECK(captureData.GetCapturePeriod() == 0);
+    CHECK((captureData.GetCounterIds()).empty());
     captureData.SetCapturePeriod(150);
     captureData.SetCounterIds(counterIds);
-    BOOST_CHECK(captureData.GetCapturePeriod() == 150);
-    BOOST_CHECK(captureData.GetCounterIds() == counterIds);
+    CHECK(captureData.GetCapturePeriod() == 150);
+    CHECK(captureData.GetCounterIds() == counterIds);
 
     // Check assignment operator
     CaptureData secondCaptureData;
 
     secondCaptureData = captureData;
-    BOOST_CHECK(secondCaptureData.GetCapturePeriod() == 150);
-    BOOST_CHECK(secondCaptureData.GetCounterIds() == counterIds);
+    CHECK(secondCaptureData.GetCapturePeriod() == 150);
+    CHECK(secondCaptureData.GetCounterIds() == counterIds);
 
     // Check copy constructor
     CaptureData copyConstructedCaptureData(captureData);
 
-    BOOST_CHECK(copyConstructedCaptureData.GetCapturePeriod() == 150);
-    BOOST_CHECK(copyConstructedCaptureData.GetCounterIds() == counterIds);
+    CHECK(copyConstructedCaptureData.GetCapturePeriod() == 150);
+    CHECK(copyConstructedCaptureData.GetCounterIds() == counterIds);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceDisabled)
+TEST_CASE("CheckProfilingServiceDisabled")
 {
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceCounterDirectory)
+TEST_CASE("CheckProfilingServiceCounterDirectory")
 {
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
 
     const ICounterDirectory& counterDirectory0 = profilingService.GetCounterDirectory();
-    BOOST_CHECK(counterDirectory0.GetCounterCount() == 0);
+    CHECK(counterDirectory0.GetCounterCount() == 0);
     profilingService.Update();
-    BOOST_CHECK(counterDirectory0.GetCounterCount() == 0);
+    CHECK(counterDirectory0.GetCounterCount() == 0);
 
     options.m_EnableProfiling = true;
     profilingService.ResetExternalProfilingOptions(options);
 
     const ICounterDirectory& counterDirectory1 = profilingService.GetCounterDirectory();
-    BOOST_CHECK(counterDirectory1.GetCounterCount() == 0);
+    CHECK(counterDirectory1.GetCounterCount() == 0);
     profilingService.Update();
-    BOOST_CHECK(counterDirectory1.GetCounterCount() != 0);
+    CHECK(counterDirectory1.GetCounterCount() != 0);
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceCounterValues)
+TEST_CASE("CheckProfilingServiceCounterValues")
 {
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
     options.m_EnableProfiling          = true;
@@ -696,11 +698,11 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceCounterValues)
     profilingService.Update();
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
     const Counters& counters                  = counterDirectory.GetCounters();
-    BOOST_CHECK(!counters.empty());
+    CHECK(!counters.empty());
 
     std::vector<std::thread> writers;
 
-    BOOST_CHECK(!counters.empty());
+    CHECK(!counters.empty());
 
     // Test GetAbsoluteCounterValue
     for (int i = 0; i < 4; ++i)
@@ -735,13 +737,13 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceCounterValues)
 
     uint32_t absoluteCounterValue = 0;
 
-    BOOST_CHECK_NO_THROW(absoluteCounterValue = profilingService.GetAbsoluteCounterValue(INFERENCES_RUN));
-    BOOST_CHECK(absoluteCounterValue = 5000);
+    CHECK_NOTHROW(absoluteCounterValue = profilingService.GetAbsoluteCounterValue(INFERENCES_RUN));
+    CHECK(absoluteCounterValue == 5000);
 
     // Test SetCounterValue
-    BOOST_CHECK_NO_THROW(profilingService.SetCounterValue(INFERENCES_RUN, 0));
-    BOOST_CHECK_NO_THROW(absoluteCounterValue = profilingService.GetAbsoluteCounterValue(INFERENCES_RUN));
-    BOOST_CHECK(absoluteCounterValue == 0);
+    CHECK_NOTHROW(profilingService.SetCounterValue(INFERENCES_RUN, 0));
+    CHECK_NOTHROW(absoluteCounterValue = profilingService.GetAbsoluteCounterValue(INFERENCES_RUN));
+    CHECK(absoluteCounterValue == 0);
 
     // Test GetDeltaCounterValue
     writers.clear();
@@ -788,402 +790,402 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceCounterValues)
 
     // Do one last read in case the reader stopped early
     deltaCounterValue += profilingService.GetDeltaCounterValue(INFERENCES_RUN);
-    BOOST_CHECK(deltaCounterValue == 5000);
+    CHECK(deltaCounterValue == 5000);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingObjectUids)
+TEST_CASE("CheckProfilingObjectUids")
 {
     uint16_t uid = 0;
-    BOOST_CHECK_NO_THROW(uid = GetNextUid());
-    BOOST_CHECK(uid >= 1);
+    CHECK_NOTHROW(uid = GetNextUid());
+    CHECK(uid >= 1);
 
     uint16_t nextUid = 0;
-    BOOST_CHECK_NO_THROW(nextUid = GetNextUid());
-    BOOST_CHECK(nextUid > uid);
+    CHECK_NOTHROW(nextUid = GetNextUid());
+    CHECK(nextUid > uid);
 
     std::vector<uint16_t> counterUids;
-    BOOST_CHECK_NO_THROW(counterUids = GetNextCounterUids(uid,0));
-    BOOST_CHECK(counterUids.size() == 1);
+    CHECK_NOTHROW(counterUids = GetNextCounterUids(uid,0));
+    CHECK(counterUids.size() == 1);
 
     std::vector<uint16_t> nextCounterUids;
-    BOOST_CHECK_NO_THROW(nextCounterUids = GetNextCounterUids(nextUid, 2));
-    BOOST_CHECK(nextCounterUids.size() == 2);
-    BOOST_CHECK(nextCounterUids[0] > counterUids[0]);
+    CHECK_NOTHROW(nextCounterUids = GetNextCounterUids(nextUid, 2));
+    CHECK(nextCounterUids.size() == 2);
+    CHECK(nextCounterUids[0] > counterUids[0]);
 
     std::vector<uint16_t> counterUidsMultiCore;
     uint16_t thirdUid = nextCounterUids[0];
     uint16_t numberOfCores = 13;
-    BOOST_CHECK_NO_THROW(counterUidsMultiCore = GetNextCounterUids(thirdUid, numberOfCores));
-    BOOST_CHECK(counterUidsMultiCore.size() == numberOfCores);
-    BOOST_CHECK(counterUidsMultiCore.front() >= nextCounterUids[0]);
+    CHECK_NOTHROW(counterUidsMultiCore = GetNextCounterUids(thirdUid, numberOfCores));
+    CHECK(counterUidsMultiCore.size() == numberOfCores);
+    CHECK(counterUidsMultiCore.front() >= nextCounterUids[0]);
     for (size_t i = 1; i < numberOfCores; i++)
     {
-        BOOST_CHECK(counterUidsMultiCore[i] == counterUidsMultiCore[i - 1] + 1);
+        CHECK(counterUidsMultiCore[i] == counterUidsMultiCore[i - 1] + 1);
     }
-    BOOST_CHECK(counterUidsMultiCore.back() == counterUidsMultiCore.front() + numberOfCores - 1);
+    CHECK(counterUidsMultiCore.back() == counterUidsMultiCore.front() + numberOfCores - 1);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCategory)
+TEST_CASE("CheckCounterDirectoryRegisterCategory")
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(counterDirectory.GetCategoryCount() == 0);
+    CHECK(counterDirectory.GetDeviceCount() == 0);
+    CHECK(counterDirectory.GetCounterSetCount() == 0);
+    CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a category with an invalid name
     const Category* noCategory = nullptr;
-    BOOST_CHECK_THROW(noCategory = counterDirectory.RegisterCategory(""), armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
-    BOOST_CHECK(!noCategory);
+    CHECK_THROWS_AS(noCategory = counterDirectory.RegisterCategory(""), armnn::InvalidArgumentException);
+    CHECK(counterDirectory.GetCategoryCount() == 0);
+    CHECK(!noCategory);
 
     // Register a category with an invalid name
-    BOOST_CHECK_THROW(noCategory = counterDirectory.RegisterCategory("invalid category"),
+    CHECK_THROWS_AS(noCategory = counterDirectory.RegisterCategory("invalid category"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
-    BOOST_CHECK(!noCategory);
+    CHECK(counterDirectory.GetCategoryCount() == 0);
+    CHECK(!noCategory);
 
     // Register a new category
     const std::string categoryName = "some_category";
     const Category* category       = nullptr;
-    BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category);
-    BOOST_CHECK(category->m_Name == categoryName);
-    BOOST_CHECK(category->m_Counters.empty());
+    CHECK_NOTHROW(category = counterDirectory.RegisterCategory(categoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category);
+    CHECK(category->m_Name == categoryName);
+    CHECK(category->m_Counters.empty());
 
     // Get the registered category
     const Category* registeredCategory = counterDirectory.GetCategory(categoryName);
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(registeredCategory);
-    BOOST_CHECK(registeredCategory == category);
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(registeredCategory);
+    CHECK(registeredCategory == category);
 
     // Try to get a category not registered
     const Category* notRegisteredCategory = counterDirectory.GetCategory("not_registered_category");
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(!notRegisteredCategory);
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(!notRegisteredCategory);
 
     // Register a category already registered
     const Category* anotherCategory = nullptr;
-    BOOST_CHECK_THROW(anotherCategory = counterDirectory.RegisterCategory(categoryName),
+    CHECK_THROWS_AS(anotherCategory = counterDirectory.RegisterCategory(categoryName),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(!anotherCategory);
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(!anotherCategory);
 
     // Register a device for testing
     const std::string deviceName = "some_device";
     const Device* device         = nullptr;
-    BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device);
-    BOOST_CHECK(device->m_Uid >= 1);
-    BOOST_CHECK(device->m_Name == deviceName);
-    BOOST_CHECK(device->m_Cores == 0);
+    CHECK_NOTHROW(device = counterDirectory.RegisterDevice(deviceName));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device);
+    CHECK(device->m_Uid >= 1);
+    CHECK(device->m_Name == deviceName);
+    CHECK(device->m_Cores == 0);
 
     // Register a new category not associated to any device
     const std::string categoryWoDeviceName = "some_category_without_device";
     const Category* categoryWoDevice       = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWoDevice = counterDirectory.RegisterCategory(categoryWoDeviceName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
-    BOOST_CHECK(categoryWoDevice);
-    BOOST_CHECK(categoryWoDevice->m_Name == categoryWoDeviceName);
-    BOOST_CHECK(categoryWoDevice->m_Counters.empty());
+    CHECK_NOTHROW(categoryWoDevice = counterDirectory.RegisterCategory(categoryWoDeviceName));
+    CHECK(counterDirectory.GetCategoryCount() == 2);
+    CHECK(categoryWoDevice);
+    CHECK(categoryWoDevice->m_Name == categoryWoDeviceName);
+    CHECK(categoryWoDevice->m_Counters.empty());
 
     // Register a new category associated to an invalid device name (already exist)
     const Category* categoryInvalidDeviceName = nullptr;
-    BOOST_CHECK_THROW(categoryInvalidDeviceName =
+    CHECK_THROWS_AS(categoryInvalidDeviceName =
                           counterDirectory.RegisterCategory(categoryWoDeviceName),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
-    BOOST_CHECK(!categoryInvalidDeviceName);
+    CHECK(counterDirectory.GetCategoryCount() == 2);
+    CHECK(!categoryInvalidDeviceName);
 
     // Register a new category associated to a valid device
     const std::string categoryWValidDeviceName = "some_category_with_valid_device";
     const Category* categoryWValidDevice       = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWValidDevice =
+    CHECK_NOTHROW(categoryWValidDevice =
                              counterDirectory.RegisterCategory(categoryWValidDeviceName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 3);
-    BOOST_CHECK(categoryWValidDevice);
-    BOOST_CHECK(categoryWValidDevice != category);
-    BOOST_CHECK(categoryWValidDevice->m_Name == categoryWValidDeviceName);
+    CHECK(counterDirectory.GetCategoryCount() == 3);
+    CHECK(categoryWValidDevice);
+    CHECK(categoryWValidDevice != category);
+    CHECK(categoryWValidDevice->m_Name == categoryWValidDeviceName);
 
     // Register a counter set for testing
     const std::string counterSetName = "some_counter_set";
     const CounterSet* counterSet     = nullptr;
-    BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(counterSet);
-    BOOST_CHECK(counterSet->m_Uid >= 1);
-    BOOST_CHECK(counterSet->m_Name == counterSetName);
-    BOOST_CHECK(counterSet->m_Count == 0);
+    CHECK_NOTHROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(counterSet);
+    CHECK(counterSet->m_Uid >= 1);
+    CHECK(counterSet->m_Name == counterSetName);
+    CHECK(counterSet->m_Count == 0);
 
     // Register a new category not associated to any counter set
     const std::string categoryWoCounterSetName = "some_category_without_counter_set";
     const Category* categoryWoCounterSet       = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWoCounterSet =
+    CHECK_NOTHROW(categoryWoCounterSet =
                              counterDirectory.RegisterCategory(categoryWoCounterSetName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 4);
-    BOOST_CHECK(categoryWoCounterSet);
-    BOOST_CHECK(categoryWoCounterSet->m_Name == categoryWoCounterSetName);
+    CHECK(counterDirectory.GetCategoryCount() == 4);
+    CHECK(categoryWoCounterSet);
+    CHECK(categoryWoCounterSet->m_Name == categoryWoCounterSetName);
 
     // Register a new category associated to a valid counter set
     const std::string categoryWValidCounterSetName = "some_category_with_valid_counter_set";
     const Category* categoryWValidCounterSet       = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWValidCounterSet = counterDirectory.RegisterCategory(categoryWValidCounterSetName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 5);
-    BOOST_CHECK(categoryWValidCounterSet);
-    BOOST_CHECK(categoryWValidCounterSet != category);
-    BOOST_CHECK(categoryWValidCounterSet->m_Name == categoryWValidCounterSetName);
+    CHECK_NOTHROW(categoryWValidCounterSet = counterDirectory.RegisterCategory(categoryWValidCounterSetName));
+    CHECK(counterDirectory.GetCategoryCount() == 5);
+    CHECK(categoryWValidCounterSet);
+    CHECK(categoryWValidCounterSet != category);
+    CHECK(categoryWValidCounterSet->m_Name == categoryWValidCounterSetName);
 
     // Register a new category associated to a valid device and counter set
     const std::string categoryWValidDeviceAndValidCounterSetName = "some_category_with_valid_device_and_counter_set";
     const Category* categoryWValidDeviceAndValidCounterSet       = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWValidDeviceAndValidCounterSet = counterDirectory.RegisterCategory(
+    CHECK_NOTHROW(categoryWValidDeviceAndValidCounterSet = counterDirectory.RegisterCategory(
                              categoryWValidDeviceAndValidCounterSetName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 6);
-    BOOST_CHECK(categoryWValidDeviceAndValidCounterSet);
-    BOOST_CHECK(categoryWValidDeviceAndValidCounterSet != category);
-    BOOST_CHECK(categoryWValidDeviceAndValidCounterSet->m_Name == categoryWValidDeviceAndValidCounterSetName);
+    CHECK(counterDirectory.GetCategoryCount() == 6);
+    CHECK(categoryWValidDeviceAndValidCounterSet);
+    CHECK(categoryWValidDeviceAndValidCounterSet != category);
+    CHECK(categoryWValidDeviceAndValidCounterSet->m_Name == categoryWValidDeviceAndValidCounterSetName);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterDevice)
+TEST_CASE("CheckCounterDirectoryRegisterDevice")
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(counterDirectory.GetCategoryCount() == 0);
+    CHECK(counterDirectory.GetDeviceCount() == 0);
+    CHECK(counterDirectory.GetCounterSetCount() == 0);
+    CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a device with an invalid name
     const Device* noDevice = nullptr;
-    BOOST_CHECK_THROW(noDevice = counterDirectory.RegisterDevice(""), armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
-    BOOST_CHECK(!noDevice);
+    CHECK_THROWS_AS(noDevice = counterDirectory.RegisterDevice(""), armnn::InvalidArgumentException);
+    CHECK(counterDirectory.GetDeviceCount() == 0);
+    CHECK(!noDevice);
 
     // Register a device with an invalid name
-    BOOST_CHECK_THROW(noDevice = counterDirectory.RegisterDevice("inv@lid nam€"), armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
-    BOOST_CHECK(!noDevice);
+    CHECK_THROWS_AS(noDevice = counterDirectory.RegisterDevice("inv@lid nam€"), armnn::InvalidArgumentException);
+    CHECK(counterDirectory.GetDeviceCount() == 0);
+    CHECK(!noDevice);
 
     // Register a new device with no cores or parent category
     const std::string deviceName = "some_device";
     const Device* device         = nullptr;
-    BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device);
-    BOOST_CHECK(device->m_Name == deviceName);
-    BOOST_CHECK(device->m_Uid >= 1);
-    BOOST_CHECK(device->m_Cores == 0);
+    CHECK_NOTHROW(device = counterDirectory.RegisterDevice(deviceName));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device);
+    CHECK(device->m_Name == deviceName);
+    CHECK(device->m_Uid >= 1);
+    CHECK(device->m_Cores == 0);
 
     // Try getting an unregistered device
     const Device* unregisteredDevice = counterDirectory.GetDevice(9999);
-    BOOST_CHECK(!unregisteredDevice);
+    CHECK(!unregisteredDevice);
 
     // Get the registered device
     const Device* registeredDevice = counterDirectory.GetDevice(device->m_Uid);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(registeredDevice);
-    BOOST_CHECK(registeredDevice == device);
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(registeredDevice);
+    CHECK(registeredDevice == device);
 
     // Register a device with the name of a device already registered
     const Device* deviceSameName = nullptr;
-    BOOST_CHECK_THROW(deviceSameName = counterDirectory.RegisterDevice(deviceName), armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(!deviceSameName);
+    CHECK_THROWS_AS(deviceSameName = counterDirectory.RegisterDevice(deviceName), armnn::InvalidArgumentException);
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(!deviceSameName);
 
     // Register a new device with cores and no parent category
     const std::string deviceWCoresName = "some_device_with_cores";
     const Device* deviceWCores         = nullptr;
-    BOOST_CHECK_NO_THROW(deviceWCores = counterDirectory.RegisterDevice(deviceWCoresName, 2));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
-    BOOST_CHECK(deviceWCores);
-    BOOST_CHECK(deviceWCores->m_Name == deviceWCoresName);
-    BOOST_CHECK(deviceWCores->m_Uid >= 1);
-    BOOST_CHECK(deviceWCores->m_Uid > device->m_Uid);
-    BOOST_CHECK(deviceWCores->m_Cores == 2);
+    CHECK_NOTHROW(deviceWCores = counterDirectory.RegisterDevice(deviceWCoresName, 2));
+    CHECK(counterDirectory.GetDeviceCount() == 2);
+    CHECK(deviceWCores);
+    CHECK(deviceWCores->m_Name == deviceWCoresName);
+    CHECK(deviceWCores->m_Uid >= 1);
+    CHECK(deviceWCores->m_Uid > device->m_Uid);
+    CHECK(deviceWCores->m_Cores == 2);
 
     // Get the registered device
     const Device* registeredDeviceWCores = counterDirectory.GetDevice(deviceWCores->m_Uid);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
-    BOOST_CHECK(registeredDeviceWCores);
-    BOOST_CHECK(registeredDeviceWCores == deviceWCores);
-    BOOST_CHECK(registeredDeviceWCores != device);
+    CHECK(counterDirectory.GetDeviceCount() == 2);
+    CHECK(registeredDeviceWCores);
+    CHECK(registeredDeviceWCores == deviceWCores);
+    CHECK(registeredDeviceWCores != device);
 
     // Register a new device with cores and invalid parent category
     const std::string deviceWCoresWInvalidParentCategoryName = "some_device_with_cores_with_invalid_parent_category";
     const Device* deviceWCoresWInvalidParentCategory         = nullptr;
-    BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory =
+    CHECK_THROWS_AS(deviceWCoresWInvalidParentCategory =
                           counterDirectory.RegisterDevice(deviceWCoresWInvalidParentCategoryName, 3, std::string("")),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
-    BOOST_CHECK(!deviceWCoresWInvalidParentCategory);
+    CHECK(counterDirectory.GetDeviceCount() == 2);
+    CHECK(!deviceWCoresWInvalidParentCategory);
 
     // Register a new device with cores and invalid parent category
     const std::string deviceWCoresWInvalidParentCategoryName2 = "some_device_with_cores_with_invalid_parent_category2";
     const Device* deviceWCoresWInvalidParentCategory2         = nullptr;
-    BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory2 = counterDirectory.RegisterDevice(
+    CHECK_THROWS_AS(deviceWCoresWInvalidParentCategory2 = counterDirectory.RegisterDevice(
                           deviceWCoresWInvalidParentCategoryName2, 3, std::string("invalid_parent_category")),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
-    BOOST_CHECK(!deviceWCoresWInvalidParentCategory2);
+    CHECK(counterDirectory.GetDeviceCount() == 2);
+    CHECK(!deviceWCoresWInvalidParentCategory2);
 
     // Register a category for testing
     const std::string categoryName = "some_category";
     const Category* category       = nullptr;
-    BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category);
-    BOOST_CHECK(category->m_Name == categoryName);
-    BOOST_CHECK(category->m_Counters.empty());
+    CHECK_NOTHROW(category = counterDirectory.RegisterCategory(categoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category);
+    CHECK(category->m_Name == categoryName);
+    CHECK(category->m_Counters.empty());
 
     // Register a new device with cores and valid parent category
     const std::string deviceWCoresWValidParentCategoryName = "some_device_with_cores_with_valid_parent_category";
     const Device* deviceWCoresWValidParentCategory         = nullptr;
-    BOOST_CHECK_NO_THROW(deviceWCoresWValidParentCategory =
+    CHECK_NOTHROW(deviceWCoresWValidParentCategory =
                              counterDirectory.RegisterDevice(deviceWCoresWValidParentCategoryName, 4, categoryName));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 3);
-    BOOST_CHECK(deviceWCoresWValidParentCategory);
-    BOOST_CHECK(deviceWCoresWValidParentCategory->m_Name == deviceWCoresWValidParentCategoryName);
-    BOOST_CHECK(deviceWCoresWValidParentCategory->m_Uid >= 1);
-    BOOST_CHECK(deviceWCoresWValidParentCategory->m_Uid > device->m_Uid);
-    BOOST_CHECK(deviceWCoresWValidParentCategory->m_Uid > deviceWCores->m_Uid);
-    BOOST_CHECK(deviceWCoresWValidParentCategory->m_Cores == 4);
+    CHECK(counterDirectory.GetDeviceCount() == 3);
+    CHECK(deviceWCoresWValidParentCategory);
+    CHECK(deviceWCoresWValidParentCategory->m_Name == deviceWCoresWValidParentCategoryName);
+    CHECK(deviceWCoresWValidParentCategory->m_Uid >= 1);
+    CHECK(deviceWCoresWValidParentCategory->m_Uid > device->m_Uid);
+    CHECK(deviceWCoresWValidParentCategory->m_Uid > deviceWCores->m_Uid);
+    CHECK(deviceWCoresWValidParentCategory->m_Cores == 4);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounterSet)
+TEST_CASE("CheckCounterDirectoryRegisterCounterSet")
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(counterDirectory.GetCategoryCount() == 0);
+    CHECK(counterDirectory.GetDeviceCount() == 0);
+    CHECK(counterDirectory.GetCounterSetCount() == 0);
+    CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a counter set with an invalid name
     const CounterSet* noCounterSet = nullptr;
-    BOOST_CHECK_THROW(noCounterSet = counterDirectory.RegisterCounterSet(""), armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(!noCounterSet);
+    CHECK_THROWS_AS(noCounterSet = counterDirectory.RegisterCounterSet(""), armnn::InvalidArgumentException);
+    CHECK(counterDirectory.GetCounterSetCount() == 0);
+    CHECK(!noCounterSet);
 
     // Register a counter set with an invalid name
-    BOOST_CHECK_THROW(noCounterSet = counterDirectory.RegisterCounterSet("invalid name"),
+    CHECK_THROWS_AS(noCounterSet = counterDirectory.RegisterCounterSet("invalid name"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(!noCounterSet);
+    CHECK(counterDirectory.GetCounterSetCount() == 0);
+    CHECK(!noCounterSet);
 
     // Register a new counter set with no count or parent category
     const std::string counterSetName = "some_counter_set";
     const CounterSet* counterSet     = nullptr;
-    BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(counterSet);
-    BOOST_CHECK(counterSet->m_Name == counterSetName);
-    BOOST_CHECK(counterSet->m_Uid >= 1);
-    BOOST_CHECK(counterSet->m_Count == 0);
+    CHECK_NOTHROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(counterSet);
+    CHECK(counterSet->m_Name == counterSetName);
+    CHECK(counterSet->m_Uid >= 1);
+    CHECK(counterSet->m_Count == 0);
 
     // Try getting an unregistered counter set
     const CounterSet* unregisteredCounterSet = counterDirectory.GetCounterSet(9999);
-    BOOST_CHECK(!unregisteredCounterSet);
+    CHECK(!unregisteredCounterSet);
 
     // Get the registered counter set
     const CounterSet* registeredCounterSet = counterDirectory.GetCounterSet(counterSet->m_Uid);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(registeredCounterSet);
-    BOOST_CHECK(registeredCounterSet == counterSet);
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(registeredCounterSet);
+    CHECK(registeredCounterSet == counterSet);
 
     // Register a counter set with the name of a counter set already registered
     const CounterSet* counterSetSameName = nullptr;
-    BOOST_CHECK_THROW(counterSetSameName = counterDirectory.RegisterCounterSet(counterSetName),
+    CHECK_THROWS_AS(counterSetSameName = counterDirectory.RegisterCounterSet(counterSetName),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(!counterSetSameName);
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(!counterSetSameName);
 
     // Register a new counter set with count and no parent category
     const std::string counterSetWCountName = "some_counter_set_with_count";
     const CounterSet* counterSetWCount     = nullptr;
-    BOOST_CHECK_NO_THROW(counterSetWCount = counterDirectory.RegisterCounterSet(counterSetWCountName, 37));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 2);
-    BOOST_CHECK(counterSetWCount);
-    BOOST_CHECK(counterSetWCount->m_Name == counterSetWCountName);
-    BOOST_CHECK(counterSetWCount->m_Uid >= 1);
-    BOOST_CHECK(counterSetWCount->m_Uid > counterSet->m_Uid);
-    BOOST_CHECK(counterSetWCount->m_Count == 37);
+    CHECK_NOTHROW(counterSetWCount = counterDirectory.RegisterCounterSet(counterSetWCountName, 37));
+    CHECK(counterDirectory.GetCounterSetCount() == 2);
+    CHECK(counterSetWCount);
+    CHECK(counterSetWCount->m_Name == counterSetWCountName);
+    CHECK(counterSetWCount->m_Uid >= 1);
+    CHECK(counterSetWCount->m_Uid > counterSet->m_Uid);
+    CHECK(counterSetWCount->m_Count == 37);
 
     // Get the registered counter set
     const CounterSet* registeredCounterSetWCount = counterDirectory.GetCounterSet(counterSetWCount->m_Uid);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 2);
-    BOOST_CHECK(registeredCounterSetWCount);
-    BOOST_CHECK(registeredCounterSetWCount == counterSetWCount);
-    BOOST_CHECK(registeredCounterSetWCount != counterSet);
+    CHECK(counterDirectory.GetCounterSetCount() == 2);
+    CHECK(registeredCounterSetWCount);
+    CHECK(registeredCounterSetWCount == counterSetWCount);
+    CHECK(registeredCounterSetWCount != counterSet);
 
     // Register a new counter set with count and invalid parent category
     const std::string counterSetWCountWInvalidParentCategoryName = "some_counter_set_with_count_"
                                                                    "with_invalid_parent_category";
     const CounterSet* counterSetWCountWInvalidParentCategory = nullptr;
-    BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory = counterDirectory.RegisterCounterSet(
+    CHECK_THROWS_AS(counterSetWCountWInvalidParentCategory = counterDirectory.RegisterCounterSet(
                           counterSetWCountWInvalidParentCategoryName, 42, std::string("")),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 2);
-    BOOST_CHECK(!counterSetWCountWInvalidParentCategory);
+    CHECK(counterDirectory.GetCounterSetCount() == 2);
+    CHECK(!counterSetWCountWInvalidParentCategory);
 
     // Register a new counter set with count and invalid parent category
     const std::string counterSetWCountWInvalidParentCategoryName2 = "some_counter_set_with_count_"
                                                                     "with_invalid_parent_category2";
     const CounterSet* counterSetWCountWInvalidParentCategory2 = nullptr;
-    BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory2 = counterDirectory.RegisterCounterSet(
+    CHECK_THROWS_AS(counterSetWCountWInvalidParentCategory2 = counterDirectory.RegisterCounterSet(
                           counterSetWCountWInvalidParentCategoryName2, 42, std::string("invalid_parent_category")),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 2);
-    BOOST_CHECK(!counterSetWCountWInvalidParentCategory2);
+    CHECK(counterDirectory.GetCounterSetCount() == 2);
+    CHECK(!counterSetWCountWInvalidParentCategory2);
 
     // Register a category for testing
     const std::string categoryName = "some_category";
     const Category* category       = nullptr;
-    BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category);
-    BOOST_CHECK(category->m_Name == categoryName);
-    BOOST_CHECK(category->m_Counters.empty());
+    CHECK_NOTHROW(category = counterDirectory.RegisterCategory(categoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category);
+    CHECK(category->m_Name == categoryName);
+    CHECK(category->m_Counters.empty());
 
     // Register a new counter set with count and valid parent category
     const std::string counterSetWCountWValidParentCategoryName = "some_counter_set_with_count_"
                                                                  "with_valid_parent_category";
     const CounterSet* counterSetWCountWValidParentCategory = nullptr;
-    BOOST_CHECK_NO_THROW(counterSetWCountWValidParentCategory = counterDirectory.RegisterCounterSet(
+    CHECK_NOTHROW(counterSetWCountWValidParentCategory = counterDirectory.RegisterCounterSet(
                              counterSetWCountWValidParentCategoryName, 42, categoryName));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 3);
-    BOOST_CHECK(counterSetWCountWValidParentCategory);
-    BOOST_CHECK(counterSetWCountWValidParentCategory->m_Name == counterSetWCountWValidParentCategoryName);
-    BOOST_CHECK(counterSetWCountWValidParentCategory->m_Uid >= 1);
-    BOOST_CHECK(counterSetWCountWValidParentCategory->m_Uid > counterSet->m_Uid);
-    BOOST_CHECK(counterSetWCountWValidParentCategory->m_Uid > counterSetWCount->m_Uid);
-    BOOST_CHECK(counterSetWCountWValidParentCategory->m_Count == 42);
+    CHECK(counterDirectory.GetCounterSetCount() == 3);
+    CHECK(counterSetWCountWValidParentCategory);
+    CHECK(counterSetWCountWValidParentCategory->m_Name == counterSetWCountWValidParentCategoryName);
+    CHECK(counterSetWCountWValidParentCategory->m_Uid >= 1);
+    CHECK(counterSetWCountWValidParentCategory->m_Uid > counterSet->m_Uid);
+    CHECK(counterSetWCountWValidParentCategory->m_Uid > counterSetWCount->m_Uid);
+    CHECK(counterSetWCountWValidParentCategory->m_Count == 42);
 
     // Register a counter set associated to a category with invalid name
     const std::string counterSetSameCategoryName = "some_counter_set_with_invalid_parent_category";
     const std::string invalidCategoryName = "";
     const CounterSet* counterSetSameCategory     = nullptr;
-    BOOST_CHECK_THROW(counterSetSameCategory =
+    CHECK_THROWS_AS(counterSetSameCategory =
                           counterDirectory.RegisterCounterSet(counterSetSameCategoryName, 0, invalidCategoryName),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 3);
-    BOOST_CHECK(!counterSetSameCategory);
+    CHECK(counterDirectory.GetCounterSetCount() == 3);
+    CHECK(!counterSetSameCategory);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
+TEST_CASE("CheckCounterDirectoryRegisterCounter")
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(counterDirectory.GetCategoryCount() == 0);
+    CHECK(counterDirectory.GetDeviceCount() == 0);
+    CHECK(counterDirectory.GetCounterSetCount() == 0);
+    CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a counter with an invalid parent category name
     const Counter* noCounter = nullptr;
-    BOOST_CHECK_THROW(noCounter =
+    CHECK_THROWS_AS(noCounter =
                           counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                            0,
                                                            "",
@@ -1193,11 +1195,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                            "valid ",
                                                            "name"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid parent category name
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    1,
                                                                    "invalid parent category",
                                                                    0,
@@ -1206,11 +1208,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "valid name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid class
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    2,
                                                                    "valid_parent_category",
                                                                    2,
@@ -1220,11 +1222,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid interpolation
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    4,
                                                                    "valid_parent_category",
                                                                    0,
@@ -1234,11 +1236,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid multiplier
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    5,
                                                                    "valid_parent_category",
                                                                    0,
@@ -1248,11 +1250,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid name
-    BOOST_CHECK_THROW(
+    CHECK_THROWS_AS(
         noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                      6,
                                                      "valid_parent_category",
@@ -1262,11 +1264,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                      "",
                                                      "valid description"),
         armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid name
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    7,
                                                                    "valid_parent_category",
                                                                    0,
@@ -1275,11 +1277,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "invalid nam€",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid description
-    BOOST_CHECK_THROW(noCounter =
+    CHECK_THROWS_AS(noCounter =
                           counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                            8,
                                                            "valid_parent_category",
@@ -1289,11 +1291,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                            "valid name",
                                                            ""),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid description
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    9,
                                                                    "valid_parent_category",
                                                                    0,
@@ -1303,11 +1305,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "name",
                                                                    "inv@lid description"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with an invalid unit2
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    10,
                                                                    "valid_parent_category",
                                                                    0,
@@ -1317,11 +1319,11 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "valid description",
                                                                    std::string("Mb/s2")),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Register a counter with a non-existing parent category name
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    11,
                                                                    "invalid_parent_category",
                                                                    0,
@@ -1330,25 +1332,25 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    "valid name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 0);
+    CHECK(!noCounter);
 
     // Try getting an unregistered counter
     const Counter* unregisteredCounter = counterDirectory.GetCounter(9999);
-    BOOST_CHECK(!unregisteredCounter);
+    CHECK(!unregisteredCounter);
 
     // Register a category for testing
     const std::string categoryName = "some_category";
     const Category* category       = nullptr;
-    BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category);
-    BOOST_CHECK(category->m_Name == categoryName);
-    BOOST_CHECK(category->m_Counters.empty());
+    CHECK_NOTHROW(category = counterDirectory.RegisterCategory(categoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category);
+    CHECK(category->m_Name == categoryName);
+    CHECK(category->m_Counters.empty());
 
     // Register a counter with a valid parent category name
     const Counter* counter = nullptr;
-    BOOST_CHECK_NO_THROW(
+    CHECK_NOTHROW(
         counter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                    12,
                                                    categoryName,
@@ -1357,23 +1359,23 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                    123.45f,
                                                    "valid name",
                                                    "valid description"));
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 1);
-    BOOST_CHECK(counter);
-    BOOST_CHECK(counter->m_MaxCounterUid == counter->m_Uid);
-    BOOST_CHECK(counter->m_Class == 0);
-    BOOST_CHECK(counter->m_Interpolation == 1);
-    BOOST_CHECK(counter->m_Multiplier == 123.45f);
-    BOOST_CHECK(counter->m_Name == "valid name");
-    BOOST_CHECK(counter->m_Description == "valid description");
-    BOOST_CHECK(counter->m_Units == "");
-    BOOST_CHECK(counter->m_DeviceUid == 0);
-    BOOST_CHECK(counter->m_CounterSetUid == 0);
-    BOOST_CHECK(category->m_Counters.size() == 1);
-    BOOST_CHECK(category->m_Counters.back() == counter->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 1);
+    CHECK(counter);
+    CHECK(counter->m_MaxCounterUid == counter->m_Uid);
+    CHECK(counter->m_Class == 0);
+    CHECK(counter->m_Interpolation == 1);
+    CHECK(counter->m_Multiplier == 123.45f);
+    CHECK(counter->m_Name == "valid name");
+    CHECK(counter->m_Description == "valid description");
+    CHECK(counter->m_Units == "");
+    CHECK(counter->m_DeviceUid == 0);
+    CHECK(counter->m_CounterSetUid == 0);
+    CHECK(category->m_Counters.size() == 1);
+    CHECK(category->m_Counters.back() == counter->m_Uid);
 
     // Register a counter with a name of a counter already registered for the given parent category name
     const Counter* counterSameName = nullptr;
-    BOOST_CHECK_THROW(counterSameName =
+    CHECK_THROWS_AS(counterSameName =
                           counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                            13,
                                                            categoryName,
@@ -1384,12 +1386,12 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                            "valid description",
                                                            std::string("description")),
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 1);
-    BOOST_CHECK(!counterSameName);
+    CHECK(counterDirectory.GetCounterCount() == 1);
+    CHECK(!counterSameName);
 
     // Register a counter with a valid parent category name and units
     const Counter* counterWUnits = nullptr;
-    BOOST_CHECK_NO_THROW(counterWUnits = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counterWUnits = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                              14,
                                                                              categoryName,
                                                                              0,
@@ -1398,24 +1400,24 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                              "valid name 2",
                                                                              "valid description",
                                                                              std::string("Mnnsq2")));    // Units
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 2);
-    BOOST_CHECK(counterWUnits);
-    BOOST_CHECK(counterWUnits->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWUnits->m_MaxCounterUid == counterWUnits->m_Uid);
-    BOOST_CHECK(counterWUnits->m_Class == 0);
-    BOOST_CHECK(counterWUnits->m_Interpolation == 1);
-    BOOST_CHECK(counterWUnits->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWUnits->m_Name == "valid name 2");
-    BOOST_CHECK(counterWUnits->m_Description == "valid description");
-    BOOST_CHECK(counterWUnits->m_Units == "Mnnsq2");
-    BOOST_CHECK(counterWUnits->m_DeviceUid == 0);
-    BOOST_CHECK(counterWUnits->m_CounterSetUid == 0);
-    BOOST_CHECK(category->m_Counters.size() == 2);
-    BOOST_CHECK(category->m_Counters.back() == counterWUnits->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 2);
+    CHECK(counterWUnits);
+    CHECK(counterWUnits->m_Uid > counter->m_Uid);
+    CHECK(counterWUnits->m_MaxCounterUid == counterWUnits->m_Uid);
+    CHECK(counterWUnits->m_Class == 0);
+    CHECK(counterWUnits->m_Interpolation == 1);
+    CHECK(counterWUnits->m_Multiplier == 123.45f);
+    CHECK(counterWUnits->m_Name == "valid name 2");
+    CHECK(counterWUnits->m_Description == "valid description");
+    CHECK(counterWUnits->m_Units == "Mnnsq2");
+    CHECK(counterWUnits->m_DeviceUid == 0);
+    CHECK(counterWUnits->m_CounterSetUid == 0);
+    CHECK(category->m_Counters.size() == 2);
+    CHECK(category->m_Counters.back() == counterWUnits->m_Uid);
 
     // Register a counter with a valid parent category name and not associated with a device
     const Counter* counterWoDevice = nullptr;
-    BOOST_CHECK_NO_THROW(counterWoDevice = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counterWoDevice = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                             26,
                                                                             categoryName,
                                                                             0,
@@ -1426,23 +1428,23 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                             armnn::EmptyOptional(),// Units
                                                                             armnn::EmptyOptional(),// Number of cores
                                                                             0));                   // Device UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 3);
-    BOOST_CHECK(counterWoDevice);
-    BOOST_CHECK(counterWoDevice->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWoDevice->m_MaxCounterUid == counterWoDevice->m_Uid);
-    BOOST_CHECK(counterWoDevice->m_Class == 0);
-    BOOST_CHECK(counterWoDevice->m_Interpolation == 1);
-    BOOST_CHECK(counterWoDevice->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWoDevice->m_Name == "valid name 3");
-    BOOST_CHECK(counterWoDevice->m_Description == "valid description");
-    BOOST_CHECK(counterWoDevice->m_Units == "");
-    BOOST_CHECK(counterWoDevice->m_DeviceUid == 0);
-    BOOST_CHECK(counterWoDevice->m_CounterSetUid == 0);
-    BOOST_CHECK(category->m_Counters.size() == 3);
-    BOOST_CHECK(category->m_Counters.back() == counterWoDevice->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 3);
+    CHECK(counterWoDevice);
+    CHECK(counterWoDevice->m_Uid > counter->m_Uid);
+    CHECK(counterWoDevice->m_MaxCounterUid == counterWoDevice->m_Uid);
+    CHECK(counterWoDevice->m_Class == 0);
+    CHECK(counterWoDevice->m_Interpolation == 1);
+    CHECK(counterWoDevice->m_Multiplier == 123.45f);
+    CHECK(counterWoDevice->m_Name == "valid name 3");
+    CHECK(counterWoDevice->m_Description == "valid description");
+    CHECK(counterWoDevice->m_Units == "");
+    CHECK(counterWoDevice->m_DeviceUid == 0);
+    CHECK(counterWoDevice->m_CounterSetUid == 0);
+    CHECK(category->m_Counters.size() == 3);
+    CHECK(category->m_Counters.back() == counterWoDevice->m_Uid);
 
     // Register a counter with a valid parent category name and associated to an invalid device
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    15,
                                                                    categoryName,
                                                                    0,
@@ -1454,22 +1456,22 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    armnn::EmptyOptional(),    // Number of cores
                                                                    100),                      // Device UID
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 3);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 3);
+    CHECK(!noCounter);
 
     // Register a device for testing
     const std::string deviceName = "some_device";
     const Device* device         = nullptr;
-    BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device);
-    BOOST_CHECK(device->m_Name == deviceName);
-    BOOST_CHECK(device->m_Uid >= 1);
-    BOOST_CHECK(device->m_Cores == 0);
+    CHECK_NOTHROW(device = counterDirectory.RegisterDevice(deviceName));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device);
+    CHECK(device->m_Name == deviceName);
+    CHECK(device->m_Uid >= 1);
+    CHECK(device->m_Cores == 0);
 
     // Register a counter with a valid parent category name and associated to a device
     const Counter* counterWDevice = nullptr;
-    BOOST_CHECK_NO_THROW(counterWDevice = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counterWDevice = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                            16,
                                                                            categoryName,
                                                                            0,
@@ -1480,24 +1482,24 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                            armnn::EmptyOptional(), // Units
                                                                            armnn::EmptyOptional(), // Number of cores
                                                                            device->m_Uid));        // Device UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 4);
-    BOOST_CHECK(counterWDevice);
-    BOOST_CHECK(counterWDevice->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWDevice->m_MaxCounterUid == counterWDevice->m_Uid);
-    BOOST_CHECK(counterWDevice->m_Class == 0);
-    BOOST_CHECK(counterWDevice->m_Interpolation == 1);
-    BOOST_CHECK(counterWDevice->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWDevice->m_Name == "valid name 5");
-    BOOST_CHECK(counterWDevice->m_Description == "valid description");
-    BOOST_CHECK(counterWDevice->m_Units == "");
-    BOOST_CHECK(counterWDevice->m_DeviceUid == device->m_Uid);
-    BOOST_CHECK(counterWDevice->m_CounterSetUid == 0);
-    BOOST_CHECK(category->m_Counters.size() == 4);
-    BOOST_CHECK(category->m_Counters.back() == counterWDevice->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 4);
+    CHECK(counterWDevice);
+    CHECK(counterWDevice->m_Uid > counter->m_Uid);
+    CHECK(counterWDevice->m_MaxCounterUid == counterWDevice->m_Uid);
+    CHECK(counterWDevice->m_Class == 0);
+    CHECK(counterWDevice->m_Interpolation == 1);
+    CHECK(counterWDevice->m_Multiplier == 123.45f);
+    CHECK(counterWDevice->m_Name == "valid name 5");
+    CHECK(counterWDevice->m_Description == "valid description");
+    CHECK(counterWDevice->m_Units == "");
+    CHECK(counterWDevice->m_DeviceUid == device->m_Uid);
+    CHECK(counterWDevice->m_CounterSetUid == 0);
+    CHECK(category->m_Counters.size() == 4);
+    CHECK(category->m_Counters.back() == counterWDevice->m_Uid);
 
     // Register a counter with a valid parent category name and not associated with a counter set
     const Counter* counterWoCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterWoCounterSet = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counterWoCounterSet = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                                 17,
                                                                                 categoryName,
                                                                                 0,
@@ -1509,23 +1511,23 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                                 armnn::EmptyOptional(),// No of cores
                                                                                 armnn::EmptyOptional(),// Device UID
                                                                                 0));               // CounterSet UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 5);
-    BOOST_CHECK(counterWoCounterSet);
-    BOOST_CHECK(counterWoCounterSet->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWoCounterSet->m_MaxCounterUid == counterWoCounterSet->m_Uid);
-    BOOST_CHECK(counterWoCounterSet->m_Class == 0);
-    BOOST_CHECK(counterWoCounterSet->m_Interpolation == 1);
-    BOOST_CHECK(counterWoCounterSet->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWoCounterSet->m_Name == "valid name 6");
-    BOOST_CHECK(counterWoCounterSet->m_Description == "valid description");
-    BOOST_CHECK(counterWoCounterSet->m_Units == "");
-    BOOST_CHECK(counterWoCounterSet->m_DeviceUid == 0);
-    BOOST_CHECK(counterWoCounterSet->m_CounterSetUid == 0);
-    BOOST_CHECK(category->m_Counters.size() == 5);
-    BOOST_CHECK(category->m_Counters.back() == counterWoCounterSet->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 5);
+    CHECK(counterWoCounterSet);
+    CHECK(counterWoCounterSet->m_Uid > counter->m_Uid);
+    CHECK(counterWoCounterSet->m_MaxCounterUid == counterWoCounterSet->m_Uid);
+    CHECK(counterWoCounterSet->m_Class == 0);
+    CHECK(counterWoCounterSet->m_Interpolation == 1);
+    CHECK(counterWoCounterSet->m_Multiplier == 123.45f);
+    CHECK(counterWoCounterSet->m_Name == "valid name 6");
+    CHECK(counterWoCounterSet->m_Description == "valid description");
+    CHECK(counterWoCounterSet->m_Units == "");
+    CHECK(counterWoCounterSet->m_DeviceUid == 0);
+    CHECK(counterWoCounterSet->m_CounterSetUid == 0);
+    CHECK(category->m_Counters.size() == 5);
+    CHECK(category->m_Counters.back() == counterWoCounterSet->m_Uid);
 
     // Register a counter with a valid parent category name and associated to an invalid counter set
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_THROWS_AS(noCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                    18,
                                                                    categoryName,
                                                                    0,
@@ -1538,92 +1540,92 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                                    armnn::EmptyOptional(),    // Number of cores
                                                                    100),            // Counter set UID
                       armnn::InvalidArgumentException);
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 5);
-    BOOST_CHECK(!noCounter);
+    CHECK(counterDirectory.GetCounterCount() == 5);
+    CHECK(!noCounter);
 
     // Register a counter with a valid parent category name and with a given number of cores
     const Counter* counterWNumberOfCores = nullptr;
     uint16_t numberOfCores               = 15;
-    BOOST_CHECK_NO_THROW(counterWNumberOfCores = counterDirectory.RegisterCounter(
+    CHECK_NOTHROW(counterWNumberOfCores = counterDirectory.RegisterCounter(
                              armnn::profiling::BACKEND_ID, 50,
                              categoryName, 0, 1, 123.45f, "valid name 8", "valid description",
                              armnn::EmptyOptional(),      // Units
                              numberOfCores,               // Number of cores
                              armnn::EmptyOptional(),      // Device UID
                              armnn::EmptyOptional()));    // Counter set UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 20);
-    BOOST_CHECK(counterWNumberOfCores);
-    BOOST_CHECK(counterWNumberOfCores->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWNumberOfCores->m_MaxCounterUid == counterWNumberOfCores->m_Uid + numberOfCores - 1);
-    BOOST_CHECK(counterWNumberOfCores->m_Class == 0);
-    BOOST_CHECK(counterWNumberOfCores->m_Interpolation == 1);
-    BOOST_CHECK(counterWNumberOfCores->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWNumberOfCores->m_Name == "valid name 8");
-    BOOST_CHECK(counterWNumberOfCores->m_Description == "valid description");
-    BOOST_CHECK(counterWNumberOfCores->m_Units == "");
-    BOOST_CHECK(counterWNumberOfCores->m_DeviceUid == 0);
-    BOOST_CHECK(counterWNumberOfCores->m_CounterSetUid == 0);
-    BOOST_CHECK(category->m_Counters.size() == 20);
+    CHECK(counterDirectory.GetCounterCount() == 20);
+    CHECK(counterWNumberOfCores);
+    CHECK(counterWNumberOfCores->m_Uid > counter->m_Uid);
+    CHECK(counterWNumberOfCores->m_MaxCounterUid == counterWNumberOfCores->m_Uid + numberOfCores - 1);
+    CHECK(counterWNumberOfCores->m_Class == 0);
+    CHECK(counterWNumberOfCores->m_Interpolation == 1);
+    CHECK(counterWNumberOfCores->m_Multiplier == 123.45f);
+    CHECK(counterWNumberOfCores->m_Name == "valid name 8");
+    CHECK(counterWNumberOfCores->m_Description == "valid description");
+    CHECK(counterWNumberOfCores->m_Units == "");
+    CHECK(counterWNumberOfCores->m_DeviceUid == 0);
+    CHECK(counterWNumberOfCores->m_CounterSetUid == 0);
+    CHECK(category->m_Counters.size() == 20);
     for (size_t i = 0; i < numberOfCores; i++)
     {
-        BOOST_CHECK(category->m_Counters[category->m_Counters.size() - numberOfCores + i] ==
+        CHECK(category->m_Counters[category->m_Counters.size() - numberOfCores + i] ==
                     counterWNumberOfCores->m_Uid + i);
     }
 
     // Register a multi-core device for testing
     const std::string multiCoreDeviceName = "some_multi_core_device";
     const Device* multiCoreDevice         = nullptr;
-    BOOST_CHECK_NO_THROW(multiCoreDevice = counterDirectory.RegisterDevice(multiCoreDeviceName, 4));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
-    BOOST_CHECK(multiCoreDevice);
-    BOOST_CHECK(multiCoreDevice->m_Name == multiCoreDeviceName);
-    BOOST_CHECK(multiCoreDevice->m_Uid >= 1);
-    BOOST_CHECK(multiCoreDevice->m_Cores == 4);
+    CHECK_NOTHROW(multiCoreDevice = counterDirectory.RegisterDevice(multiCoreDeviceName, 4));
+    CHECK(counterDirectory.GetDeviceCount() == 2);
+    CHECK(multiCoreDevice);
+    CHECK(multiCoreDevice->m_Name == multiCoreDeviceName);
+    CHECK(multiCoreDevice->m_Uid >= 1);
+    CHECK(multiCoreDevice->m_Cores == 4);
 
     // Register a counter with a valid parent category name and associated to the multi-core device
     const Counter* counterWMultiCoreDevice = nullptr;
-    BOOST_CHECK_NO_THROW(counterWMultiCoreDevice = counterDirectory.RegisterCounter(
+    CHECK_NOTHROW(counterWMultiCoreDevice = counterDirectory.RegisterCounter(
                              armnn::profiling::BACKEND_ID, 19, categoryName, 0, 1,
                              123.45f, "valid name 9", "valid description",
                              armnn::EmptyOptional(),      // Units
                              armnn::EmptyOptional(),      // Number of cores
                              multiCoreDevice->m_Uid,      // Device UID
                              armnn::EmptyOptional()));    // Counter set UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 24);
-    BOOST_CHECK(counterWMultiCoreDevice);
-    BOOST_CHECK(counterWMultiCoreDevice->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWMultiCoreDevice->m_MaxCounterUid ==
+    CHECK(counterDirectory.GetCounterCount() == 24);
+    CHECK(counterWMultiCoreDevice);
+    CHECK(counterWMultiCoreDevice->m_Uid > counter->m_Uid);
+    CHECK(counterWMultiCoreDevice->m_MaxCounterUid ==
                 counterWMultiCoreDevice->m_Uid + multiCoreDevice->m_Cores - 1);
-    BOOST_CHECK(counterWMultiCoreDevice->m_Class == 0);
-    BOOST_CHECK(counterWMultiCoreDevice->m_Interpolation == 1);
-    BOOST_CHECK(counterWMultiCoreDevice->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWMultiCoreDevice->m_Name == "valid name 9");
-    BOOST_CHECK(counterWMultiCoreDevice->m_Description == "valid description");
-    BOOST_CHECK(counterWMultiCoreDevice->m_Units == "");
-    BOOST_CHECK(counterWMultiCoreDevice->m_DeviceUid == multiCoreDevice->m_Uid);
-    BOOST_CHECK(counterWMultiCoreDevice->m_CounterSetUid == 0);
-    BOOST_CHECK(category->m_Counters.size() == 24);
+    CHECK(counterWMultiCoreDevice->m_Class == 0);
+    CHECK(counterWMultiCoreDevice->m_Interpolation == 1);
+    CHECK(counterWMultiCoreDevice->m_Multiplier == 123.45f);
+    CHECK(counterWMultiCoreDevice->m_Name == "valid name 9");
+    CHECK(counterWMultiCoreDevice->m_Description == "valid description");
+    CHECK(counterWMultiCoreDevice->m_Units == "");
+    CHECK(counterWMultiCoreDevice->m_DeviceUid == multiCoreDevice->m_Uid);
+    CHECK(counterWMultiCoreDevice->m_CounterSetUid == 0);
+    CHECK(category->m_Counters.size() == 24);
     for (size_t i = 0; i < 4; i++)
     {
-        BOOST_CHECK(category->m_Counters[category->m_Counters.size() - 4 + i] == counterWMultiCoreDevice->m_Uid + i);
+        CHECK(category->m_Counters[category->m_Counters.size() - 4 + i] == counterWMultiCoreDevice->m_Uid + i);
     }
 
     // Register a multi-core device associate to a parent category for testing
     const std::string multiCoreDeviceNameWParentCategory = "some_multi_core_device_with_parent_category";
     const Device* multiCoreDeviceWParentCategory         = nullptr;
-    BOOST_CHECK_NO_THROW(multiCoreDeviceWParentCategory =
+    CHECK_NOTHROW(multiCoreDeviceWParentCategory =
                              counterDirectory.RegisterDevice(multiCoreDeviceNameWParentCategory, 2, categoryName));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 3);
-    BOOST_CHECK(multiCoreDeviceWParentCategory);
-    BOOST_CHECK(multiCoreDeviceWParentCategory->m_Name == multiCoreDeviceNameWParentCategory);
-    BOOST_CHECK(multiCoreDeviceWParentCategory->m_Uid >= 1);
-    BOOST_CHECK(multiCoreDeviceWParentCategory->m_Cores == 2);
+    CHECK(counterDirectory.GetDeviceCount() == 3);
+    CHECK(multiCoreDeviceWParentCategory);
+    CHECK(multiCoreDeviceWParentCategory->m_Name == multiCoreDeviceNameWParentCategory);
+    CHECK(multiCoreDeviceWParentCategory->m_Uid >= 1);
+    CHECK(multiCoreDeviceWParentCategory->m_Cores == 2);
 
     // Register a counter with a valid parent category name and getting the number of cores of the multi-core device
     // associated to that category
     const Counter* counterWMultiCoreDeviceWParentCategory = nullptr;
     uint16_t numberOfCourse = multiCoreDeviceWParentCategory->m_Cores;
-    BOOST_CHECK_NO_THROW(counterWMultiCoreDeviceWParentCategory =
+    CHECK_NOTHROW(counterWMultiCoreDeviceWParentCategory =
                                                 counterDirectory.RegisterCounter(
                                                     armnn::profiling::BACKEND_ID,
                                                     100,
@@ -1637,117 +1639,117 @@ BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
                                                     numberOfCourse,          // Number of cores
                                                     armnn::EmptyOptional(),  // Device UID
                                                     armnn::EmptyOptional()));// Counter set UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 26);
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory);
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_MaxCounterUid ==
+    CHECK(counterDirectory.GetCounterCount() == 26);
+    CHECK(counterWMultiCoreDeviceWParentCategory);
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_Uid > counter->m_Uid);
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_MaxCounterUid ==
                 counterWMultiCoreDeviceWParentCategory->m_Uid + multiCoreDeviceWParentCategory->m_Cores - 1);
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Class == 0);
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Interpolation == 1);
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Name == "valid name 10");
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Description == "valid description");
-    BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Units == "");
-    BOOST_CHECK(category->m_Counters.size() == 26);
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_Class == 0);
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_Interpolation == 1);
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_Multiplier == 123.45f);
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_Name == "valid name 10");
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_Description == "valid description");
+    CHECK(counterWMultiCoreDeviceWParentCategory->m_Units == "");
+    CHECK(category->m_Counters.size() == 26);
     for (size_t i = 0; i < 2; i++)
     {
-        BOOST_CHECK(category->m_Counters[category->m_Counters.size() - 2 + i] ==
+        CHECK(category->m_Counters[category->m_Counters.size() - 2 + i] ==
                     counterWMultiCoreDeviceWParentCategory->m_Uid + i);
     }
 
     // Register a counter set for testing
     const std::string counterSetName = "some_counter_set";
     const CounterSet* counterSet     = nullptr;
-    BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(counterSet);
-    BOOST_CHECK(counterSet->m_Name == counterSetName);
-    BOOST_CHECK(counterSet->m_Uid >= 1);
-    BOOST_CHECK(counterSet->m_Count == 0);
+    CHECK_NOTHROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(counterSet);
+    CHECK(counterSet->m_Name == counterSetName);
+    CHECK(counterSet->m_Uid >= 1);
+    CHECK(counterSet->m_Count == 0);
 
     // Register a counter with a valid parent category name and associated to a counter set
     const Counter* counterWCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterWCounterSet = counterDirectory.RegisterCounter(
+    CHECK_NOTHROW(counterWCounterSet = counterDirectory.RegisterCounter(
                              armnn::profiling::BACKEND_ID, 300,
                              categoryName, 0, 1, 123.45f, "valid name 11", "valid description",
                              armnn::EmptyOptional(),    // Units
                              0,                         // Number of cores
                              armnn::EmptyOptional(),    // Device UID
                              counterSet->m_Uid));       // Counter set UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 27);
-    BOOST_CHECK(counterWCounterSet);
-    BOOST_CHECK(counterWCounterSet->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWCounterSet->m_MaxCounterUid == counterWCounterSet->m_Uid);
-    BOOST_CHECK(counterWCounterSet->m_Class == 0);
-    BOOST_CHECK(counterWCounterSet->m_Interpolation == 1);
-    BOOST_CHECK(counterWCounterSet->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWCounterSet->m_Name == "valid name 11");
-    BOOST_CHECK(counterWCounterSet->m_Description == "valid description");
-    BOOST_CHECK(counterWCounterSet->m_Units == "");
-    BOOST_CHECK(counterWCounterSet->m_DeviceUid == 0);
-    BOOST_CHECK(counterWCounterSet->m_CounterSetUid == counterSet->m_Uid);
-    BOOST_CHECK(category->m_Counters.size() == 27);
-    BOOST_CHECK(category->m_Counters.back() == counterWCounterSet->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 27);
+    CHECK(counterWCounterSet);
+    CHECK(counterWCounterSet->m_Uid > counter->m_Uid);
+    CHECK(counterWCounterSet->m_MaxCounterUid == counterWCounterSet->m_Uid);
+    CHECK(counterWCounterSet->m_Class == 0);
+    CHECK(counterWCounterSet->m_Interpolation == 1);
+    CHECK(counterWCounterSet->m_Multiplier == 123.45f);
+    CHECK(counterWCounterSet->m_Name == "valid name 11");
+    CHECK(counterWCounterSet->m_Description == "valid description");
+    CHECK(counterWCounterSet->m_Units == "");
+    CHECK(counterWCounterSet->m_DeviceUid == 0);
+    CHECK(counterWCounterSet->m_CounterSetUid == counterSet->m_Uid);
+    CHECK(category->m_Counters.size() == 27);
+    CHECK(category->m_Counters.back() == counterWCounterSet->m_Uid);
 
     // Register a counter with a valid parent category name and associated to a device and a counter set
     const Counter* counterWDeviceWCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterWDeviceWCounterSet = counterDirectory.RegisterCounter(
+    CHECK_NOTHROW(counterWDeviceWCounterSet = counterDirectory.RegisterCounter(
                              armnn::profiling::BACKEND_ID, 23,
                              categoryName, 0, 1, 123.45f, "valid name 12", "valid description",
                              armnn::EmptyOptional(),    // Units
                              1,                         // Number of cores
                              device->m_Uid,             // Device UID
                              counterSet->m_Uid));       // Counter set UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 28);
-    BOOST_CHECK(counterWDeviceWCounterSet);
-    BOOST_CHECK(counterWDeviceWCounterSet->m_Uid > counter->m_Uid);
-    BOOST_CHECK(counterWDeviceWCounterSet->m_MaxCounterUid == counterWDeviceWCounterSet->m_Uid);
-    BOOST_CHECK(counterWDeviceWCounterSet->m_Class == 0);
-    BOOST_CHECK(counterWDeviceWCounterSet->m_Interpolation == 1);
-    BOOST_CHECK(counterWDeviceWCounterSet->m_Multiplier == 123.45f);
-    BOOST_CHECK(counterWDeviceWCounterSet->m_Name == "valid name 12");
-    BOOST_CHECK(counterWDeviceWCounterSet->m_Description == "valid description");
-    BOOST_CHECK(counterWDeviceWCounterSet->m_Units == "");
-    BOOST_CHECK(counterWDeviceWCounterSet->m_DeviceUid == device->m_Uid);
-    BOOST_CHECK(counterWDeviceWCounterSet->m_CounterSetUid == counterSet->m_Uid);
-    BOOST_CHECK(category->m_Counters.size() == 28);
-    BOOST_CHECK(category->m_Counters.back() == counterWDeviceWCounterSet->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 28);
+    CHECK(counterWDeviceWCounterSet);
+    CHECK(counterWDeviceWCounterSet->m_Uid > counter->m_Uid);
+    CHECK(counterWDeviceWCounterSet->m_MaxCounterUid == counterWDeviceWCounterSet->m_Uid);
+    CHECK(counterWDeviceWCounterSet->m_Class == 0);
+    CHECK(counterWDeviceWCounterSet->m_Interpolation == 1);
+    CHECK(counterWDeviceWCounterSet->m_Multiplier == 123.45f);
+    CHECK(counterWDeviceWCounterSet->m_Name == "valid name 12");
+    CHECK(counterWDeviceWCounterSet->m_Description == "valid description");
+    CHECK(counterWDeviceWCounterSet->m_Units == "");
+    CHECK(counterWDeviceWCounterSet->m_DeviceUid == device->m_Uid);
+    CHECK(counterWDeviceWCounterSet->m_CounterSetUid == counterSet->m_Uid);
+    CHECK(category->m_Counters.size() == 28);
+    CHECK(category->m_Counters.back() == counterWDeviceWCounterSet->m_Uid);
 
     // Register another category for testing
     const std::string anotherCategoryName = "some_other_category";
     const Category* anotherCategory       = nullptr;
-    BOOST_CHECK_NO_THROW(anotherCategory = counterDirectory.RegisterCategory(anotherCategoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
-    BOOST_CHECK(anotherCategory);
-    BOOST_CHECK(anotherCategory != category);
-    BOOST_CHECK(anotherCategory->m_Name == anotherCategoryName);
-    BOOST_CHECK(anotherCategory->m_Counters.empty());
+    CHECK_NOTHROW(anotherCategory = counterDirectory.RegisterCategory(anotherCategoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 2);
+    CHECK(anotherCategory);
+    CHECK(anotherCategory != category);
+    CHECK(anotherCategory->m_Name == anotherCategoryName);
+    CHECK(anotherCategory->m_Counters.empty());
 
     // Register a counter to the other category
     const Counter* anotherCounter = nullptr;
-    BOOST_CHECK_NO_THROW(anotherCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID, 24,
+    CHECK_NOTHROW(anotherCounter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID, 24,
                                                                            anotherCategoryName, 1, 0, .00043f,
                                                                            "valid name", "valid description",
                                                                            armnn::EmptyOptional(), // Units
                                                                            armnn::EmptyOptional(), // Number of cores
                                                                            device->m_Uid,          // Device UID
                                                                            counterSet->m_Uid));    // Counter set UID
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 29);
-    BOOST_CHECK(anotherCounter);
-    BOOST_CHECK(anotherCounter->m_MaxCounterUid == anotherCounter->m_Uid);
-    BOOST_CHECK(anotherCounter->m_Class == 1);
-    BOOST_CHECK(anotherCounter->m_Interpolation == 0);
-    BOOST_CHECK(anotherCounter->m_Multiplier == .00043f);
-    BOOST_CHECK(anotherCounter->m_Name == "valid name");
-    BOOST_CHECK(anotherCounter->m_Description == "valid description");
-    BOOST_CHECK(anotherCounter->m_Units == "");
-    BOOST_CHECK(anotherCounter->m_DeviceUid == device->m_Uid);
-    BOOST_CHECK(anotherCounter->m_CounterSetUid == counterSet->m_Uid);
-    BOOST_CHECK(anotherCategory->m_Counters.size() == 1);
-    BOOST_CHECK(anotherCategory->m_Counters.back() == anotherCounter->m_Uid);
+    CHECK(counterDirectory.GetCounterCount() == 29);
+    CHECK(anotherCounter);
+    CHECK(anotherCounter->m_MaxCounterUid == anotherCounter->m_Uid);
+    CHECK(anotherCounter->m_Class == 1);
+    CHECK(anotherCounter->m_Interpolation == 0);
+    CHECK(anotherCounter->m_Multiplier == .00043f);
+    CHECK(anotherCounter->m_Name == "valid name");
+    CHECK(anotherCounter->m_Description == "valid description");
+    CHECK(anotherCounter->m_Units == "");
+    CHECK(anotherCounter->m_DeviceUid == device->m_Uid);
+    CHECK(anotherCounter->m_CounterSetUid == counterSet->m_Uid);
+    CHECK(anotherCategory->m_Counters.size() == 1);
+    CHECK(anotherCategory->m_Counters.back() == anotherCounter->m_Uid);
 }
 
-BOOST_AUTO_TEST_CASE(CounterSelectionCommandHandlerParseData)
+TEST_CASE("CounterSelectionCommandHandlerParseData")
 {
     ProfilingStateMachine profilingStateMachine;
 
@@ -1819,20 +1821,20 @@ BOOST_AUTO_TEST_CASE(CounterSelectionCommandHandlerParseData)
                                                           readCounterValues, sendCounterPacket, profilingStateMachine);
 
     profilingStateMachine.TransitionToState(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(commandHandler(packetA), armnn::RuntimeException);
+    CHECK_THROWS_AS(commandHandler(packetA), armnn::RuntimeException);
     profilingStateMachine.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(commandHandler(packetA), armnn::RuntimeException);
+    CHECK_THROWS_AS(commandHandler(packetA), armnn::RuntimeException);
     profilingStateMachine.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(commandHandler(packetA), armnn::RuntimeException);
+    CHECK_THROWS_AS(commandHandler(packetA), armnn::RuntimeException);
     profilingStateMachine.TransitionToState(ProfilingState::Active);
-    BOOST_CHECK_NO_THROW(commandHandler(packetA));
+    CHECK_NOTHROW(commandHandler(packetA));
 
     const std::vector<uint16_t> counterIdsA = holder.GetCaptureData().GetCounterIds();
 
-    BOOST_TEST(holder.GetCaptureData().GetCapturePeriod() == period1);
-    BOOST_TEST(counterIdsA.size() == 2);
-    BOOST_TEST(counterIdsA[0] == 4000);
-    BOOST_TEST(counterIdsA[1] == 5000);
+    CHECK(holder.GetCaptureData().GetCapturePeriod() == period1);
+    CHECK(counterIdsA.size() == 2);
+    CHECK(counterIdsA[0] == 4000);
+    CHECK(counterIdsA[1] == 5000);
 
     auto readBuffer = mockBuffer.GetReadableBuffer();
 
@@ -1844,18 +1846,18 @@ BOOST_AUTO_TEST_CASE(CounterSelectionCommandHandlerParseData)
     offset += sizeOfUint32;
     uint32_t period = ReadUint32(readBuffer, offset);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);             // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);            // packet id
-    BOOST_TEST(headerWord1 == 8);                              // data length
-    BOOST_TEST(period ==  armnn::LOWEST_CAPTURE_PERIOD);       // capture period
+    CHECK(((headerWord0 >> 26) & 0x3F) == 0);             // packet family
+    CHECK(((headerWord0 >> 16) & 0x3FF) == 4);            // packet id
+    CHECK(headerWord1 == 8);                              // data length
+    CHECK(period ==  armnn::LOWEST_CAPTURE_PERIOD);       // capture period
 
     uint16_t counterId = 0;
     offset += sizeOfUint32;
     counterId = ReadUint16(readBuffer, offset);
-    BOOST_TEST(counterId == 4000);
+    CHECK(counterId == 4000);
     offset += sizeOfUint16;
     counterId = ReadUint16(readBuffer, offset);
-    BOOST_TEST(counterId == 5000);
+    CHECK(counterId == 5000);
 
     mockBuffer.MarkRead(readBuffer);
 
@@ -1874,8 +1876,8 @@ BOOST_AUTO_TEST_CASE(CounterSelectionCommandHandlerParseData)
     const std::vector<uint16_t> counterIdsB = holder.GetCaptureData().GetCounterIds();
 
     // Value should have been pulled up from 9000 to LOWEST_CAPTURE_PERIOD.
-    BOOST_TEST(holder.GetCaptureData().GetCapturePeriod() ==  armnn::LOWEST_CAPTURE_PERIOD);
-    BOOST_TEST(counterIdsB.size() == 0);
+    CHECK(holder.GetCaptureData().GetCapturePeriod() ==  armnn::LOWEST_CAPTURE_PERIOD);
+    CHECK(counterIdsB.size() == 0);
 
     readBuffer = mockBuffer.GetReadableBuffer();
 
@@ -1887,13 +1889,13 @@ BOOST_AUTO_TEST_CASE(CounterSelectionCommandHandlerParseData)
     offset += sizeOfUint32;
     period = ReadUint32(readBuffer, offset);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);         // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);        // packet id
-    BOOST_TEST(headerWord1 == 4);                          // data length
-    BOOST_TEST(period == armnn::LOWEST_CAPTURE_PERIOD);    // capture period
+    CHECK(((headerWord0 >> 26) & 0x3F) == 0);         // packet family
+    CHECK(((headerWord0 >> 16) & 0x3FF) == 4);        // packet id
+    CHECK(headerWord1 == 4);                          // data length
+    CHECK(period == armnn::LOWEST_CAPTURE_PERIOD);    // capture period
 }
 
-BOOST_AUTO_TEST_CASE(CheckTimelineActivationAndDeactivation)
+TEST_CASE("CheckTimelineActivationAndDeactivation")
 {
     class TestReportStructure : public IReportStructure
     {
@@ -1946,23 +1948,23 @@ BOOST_AUTO_TEST_CASE(CheckTimelineActivationAndDeactivation)
     // Create the ActivateTimelineReportingPacket
     arm::pipe::Packet ActivateTimelineReportingPacket(packetHeader1); // Length == 0
 
-    BOOST_CHECK_THROW(
+    CHECK_THROWS_AS(
             activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket), armnn::Exception);
 
     stateMachine.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(
+    CHECK_THROWS_AS(
             activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket), armnn::Exception);
 
     stateMachine.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(
+    CHECK_THROWS_AS(
             activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket), armnn::Exception);
 
     stateMachine.TransitionToState(ProfilingState::Active);
     activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket);
 
-    BOOST_CHECK(testReportStructure.m_ReportStructureCalled);
-    BOOST_CHECK(testNotifyBackends.m_TestNotifyBackendsCalled);
-    BOOST_CHECK(testNotifyBackends.m_timelineReporting.load());
+    CHECK(testReportStructure.m_ReportStructureCalled);
+    CHECK(testNotifyBackends.m_TestNotifyBackendsCalled);
+    CHECK(testNotifyBackends.m_timelineReporting.load());
 
     DeactivateTimelineReportingCommandHandler deactivateTimelineReportingCommandHandler(0,
                                                   7,
@@ -1979,25 +1981,25 @@ BOOST_AUTO_TEST_CASE(CheckTimelineActivationAndDeactivation)
     arm::pipe::Packet deactivateTimelineReportingPacket(packetHeader2); // Length == 0
 
     stateMachine.Reset();
-    BOOST_CHECK_THROW(
+    CHECK_THROWS_AS(
             deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket), armnn::Exception);
 
     stateMachine.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(
+    CHECK_THROWS_AS(
             deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket), armnn::Exception);
 
     stateMachine.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(
+    CHECK_THROWS_AS(
             deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket), armnn::Exception);
 
     stateMachine.TransitionToState(ProfilingState::Active);
     deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket);
 
-    BOOST_CHECK(!testNotifyBackends.m_TestNotifyBackendsCalled);
-    BOOST_CHECK(!testNotifyBackends.m_timelineReporting.load());
+    CHECK(!testNotifyBackends.m_TestNotifyBackendsCalled);
+    CHECK(!testNotifyBackends.m_timelineReporting.load());
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceNotActive)
+TEST_CASE("CheckProfilingServiceNotActive")
 {
     using namespace armnn;
     using namespace armnn::profiling;
@@ -2016,10 +2018,10 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceNotActive)
     auto readableBuffer = bufferManager.GetReadableBuffer();
 
     // Profiling is enabled, the post-optimisation structure should be created
-    BOOST_CHECK(readableBuffer == nullptr);
+    CHECK(readableBuffer == nullptr);
 }
 
-BOOST_AUTO_TEST_CASE(CheckConnectionAcknowledged)
+TEST_CASE("CheckConnectionAcknowledged")
 {
     const uint32_t packetFamilyId     = 0;
     const uint32_t connectionPacketId = 0x10000;
@@ -2045,7 +2047,7 @@ BOOST_AUTO_TEST_CASE(CheckConnectionAcknowledged)
     arm::pipe::Packet packetA(connectionPacketId, dataLength1, uniqueData1);
 
     ProfilingStateMachine profilingState(ProfilingState::Uninitialised);
-    BOOST_CHECK(profilingState.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingState.GetCurrentState() == ProfilingState::Uninitialised);
     CounterDirectory counterDirectory;
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(mockBuffer);
@@ -2063,22 +2065,22 @@ BOOST_AUTO_TEST_CASE(CheckConnectionAcknowledged)
                                                         mockProfilingServiceStatus);
 
     // command handler received packet on ProfilingState::Uninitialised
-    BOOST_CHECK_THROW(commandHandler(packetA), armnn::Exception);
+    CHECK_THROWS_AS(commandHandler(packetA), armnn::Exception);
 
     profilingState.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK(profilingState.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingState.GetCurrentState() == ProfilingState::NotConnected);
     // command handler received packet on ProfilingState::NotConnected
-    BOOST_CHECK_THROW(commandHandler(packetA), armnn::Exception);
+    CHECK_THROWS_AS(commandHandler(packetA), armnn::Exception);
 
     profilingState.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK(profilingState.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingState.GetCurrentState() == ProfilingState::WaitingForAck);
     // command handler received packet on ProfilingState::WaitingForAck
-    BOOST_CHECK_NO_THROW(commandHandler(packetA));
-    BOOST_CHECK(profilingState.GetCurrentState() == ProfilingState::Active);
+    CHECK_NOTHROW(commandHandler(packetA));
+    CHECK(profilingState.GetCurrentState() == ProfilingState::Active);
 
     // command handler received packet on ProfilingState::Active
-    BOOST_CHECK_NO_THROW(commandHandler(packetA));
-    BOOST_CHECK(profilingState.GetCurrentState() == ProfilingState::Active);
+    CHECK_NOTHROW(commandHandler(packetA));
+    CHECK(profilingState.GetCurrentState() == ProfilingState::Active);
 
     // command handler received different packet
     const uint32_t differentPacketId = 0x40000;
@@ -2093,16 +2095,16 @@ BOOST_AUTO_TEST_CASE(CheckConnectionAcknowledged)
                                                                  sendTimelinePacket,
                                                                  profilingState,
                                                                  mockProfilingServiceStatus);
-    BOOST_CHECK_THROW(differentCommandHandler(packetB), armnn::Exception);
+    CHECK_THROWS_AS(differentCommandHandler(packetB), armnn::Exception);
 }
 
-BOOST_AUTO_TEST_CASE(CheckSocketConnectionException)
+TEST_CASE("CheckSocketConnectionException")
 {
     // Check that creating a SocketProfilingConnection armnnProfiling in an exception as the Gator UDS doesn't exist.
-    BOOST_CHECK_THROW(new SocketProfilingConnection(), arm::pipe::SocketConnectionException);
+    CHECK_THROWS_AS(new SocketProfilingConnection(), arm::pipe::SocketConnectionException);
 }
 
-BOOST_AUTO_TEST_CASE(CheckSocketConnectionException2)
+TEST_CASE("CheckSocketConnectionException2")
 {
     try
     {
@@ -2110,128 +2112,128 @@ BOOST_AUTO_TEST_CASE(CheckSocketConnectionException2)
     }
     catch (const arm::pipe::SocketConnectionException& ex)
     {
-        BOOST_CHECK(ex.GetSocketFd() == 0);
-        BOOST_CHECK(ex.GetErrorNo() == ECONNREFUSED);
-        BOOST_CHECK(ex.what()
+        CHECK(ex.GetSocketFd() == 0);
+        CHECK(ex.GetErrorNo() == ECONNREFUSED);
+        CHECK(ex.what()
                     == std::string("SocketProfilingConnection: Cannot connect to stream socket: Connection refused"));
     }
 }
 
-BOOST_AUTO_TEST_CASE(SwTraceIsValidCharTest)
+TEST_CASE("SwTraceIsValidCharTest")
 {
     // Only ASCII 7-bit encoding supported
     for (unsigned char c = 0; c < 128; c++)
     {
-        BOOST_CHECK(arm::pipe::SwTraceCharPolicy::IsValidChar(c));
+        CHECK(arm::pipe::SwTraceCharPolicy::IsValidChar(c));
     }
 
     // Not ASCII
     for (unsigned char c = 255; c >= 128; c++)
     {
-        BOOST_CHECK(!arm::pipe::SwTraceCharPolicy::IsValidChar(c));
+        CHECK(!arm::pipe::SwTraceCharPolicy::IsValidChar(c));
     }
 }
 
-BOOST_AUTO_TEST_CASE(SwTraceIsValidNameCharTest)
+TEST_CASE("SwTraceIsValidNameCharTest")
 {
     // Only alpha-numeric and underscore ASCII 7-bit encoding supported
     const unsigned char validChars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
     for (unsigned char i = 0; i < sizeof(validChars) / sizeof(validChars[0]) - 1; i++)
     {
-        BOOST_CHECK(arm::pipe::SwTraceNameCharPolicy::IsValidChar(validChars[i]));
+        CHECK(arm::pipe::SwTraceNameCharPolicy::IsValidChar(validChars[i]));
     }
 
     // Non alpha-numeric chars
     for (unsigned char c = 0; c < 48; c++)
     {
-        BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
+        CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
     }
     for (unsigned char c = 58; c < 65; c++)
     {
-        BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
+        CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
     }
     for (unsigned char c = 91; c < 95; c++)
     {
-        BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
+        CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
     }
     for (unsigned char c = 96; c < 97; c++)
     {
-        BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
+        CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
     }
     for (unsigned char c = 123; c < 128; c++)
     {
-        BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
+        CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
     }
 
     // Not ASCII
     for (unsigned char c = 255; c >= 128; c++)
     {
-        BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
+        CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
     }
 }
 
-BOOST_AUTO_TEST_CASE(IsValidSwTraceStringTest)
+TEST_CASE("IsValidSwTraceStringTest")
 {
     // Valid SWTrace strings
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(""));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("_"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("0123"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("valid_string"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("VALID_string_456"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(" "));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("valid string"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("!$%"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("valid|\\~string#123"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(""));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("_"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("0123"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("valid_string"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("VALID_string_456"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(" "));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("valid string"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("!$%"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("valid|\\~string#123"));
 
     // Invalid SWTrace strings
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("€£"));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("invalid‡string"));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("12Ž34"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("€£"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("invalid‡string"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>("12Ž34"));
 }
 
-BOOST_AUTO_TEST_CASE(IsValidSwTraceNameStringTest)
+TEST_CASE("IsValidSwTraceNameStringTest")
 {
     // Valid SWTrace name strings
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(""));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("_"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("0123"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("valid_string"));
-    BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("VALID_string_456"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(""));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("_"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("0123"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("valid_string"));
+    CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("VALID_string_456"));
 
     // Invalid SWTrace name strings
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(" "));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid string"));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("!$%"));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid|\\~string#123"));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("€£"));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid‡string"));
-    BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("12Ž34"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(" "));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid string"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("!$%"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid|\\~string#123"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("€£"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid‡string"));
+    CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>("12Ž34"));
 }
 
 template <typename SwTracePolicy>
 void StringToSwTraceStringTestHelper(const std::string& testString, std::vector<uint32_t> buffer, size_t expectedSize)
 {
     // Convert the test string to a SWTrace string
-    BOOST_CHECK(arm::pipe::StringToSwTraceString<SwTracePolicy>(testString, buffer));
+    CHECK(arm::pipe::StringToSwTraceString<SwTracePolicy>(testString, buffer));
 
     // The buffer must contain at least the length of the string
-    BOOST_CHECK(!buffer.empty());
+    CHECK(!buffer.empty());
 
     // The buffer must be of the expected size (in words)
-    BOOST_CHECK(buffer.size() == expectedSize);
+    CHECK(buffer.size() == expectedSize);
 
     // The first word of the byte must be the length of the string including the null-terminator
-    BOOST_CHECK(buffer[0] == testString.size() + 1);
+    CHECK(buffer[0] == testString.size() + 1);
 
     // The contents of the buffer must match the test string
-    BOOST_CHECK(std::memcmp(testString.data(), buffer.data() + 1, testString.size()) == 0);
+    CHECK(std::memcmp(testString.data(), buffer.data() + 1, testString.size()) == 0);
 
     // The buffer must include the null-terminator at the end of the string
     size_t nullTerminatorIndex = sizeof(uint32_t) + testString.size();
-    BOOST_CHECK(reinterpret_cast<unsigned char*>(buffer.data())[nullTerminatorIndex] == '\0');
+    CHECK(reinterpret_cast<unsigned char*>(buffer.data())[nullTerminatorIndex] == '\0');
 }
 
-BOOST_AUTO_TEST_CASE(StringToSwTraceStringTest)
+TEST_CASE("StringToSwTraceStringTest")
 {
     std::vector<uint32_t> buffer;
 
@@ -2247,15 +2249,15 @@ BOOST_AUTO_TEST_CASE(StringToSwTraceStringTest)
     StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>("valid|\\~string#123", buffer, 6);
 
     // Invalid SWTrace strings
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>("€£", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>("invalid‡string", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>("12Ž34", buffer));
-    BOOST_CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>("€£", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>("invalid‡string", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>("12Ž34", buffer));
+    CHECK(buffer.empty());
 }
 
-BOOST_AUTO_TEST_CASE(StringToSwTraceNameStringTest)
+TEST_CASE("StringToSwTraceNameStringTest")
 {
     std::vector<uint32_t> buffer;
 
@@ -2267,23 +2269,23 @@ BOOST_AUTO_TEST_CASE(StringToSwTraceNameStringTest)
     StringToSwTraceStringTestHelper<arm::pipe::SwTraceNameCharPolicy>("VALID_string_456", buffer, 6);
 
     // Invalid SWTrace namestrings
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(" ", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid string", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("!$%", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid|\\~string#123", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("€£", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid‡string", buffer));
-    BOOST_CHECK(buffer.empty());
-    BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("12Ž34", buffer));
-    BOOST_CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(" ", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid string", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("!$%", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid|\\~string#123", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("€£", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("invalid‡string", buffer));
+    CHECK(buffer.empty());
+    CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>("12Ž34", buffer));
+    CHECK(buffer.empty());
 }
 
-BOOST_AUTO_TEST_CASE(CheckPeriodicCounterCaptureThread)
+TEST_CASE("CheckPeriodicCounterCaptureThread")
 {
     class CaptureReader : public IReadCounterValues
     {
@@ -2312,7 +2314,7 @@ BOOST_AUTO_TEST_CASE(CheckPeriodicCounterCaptureThread)
         {
             if (counterUid > m_CounterSize)
             {
-                BOOST_FAIL("Invalid counter Uid");
+                FAIL("Invalid counter Uid");
             }
             return m_Data.at(counterUid).load();
         }
@@ -2321,7 +2323,7 @@ BOOST_AUTO_TEST_CASE(CheckPeriodicCounterCaptureThread)
         {
             if (counterUid > m_CounterSize)
             {
-                BOOST_FAIL("Invalid counter Uid");
+                FAIL("Invalid counter Uid");
             }
             return m_Data.at(counterUid).load();
         }
@@ -2330,7 +2332,7 @@ BOOST_AUTO_TEST_CASE(CheckPeriodicCounterCaptureThread)
         {
             if (counterUid > m_CounterSize)
             {
-                BOOST_FAIL("Invalid counter Uid");
+                FAIL("Invalid counter Uid");
             }
             m_Data.at(counterUid).store(value);
         }
@@ -2378,29 +2380,29 @@ BOOST_AUTO_TEST_CASE(CheckPeriodicCounterCaptureThread)
     uint32_t headerWord0 = ReadUint32(buffer, 0);
     uint32_t headerWord1 = ReadUint32(buffer, 4);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3);    // packet family
-    BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0);    // packet class
-    BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0);    // packet type
-    BOOST_TEST(headerWord1 == 20);
+    CHECK(((headerWord0 >> 26) & 0x0000003F) == 3);    // packet family
+    CHECK(((headerWord0 >> 19) & 0x0000007F) == 0);    // packet class
+    CHECK(((headerWord0 >> 16) & 0x00000007) == 0);    // packet type
+    CHECK(headerWord1 == 20);
 
     uint32_t offset    = 16;
     uint16_t readIndex = ReadUint16(buffer, offset);
-    BOOST_TEST(0 == readIndex);
+    CHECK(0 == readIndex);
 
     offset += 2;
     uint32_t readValue = ReadUint32(buffer, offset);
-    BOOST_TEST((valueA * numSteps) == readValue);
+    CHECK((valueA * numSteps) == readValue);
 
     offset += 4;
     readIndex = ReadUint16(buffer, offset);
-    BOOST_TEST(1 == readIndex);
+    CHECK(1 == readIndex);
 
     offset += 2;
     readValue = ReadUint32(buffer, offset);
-    BOOST_TEST((valueB * numSteps) == readValue);
+    CHECK((valueB * numSteps) == readValue);
 }
 
-BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest1)
+TEST_CASE("RequestCounterDirectoryCommandHandlerTest1")
 {
     const uint32_t familyId = 0;
     const uint32_t packetId = 3;
@@ -2421,19 +2423,19 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest1)
     arm::pipe::Packet wrongPacket(wrongHeader);
 
     profilingStateMachine.TransitionToState(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
+    CHECK_THROWS_AS(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
+    CHECK_THROWS_AS(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
+    CHECK_THROWS_AS(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::Active);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::InvalidArgumentException); // Wrong packet
+    CHECK_THROWS_AS(commandHandler(wrongPacket), armnn::InvalidArgumentException); // Wrong packet
 
     const uint32_t rightHeader = (packetId & 0x000003FF) << 16;
 
     arm::pipe::Packet rightPacket(rightHeader);
 
-    BOOST_CHECK_NO_THROW(commandHandler(rightPacket)); // Right packet
+    CHECK_NOTHROW(commandHandler(rightPacket)); // Right packet
 
     auto readBuffer1 = mockBuffer1.GetReadableBuffer();
 
@@ -2441,13 +2443,13 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest1)
     uint32_t header1Word1 = ReadUint32(readBuffer1, 4);
 
     // Counter directory packet
-    BOOST_TEST(((header1Word0 >> 26) & 0x0000003F) == 0); // packet family
-    BOOST_TEST(((header1Word0 >> 16) & 0x000003FF) == 2); // packet id
-    BOOST_TEST(header1Word1 == 24);                       // data length
+    CHECK(((header1Word0 >> 26) & 0x0000003F) == 0); // packet family
+    CHECK(((header1Word0 >> 16) & 0x000003FF) == 2); // packet id
+    CHECK(header1Word1 == 24);                       // data length
 
     uint32_t bodyHeader1Word0   = ReadUint32(readBuffer1, 8);
     uint16_t deviceRecordCount = armnn::numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
-    BOOST_TEST(deviceRecordCount == 0); // device_records_count
+    CHECK(deviceRecordCount == 0); // device_records_count
 
     auto readBuffer2 = mockBuffer2.GetReadableBuffer();
 
@@ -2455,12 +2457,12 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest1)
     uint32_t header2Word1 = ReadUint32(readBuffer2, 4);
 
     // Timeline message directory packet
-    BOOST_TEST(((header2Word0 >> 26) & 0x0000003F) == 1); // packet family
-    BOOST_TEST(((header2Word0 >> 16) & 0x000003FF) == 0); // packet id
-    BOOST_TEST(header2Word1 == 443);                      // data length
+    CHECK(((header2Word0 >> 26) & 0x0000003F) == 1); // packet family
+    CHECK(((header2Word0 >> 16) & 0x000003FF) == 0); // packet id
+    CHECK(header2Word1 == 443);                      // data length
 }
 
-BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest2)
+TEST_CASE("RequestCounterDirectoryCommandHandlerTest2")
 {
     const uint32_t familyId = 0;
     const uint32_t packetId = 3;
@@ -2478,9 +2480,9 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest2)
     const arm::pipe::Packet packet(header);
 
     const Device* device = counterDirectory.RegisterDevice("deviceA", 1);
-    BOOST_CHECK(device != nullptr);
+    CHECK(device != nullptr);
     const CounterSet* counterSet = counterDirectory.RegisterCounterSet("countersetA");
-    BOOST_CHECK(counterSet != nullptr);
+    CHECK(counterSet != nullptr);
     counterDirectory.RegisterCategory("categoryA");
     counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID, 24,
                                      "categoryA", 0, 1, 2.0f, "counterA", "descA");
@@ -2488,22 +2490,22 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest2)
                                      "categoryA", 1, 1, 3.0f, "counterB", "descB");
 
     profilingStateMachine.TransitionToState(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
+    CHECK_THROWS_AS(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
+    CHECK_THROWS_AS(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
+    CHECK_THROWS_AS(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::Active);
-    BOOST_CHECK_NO_THROW(commandHandler(packet));
+    CHECK_NOTHROW(commandHandler(packet));
 
     auto readBuffer1 = mockBuffer1.GetReadableBuffer();
 
     const uint32_t header1Word0 = ReadUint32(readBuffer1, 0);
     const uint32_t header1Word1 = ReadUint32(readBuffer1, 4);
 
-    BOOST_TEST(((header1Word0 >> 26) & 0x0000003F) == 0); // packet family
-    BOOST_TEST(((header1Word0 >> 16) & 0x000003FF) == 2); // packet id
-    BOOST_TEST(header1Word1 == 236);                      // data length
+    CHECK(((header1Word0 >> 26) & 0x0000003F) == 0); // packet family
+    CHECK(((header1Word0 >> 16) & 0x000003FF) == 2); // packet id
+    CHECK(header1Word1 == 236);                      // data length
 
     const uint32_t bodyHeaderSizeBytes = bodyHeaderSize * sizeof(uint32_t);
 
@@ -2516,21 +2518,21 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest2)
     const uint16_t deviceRecordCount     = armnn::numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
     const uint16_t counterSetRecordCount = armnn::numeric_cast<uint16_t>(bodyHeader1Word2 >> 16);
     const uint16_t categoryRecordCount   = armnn::numeric_cast<uint16_t>(bodyHeader1Word4 >> 16);
-    BOOST_TEST(deviceRecordCount == 1);                      // device_records_count
-    BOOST_TEST(bodyHeader1Word1 == 0 + bodyHeaderSizeBytes);      // device_records_pointer_table_offset
-    BOOST_TEST(counterSetRecordCount == 1);                  // counter_set_count
-    BOOST_TEST(bodyHeader1Word3 == 4 + bodyHeaderSizeBytes);      // counter_set_pointer_table_offset
-    BOOST_TEST(categoryRecordCount == 1);                    // categories_count
-    BOOST_TEST(bodyHeader1Word5 == 8 + bodyHeaderSizeBytes);      // categories_pointer_table_offset
+    CHECK(deviceRecordCount == 1);                      // device_records_count
+    CHECK(bodyHeader1Word1 == 0 + bodyHeaderSizeBytes);      // device_records_pointer_table_offset
+    CHECK(counterSetRecordCount == 1);                  // counter_set_count
+    CHECK(bodyHeader1Word3 == 4 + bodyHeaderSizeBytes);      // counter_set_pointer_table_offset
+    CHECK(categoryRecordCount == 1);                    // categories_count
+    CHECK(bodyHeader1Word5 == 8 + bodyHeaderSizeBytes);      // categories_pointer_table_offset
 
     const uint32_t deviceRecordOffset = ReadUint32(readBuffer1, 32);
-    BOOST_TEST(deviceRecordOffset == 12);
+    CHECK(deviceRecordOffset == 12);
 
     const uint32_t counterSetRecordOffset = ReadUint32(readBuffer1, 36);
-    BOOST_TEST(counterSetRecordOffset == 28);
+    CHECK(counterSetRecordOffset == 28);
 
     const uint32_t categoryRecordOffset = ReadUint32(readBuffer1, 40);
-    BOOST_TEST(categoryRecordOffset == 48);
+    CHECK(categoryRecordOffset == 48);
 
     auto readBuffer2 = mockBuffer2.GetReadableBuffer();
 
@@ -2538,12 +2540,12 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest2)
     const uint32_t header2Word1 = ReadUint32(readBuffer2, 4);
 
     // Timeline message directory packet
-    BOOST_TEST(((header2Word0 >> 26) & 0x0000003F) == 1); // packet family
-    BOOST_TEST(((header2Word0 >> 16) & 0x000003FF) == 0); // packet id
-    BOOST_TEST(header2Word1 == 443);                      // data length
+    CHECK(((header2Word0 >> 26) & 0x0000003F) == 1); // packet family
+    CHECK(((header2Word0 >> 16) & 0x000003FF) == 0); // packet id
+    CHECK(header2Word1 == 443);                      // data length
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodConnectionAcknowledgedPacket)
+TEST_CASE("CheckProfilingServiceGoodConnectionAcknowledgedPacket")
 {
     unsigned int streamMetadataPacketsize = GetStreamMetaDataPacketSize();
 
@@ -2557,23 +2559,23 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodConnectionAcknowledgedPacket)
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "WaitingForAck" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Remove the packets received so far
     mockProfilingConnection->Clear();
 
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet to be sent
-    BOOST_CHECK(helper.WaitForPacketsSent(
+    CHECK(helper.WaitForPacketsSent(
             mockProfilingConnection, PacketType::StreamMetaData, streamMetadataPacketsize) >= 1);
 
     // Write a valid "Connection Acknowledged" packet into the mock profiling connection, to simulate a valid
@@ -2595,17 +2597,17 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodConnectionAcknowledgedPacket)
     mockProfilingConnection->WritePacket(std::move(connectionAcknowledgedPacket));
 
     // Wait for the counter directory packet to ensure the ConnectionAcknowledgedCommandHandler has run.
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory) == 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory) == 1);
 
     // The Connection Acknowledged Command Handler should have updated the profiling state accordingly
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodRequestCounterDirectoryPacket)
+TEST_CASE("CheckProfilingServiceGoodRequestCounterDirectoryPacket")
 {
     // Reset the profiling service to the uninitialized state
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
@@ -2617,20 +2619,20 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodRequestCounterDirectoryPacket)
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Force the profiling service to the "Active" state
     helper.ForceTransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Write a valid "Request Counter Directory" packet into the mock profiling connection, to simulate a valid
     // reply from an external profiling service
@@ -2652,18 +2654,18 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodRequestCounterDirectoryPacket)
 
     // Expecting one CounterDirectory Packet of length 652
     // and one TimelineMessageDirectory packet of length 451
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory, 652) == 1);
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::TimelineMessageDirectory, 451) == 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory, 652) == 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::TimelineMessageDirectory, 451) == 1);
 
     // The Request Counter Directory Command Handler should not have updated the profiling state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadPeriodicCounterSelectionPacketInvalidCounterUid)
+TEST_CASE("CheckProfilingServiceBadPeriodicCounterSelectionPacketInvalidCounterUid")
 {
     // Reset the profiling service to the uninitialized state
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
@@ -2675,20 +2677,20 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadPeriodicCounterSelectionPacketInval
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Force the profiling service to the "Active" state
     helper.ForceTransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Remove the packets received so far
     mockProfilingConnection->Clear();
@@ -2710,7 +2712,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadPeriodicCounterSelectionPacketInval
     // Get the first valid counter UID
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
     const Counters& counters                  = counterDirectory.GetCounters();
-    BOOST_CHECK(counters.size() > 1);
+    CHECK(counters.size() > 1);
     uint16_t counterUidA = counters.begin()->first;    // First valid counter UID
     uint16_t counterUidB = 9999;                       // Second invalid counter UID
 
@@ -2731,18 +2733,18 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadPeriodicCounterSelectionPacketInval
 
     // Expecting one Periodic Counter Selection packet of length 14
     // and at least one Periodic Counter Capture packet of length 22
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 14) == 1);
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 22) >= 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 14) == 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 22) >= 1);
 
     // The Periodic Counter Selection Handler should not have updated the profiling state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketNoCounters)
+TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketNoCounters")
 {
     // Reset the profiling service to the uninitialized state
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
@@ -2754,16 +2756,16 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketNoCo
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2771,7 +2773,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketNoCo
 
     // Force the profiling service to the "Active" state
     helper.ForceTransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Write a "Periodic Counter Selection" packet into the mock profiling connection, to simulate an input from an
     // external profiling service
@@ -2794,20 +2796,20 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketNoCo
 
     // Wait for the Periodic Counter Selection packet of length 12 to be sent
     // The size of the expected Periodic Counter Selection (echos the sent one)
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 12) == 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 12) == 1);
 
     // The Periodic Counter Selection Handler should not have updated the profiling state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // No Periodic Counter packets are expected
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 0, 0) == 0);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 0, 0) == 0);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketSingleCounter)
+TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketSingleCounter")
 {
     // Reset the profiling service to the uninitialized state
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
@@ -2819,16 +2821,16 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketSing
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Wait for the Stream Metadata packet to be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2836,7 +2838,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketSing
 
     // Force the profiling service to the "Active" state
     helper.ForceTransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Write a "Periodic Counter Selection" packet into the mock profiling connection, to simulate an input from an
     // external profiling service
@@ -2855,7 +2857,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketSing
     // Get the first valid counter UID
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
     const Counters& counters                  = counterDirectory.GetCounters();
-    BOOST_CHECK(!counters.empty());
+    CHECK(!counters.empty());
     uint16_t counterUid = counters.begin()->first;    // Valid counter UID
 
     uint32_t length = 6;
@@ -2873,18 +2875,18 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketSing
 
     // Expecting one Periodic Counter Selection packet of length 14
     // and at least one Periodic Counter Capture packet of length 22
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 14) == 1);
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 22) >= 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 14) == 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 22) >= 1);
 
     // The Periodic Counter Selection Handler should not have updated the profiling state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketMultipleCounters)
+TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketMultipleCounters")
 {
     // Reset the profiling service to the uninitialized state
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
@@ -2896,16 +2898,16 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketMult
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2913,7 +2915,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketMult
 
     // Force the profiling service to the "Active" state
     helper.ForceTransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Write a "Periodic Counter Selection" packet into the mock profiling connection, to simulate an input from an
     // external profiling service
@@ -2932,7 +2934,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketMult
     // Get the first valid counter UID
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
     const Counters& counters                  = counterDirectory.GetCounters();
-    BOOST_CHECK(counters.size() > 1);
+    CHECK(counters.size() > 1);
     uint16_t counterUidA = counters.begin()->first;        // First valid counter UID
     uint16_t counterUidB = (counters.begin()++)->first;    // Second valid counter UID
 
@@ -2952,18 +2954,18 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPeriodicCounterSelectionPacketMult
 
     // Expecting one PeriodicCounterSelection Packet with a length of 16
     // And at least one PeriodicCounterCapture Packet with a length of 28
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 16) == 1);
-    BOOST_CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 28) >= 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 16) == 1);
+    CHECK(helper.WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 28) >= 1);
 
     // The Periodic Counter Selection Handler should not have updated the profiling state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceDisconnect)
+TEST_CASE("CheckProfilingServiceDisconnect")
 {
     // Reset the profiling service to the uninitialized state
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
@@ -2975,28 +2977,28 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceDisconnect)
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Try to disconnect the profiling service while in the "Uninitialised" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);    // The state should not change
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);    // The state should not change
 
     // Try to disconnect the profiling service while in the "NotConnected" state
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);    // The state should not change
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);    // The state should not change
 
     // Try to disconnect the profiling service while in the "WaitingForAck" state
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);    // The state should not change
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);    // The state should not change
 
     // Try to disconnect the profiling service while in the "Active" state
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -3004,24 +3006,24 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceDisconnect)
 
     // Force the profiling service to the "Active" state
     helper.ForceTransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Check that the profiling connection is open
-    BOOST_CHECK(mockProfilingConnection->IsOpen());
+    CHECK(mockProfilingConnection->IsOpen());
 
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);   // The state should have changed
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);   // The state should have changed
 
     // Check that the profiling connection has been reset
     mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection == nullptr);
+    CHECK(mockProfilingConnection == nullptr);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPerJobCounterSelectionPacket)
+TEST_CASE("CheckProfilingServiceGoodPerJobCounterSelectionPacket")
 {
     // Reset the profiling service to the uninitialized state
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
@@ -3033,16 +3035,16 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPerJobCounterSelectionPacket)
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -3050,7 +3052,7 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPerJobCounterSelectionPacket)
 
     // Force the profiling service to the "Active" state
     helper.ForceTransitionToState(ProfilingState::Active);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // Write a "Per-Job Counter Selection" packet into the mock profiling connection, to simulate an input from an
     // external profiling service
@@ -3076,47 +3078,47 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceGoodPerJobCounterSelectionPacket)
     std::this_thread::sleep_for(std::chrono::milliseconds(5));
 
     // The Per-Job Counter Selection Command Handler should not have updated the profiling state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
 
     // The Per-Job Counter Selection packets are dropped silently, so there should be no reply coming
     // from the profiling service
     const auto StreamMetaDataSize = static_cast<unsigned long>(
             helper.WaitForPacketsSent(mockProfilingConnection, PacketType::StreamMetaData, 0, 0));
-    BOOST_CHECK(StreamMetaDataSize == mockProfilingConnection->GetWrittenDataSize());
+    CHECK(StreamMetaDataSize == mockProfilingConnection->GetWrittenDataSize());
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckConfigureProfilingServiceOn)
+TEST_CASE("CheckConfigureProfilingServiceOn")
 {
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.ConfigureProfilingService(options);
     // should get as far as NOT_CONNECTED
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckConfigureProfilingServiceOff)
+TEST_CASE("CheckConfigureProfilingServiceOff")
 {
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.ConfigureProfilingService(options);
     // should not move from Uninitialised
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceEnabled)
+TEST_CASE("CheckProfilingServiceEnabled")
 {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
@@ -3124,9 +3126,9 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceEnabled)
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
 
     // Redirect the output to a local stream so that we can parse the warning message
     std::stringstream ss;
@@ -3143,25 +3145,25 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceEnabled)
     if (ss.str().find("Cannot connect to stream socket: Connection refused") == std::string::npos)
     {
         std::cout << ss.str();
-        BOOST_FAIL("Expected string not found.");
+        FAIL("Expected string not found.");
     }
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceEnabledRuntime)
+TEST_CASE("CheckProfilingServiceEnabledRuntime")
 {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     options.m_EnableProfiling = true;
     profilingService.ResetExternalProfilingOptions(options);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
 
     // Redirect the output to a local stream so that we can parse the warning message
     std::stringstream ss;
@@ -3178,11 +3180,11 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceEnabledRuntime)
     if (ss.str().find("Cannot connect to stream socket: Connection refused") == std::string::npos)
     {
         std::cout << ss.str();
-        BOOST_FAIL("Expected string not found.");
+        FAIL("Expected string not found.");
     }
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadConnectionAcknowledgedPacket)
+TEST_CASE("CheckProfilingServiceBadConnectionAcknowledgedPacket")
 {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
@@ -3202,16 +3204,16 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadConnectionAcknowledgedPacket)
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "WaitingForAck" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
 
     // Connection Acknowledged Packet header (word 0, word 1 is always zero):
     // 26:31 [6]  packet_family: Control Packet Family, value 0b000000
@@ -3241,11 +3243,11 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadConnectionAcknowledgedPacket)
     if (ss.str().find("Functor with requested PacketId=37 and Version=4194304 does not exist") == std::string::npos)
     {
         std::cout << ss.str();
-        BOOST_FAIL("Expected string not found.");
+        FAIL("Expected string not found.");
     }
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadRequestCounterDirectoryPacket)
+TEST_CASE("CheckProfilingServiceBadRequestCounterDirectoryPacket")
 {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
@@ -3264,15 +3266,15 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadRequestCounterDirectoryPacket)
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     helper.ForceTransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Write a valid "Request Counter Directory" packet into the mock profiling connection, to simulate a valid
     // reply from an external profiling service
@@ -3305,11 +3307,11 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadRequestCounterDirectoryPacket)
     if (ss.str().find("Functor with requested PacketId=123 and Version=4194304 does not exist") == std::string::npos)
     {
         std::cout << ss.str();
-        BOOST_FAIL("Expected string not found.");
+        FAIL("Expected string not found.");
     }
 }
 
-BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadPeriodicCounterSelectionPacket)
+TEST_CASE("CheckProfilingServiceBadPeriodicCounterSelectionPacket")
 {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
@@ -3328,16 +3330,16 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadPeriodicCounterSelectionPacket)
     SwapProfilingConnectionFactoryHelper helper(profilingService);
 
     // Bring the profiling service to the "Active" state
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Update();    // Initialize the counter directory
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Update();    // Create the profiling connection
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
+    CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Update();    // Start the command handler and the send thread
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
-    BOOST_CHECK(mockProfilingConnection);
+    CHECK(mockProfilingConnection);
 
     // Write a "Periodic Counter Selection" packet into the mock profiling connection, to simulate an input from an
     // external profiling service
@@ -3370,15 +3372,15 @@ BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadPeriodicCounterSelectionPacket)
     if (ss.str().find("Functor with requested PacketId=999 and Version=4194304 does not exist") == std::string::npos)
     {
         std::cout << ss.str();
-        BOOST_FAIL("Expected string not found.");
+        FAIL("Expected string not found.");
     }
 }
 
-BOOST_AUTO_TEST_CASE(CheckCounterIdMap)
+TEST_CASE("CheckCounterIdMap")
 {
     CounterIdMap counterIdMap;
-    BOOST_CHECK_THROW(counterIdMap.GetBackendId(0), armnn::Exception);
-    BOOST_CHECK_THROW(counterIdMap.GetGlobalId(0, armnn::profiling::BACKEND_ID), armnn::Exception);
+    CHECK_THROWS_AS(counterIdMap.GetBackendId(0), armnn::Exception);
+    CHECK_THROWS_AS(counterIdMap.GetGlobalId(0, armnn::profiling::BACKEND_ID), armnn::Exception);
 
     uint16_t globalCounterIds = 0;
 
@@ -3399,22 +3401,22 @@ BOOST_AUTO_TEST_CASE(CheckCounterIdMap)
         ++globalCounterIds;
     }
 
-    BOOST_CHECK(counterIdMap.GetBackendId(0) == (std::pair<uint16_t, armnn::BackendId>(0, cpuRefId)));
-    BOOST_CHECK(counterIdMap.GetBackendId(1) == (std::pair<uint16_t, armnn::BackendId>(1, cpuRefId)));
-    BOOST_CHECK(counterIdMap.GetBackendId(2) == (std::pair<uint16_t, armnn::BackendId>(2, cpuRefId)));
-    BOOST_CHECK(counterIdMap.GetBackendId(3) == (std::pair<uint16_t, armnn::BackendId>(3, cpuRefId)));
-    BOOST_CHECK(counterIdMap.GetBackendId(4) == (std::pair<uint16_t, armnn::BackendId>(0, cpuAccId)));
-    BOOST_CHECK(counterIdMap.GetBackendId(5) == (std::pair<uint16_t, armnn::BackendId>(1, cpuAccId)));
-
-    BOOST_CHECK(counterIdMap.GetGlobalId(0, cpuRefId) == 0);
-    BOOST_CHECK(counterIdMap.GetGlobalId(1, cpuRefId) == 1);
-    BOOST_CHECK(counterIdMap.GetGlobalId(2, cpuRefId) == 2);
-    BOOST_CHECK(counterIdMap.GetGlobalId(3, cpuRefId) == 3);
-    BOOST_CHECK(counterIdMap.GetGlobalId(0, cpuAccId) == 4);
-    BOOST_CHECK(counterIdMap.GetGlobalId(1, cpuAccId) == 5);
+    CHECK(counterIdMap.GetBackendId(0) == (std::pair<uint16_t, armnn::BackendId>(0, cpuRefId)));
+    CHECK(counterIdMap.GetBackendId(1) == (std::pair<uint16_t, armnn::BackendId>(1, cpuRefId)));
+    CHECK(counterIdMap.GetBackendId(2) == (std::pair<uint16_t, armnn::BackendId>(2, cpuRefId)));
+    CHECK(counterIdMap.GetBackendId(3) == (std::pair<uint16_t, armnn::BackendId>(3, cpuRefId)));
+    CHECK(counterIdMap.GetBackendId(4) == (std::pair<uint16_t, armnn::BackendId>(0, cpuAccId)));
+    CHECK(counterIdMap.GetBackendId(5) == (std::pair<uint16_t, armnn::BackendId>(1, cpuAccId)));
+
+    CHECK(counterIdMap.GetGlobalId(0, cpuRefId) == 0);
+    CHECK(counterIdMap.GetGlobalId(1, cpuRefId) == 1);
+    CHECK(counterIdMap.GetGlobalId(2, cpuRefId) == 2);
+    CHECK(counterIdMap.GetGlobalId(3, cpuRefId) == 3);
+    CHECK(counterIdMap.GetGlobalId(0, cpuAccId) == 4);
+    CHECK(counterIdMap.GetGlobalId(1, cpuAccId) == 5);
 }
 
-BOOST_AUTO_TEST_CASE(CheckRegisterBackendCounters)
+TEST_CASE("CheckRegisterBackendCounters")
 {
     uint16_t globalCounterIds = armnn::profiling::INFERENCES_RUN;
     armnn::BackendId cpuRefId(armnn::Compute::CpuRef);
@@ -3429,22 +3431,22 @@ BOOST_AUTO_TEST_CASE(CheckRegisterBackendCounters)
 
 
 
-    BOOST_CHECK(profilingService.GetCounterDirectory().GetCategories().empty());
+    CHECK(profilingService.GetCounterDirectory().GetCategories().empty());
     registerBackendCounters.RegisterCategory("categoryOne");
     auto categoryOnePtr = profilingService.GetCounterDirectory().GetCategory("categoryOne");
-    BOOST_CHECK(categoryOnePtr);
+    CHECK(categoryOnePtr);
 
-    BOOST_CHECK(profilingService.GetCounterDirectory().GetDevices().empty());
+    CHECK(profilingService.GetCounterDirectory().GetDevices().empty());
     globalCounterIds = registerBackendCounters.RegisterDevice("deviceOne");
     auto deviceOnePtr = profilingService.GetCounterDirectory().GetDevice(globalCounterIds);
-    BOOST_CHECK(deviceOnePtr);
-    BOOST_CHECK(deviceOnePtr->m_Name == "deviceOne");
+    CHECK(deviceOnePtr);
+    CHECK(deviceOnePtr->m_Name == "deviceOne");
 
-    BOOST_CHECK(profilingService.GetCounterDirectory().GetCounterSets().empty());
+    CHECK(profilingService.GetCounterDirectory().GetCounterSets().empty());
     globalCounterIds = registerBackendCounters.RegisterCounterSet("counterSetOne");
     auto counterSetOnePtr = profilingService.GetCounterDirectory().GetCounterSet(globalCounterIds);
-    BOOST_CHECK(counterSetOnePtr);
-    BOOST_CHECK(counterSetOnePtr->m_Name == "counterSetOne");
+    CHECK(counterSetOnePtr);
+    CHECK(counterSetOnePtr->m_Name == "counterSetOne");
 
     uint16_t newGlobalCounterId = registerBackendCounters.RegisterCounter(0,
                                                                           "categoryOne",
@@ -3453,19 +3455,19 @@ BOOST_AUTO_TEST_CASE(CheckRegisterBackendCounters)
                                                                           1.f,
                                                                           "CounterOne",
                                                                           "first test counter");
-    BOOST_CHECK(newGlobalCounterId = armnn::profiling::INFERENCES_RUN + 1);
+    CHECK((newGlobalCounterId = armnn::profiling::INFERENCES_RUN + 1));
     uint16_t mappedGlobalId = profilingService.GetCounterMappings().GetGlobalId(0, cpuRefId);
-    BOOST_CHECK(mappedGlobalId == newGlobalCounterId);
+    CHECK(mappedGlobalId == newGlobalCounterId);
     auto backendMapping = profilingService.GetCounterMappings().GetBackendId(newGlobalCounterId);
-    BOOST_CHECK(backendMapping.first == 0);
-    BOOST_CHECK(backendMapping.second == cpuRefId);
+    CHECK(backendMapping.first == 0);
+    CHECK(backendMapping.second == cpuRefId);
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckCounterStatusQuery)
+TEST_CASE("CheckCounterStatusQuery")
 {
     armnn::IRuntime::CreationOptions options;
     options.m_ProfilingOptions.m_EnableProfiling = true;
@@ -3487,10 +3489,10 @@ BOOST_AUTO_TEST_CASE(CheckCounterStatusQuery)
     RegisterBackendCounters registerBackendCountersCpuRef(initialNumGlobalCounterIds, cpuRefId, profilingService);
 
     // Create 'testCategory' in CounterDirectory (backend agnostic)
-    BOOST_CHECK(profilingService.GetCounterDirectory().GetCategories().empty());
+    CHECK(profilingService.GetCounterDirectory().GetCategories().empty());
     registerBackendCountersCpuRef.RegisterCategory("testCategory");
     auto categoryOnePtr = profilingService.GetCounterDirectory().GetCategory("testCategory");
-    BOOST_CHECK(categoryOnePtr);
+    CHECK(categoryOnePtr);
 
     // Counters:
     // Global | Local | Backend
@@ -3504,21 +3506,21 @@ BOOST_AUTO_TEST_CASE(CheckCounterStatusQuery)
     // Register the backend counters for CpuRef and validate GetGlobalId and GetBackendId
     uint16_t currentNumGlobalCounterIds = registerBackendCountersCpuRef.RegisterCounter(
             0, "testCategory", 0, 0, 1.f, "CpuRefCounter0", "Zeroth CpuRef Counter");
-    BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 1);
+    CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 1);
     uint16_t mappedGlobalId = profilingService.GetCounterMappings().GetGlobalId(0, cpuRefId);
-    BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
+    CHECK(mappedGlobalId == currentNumGlobalCounterIds);
     auto backendMapping = profilingService.GetCounterMappings().GetBackendId(currentNumGlobalCounterIds);
-    BOOST_CHECK(backendMapping.first == 0);
-    BOOST_CHECK(backendMapping.second == cpuRefId);
+    CHECK(backendMapping.first == 0);
+    CHECK(backendMapping.second == cpuRefId);
 
     currentNumGlobalCounterIds = registerBackendCountersCpuRef.RegisterCounter(
             1, "testCategory", 0, 0, 1.f, "CpuRefCounter1", "First CpuRef Counter");
-    BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 2);
+    CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 2);
     mappedGlobalId = profilingService.GetCounterMappings().GetGlobalId(1, cpuRefId);
-    BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
+    CHECK(mappedGlobalId == currentNumGlobalCounterIds);
     backendMapping = profilingService.GetCounterMappings().GetBackendId(currentNumGlobalCounterIds);
-    BOOST_CHECK(backendMapping.first == 1);
-    BOOST_CHECK(backendMapping.second == cpuRefId);
+    CHECK(backendMapping.first == 1);
+    CHECK(backendMapping.second == cpuRefId);
 
     // Create RegisterBackendCounters for CpuAcc
     RegisterBackendCounters registerBackendCountersCpuAcc(currentNumGlobalCounterIds, cpuAccId, profilingService);
@@ -3526,12 +3528,12 @@ BOOST_AUTO_TEST_CASE(CheckCounterStatusQuery)
     // Register the backend counter for CpuAcc and validate GetGlobalId and GetBackendId
     currentNumGlobalCounterIds = registerBackendCountersCpuAcc.RegisterCounter(
             0, "testCategory", 0, 0, 1.f, "CpuAccCounter0", "Zeroth CpuAcc Counter");
-    BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 3);
+    CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 3);
     mappedGlobalId = profilingService.GetCounterMappings().GetGlobalId(0, cpuAccId);
-    BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
+    CHECK(mappedGlobalId == currentNumGlobalCounterIds);
     backendMapping = profilingService.GetCounterMappings().GetBackendId(currentNumGlobalCounterIds);
-    BOOST_CHECK(backendMapping.first == 0);
-    BOOST_CHECK(backendMapping.second == cpuAccId);
+    CHECK(backendMapping.first == 0);
+    CHECK(backendMapping.second == cpuAccId);
 
     // Create vectors for active counters
     const std::vector<uint16_t> activeGlobalCounterIds = {5}; // CpuRef(0) activated
@@ -3546,28 +3548,28 @@ BOOST_AUTO_TEST_CASE(CheckCounterStatusQuery)
     // Get vector of active counters for CpuRef and CpuAcc backends
     std::vector<CounterStatus> cpuRefCounterStatus = backendProfilingCpuRef.GetActiveCounters();
     std::vector<CounterStatus> cpuAccCounterStatus = backendProfilingCpuAcc.GetActiveCounters();
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
-    BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 0);
+    CHECK_EQ(cpuRefCounterStatus.size(), 1);
+    CHECK_EQ(cpuAccCounterStatus.size(), 0);
 
     // Check active CpuRef counter
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, activeGlobalCounterIds[0]);
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[0]);
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, capturePeriod);
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled, true);
+    CHECK_EQ(cpuRefCounterStatus[0].m_GlobalCounterId, activeGlobalCounterIds[0]);
+    CHECK_EQ(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[0]);
+    CHECK_EQ(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, capturePeriod);
+    CHECK_EQ(cpuRefCounterStatus[0].m_Enabled, true);
 
     // Check inactive CpuRef counter
     CounterStatus inactiveCpuRefCounter = backendProfilingCpuRef.GetCounterStatus(cpuRefCounters[1]);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_GlobalCounterId, 6);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_BackendCounterId, cpuRefCounters[1]);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_SamplingRateInMicroseconds, 0);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_Enabled, false);
+    CHECK_EQ(inactiveCpuRefCounter.m_GlobalCounterId, 6);
+    CHECK_EQ(inactiveCpuRefCounter.m_BackendCounterId, cpuRefCounters[1]);
+    CHECK_EQ(inactiveCpuRefCounter.m_SamplingRateInMicroseconds, 0);
+    CHECK_EQ(inactiveCpuRefCounter.m_Enabled, false);
 
     // Check inactive CpuAcc counter
     CounterStatus inactiveCpuAccCounter = backendProfilingCpuAcc.GetCounterStatus(cpuAccCounters[0]);
-    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_GlobalCounterId, 7);
-    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_BackendCounterId, cpuAccCounters[0]);
-    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_SamplingRateInMicroseconds, 0);
-    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_Enabled, false);
+    CHECK_EQ(inactiveCpuAccCounter.m_GlobalCounterId, 7);
+    CHECK_EQ(inactiveCpuAccCounter.m_BackendCounterId, cpuAccCounters[0]);
+    CHECK_EQ(inactiveCpuAccCounter.m_SamplingRateInMicroseconds, 0);
+    CHECK_EQ(inactiveCpuAccCounter.m_Enabled, false);
 
     // Set new capture period and new active counters in CaptureData
     profilingService.SetCaptureData(newCapturePeriod, newActiveGlobalCounterIds, {});
@@ -3575,34 +3577,34 @@ BOOST_AUTO_TEST_CASE(CheckCounterStatusQuery)
     // Get vector of active counters for CpuRef and CpuAcc backends
     cpuRefCounterStatus = backendProfilingCpuRef.GetActiveCounters();
     cpuAccCounterStatus = backendProfilingCpuAcc.GetActiveCounters();
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
-    BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 1);
+    CHECK_EQ(cpuRefCounterStatus.size(), 1);
+    CHECK_EQ(cpuAccCounterStatus.size(), 1);
 
     // Check active CpuRef counter
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[0]);
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[1]);
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
-    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled, true);
+    CHECK_EQ(cpuRefCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[0]);
+    CHECK_EQ(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[1]);
+    CHECK_EQ(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
+    CHECK_EQ(cpuRefCounterStatus[0].m_Enabled, true);
 
     // Check active CpuAcc counter
-    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[1]);
-    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_BackendCounterId, cpuAccCounters[0]);
-    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
-    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_Enabled, true);
+    CHECK_EQ(cpuAccCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[1]);
+    CHECK_EQ(cpuAccCounterStatus[0].m_BackendCounterId, cpuAccCounters[0]);
+    CHECK_EQ(cpuAccCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
+    CHECK_EQ(cpuAccCounterStatus[0].m_Enabled, true);
 
     // Check inactive CpuRef counter
     inactiveCpuRefCounter = backendProfilingCpuRef.GetCounterStatus(cpuRefCounters[0]);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_GlobalCounterId, 5);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_BackendCounterId, cpuRefCounters[0]);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_SamplingRateInMicroseconds, 0);
-    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_Enabled, false);
+    CHECK_EQ(inactiveCpuRefCounter.m_GlobalCounterId, 5);
+    CHECK_EQ(inactiveCpuRefCounter.m_BackendCounterId, cpuRefCounters[0]);
+    CHECK_EQ(inactiveCpuRefCounter.m_SamplingRateInMicroseconds, 0);
+    CHECK_EQ(inactiveCpuRefCounter.m_Enabled, false);
 
     // Reset the profiling service to stop any running thread
     options.m_ProfilingOptions.m_EnableProfiling = false;
     profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckRegisterCounters)
+TEST_CASE("CheckRegisterCounters")
 {
     armnn::IRuntime::CreationOptions options;
     options.m_ProfilingOptions.m_EnableProfiling = true;
@@ -3634,34 +3636,34 @@ BOOST_AUTO_TEST_CASE(CheckRegisterCounters)
     uint32_t headerWord1 = ReadUint32(readBuffer, 4);
     uint64_t readTimestamp = ReadUint64(readBuffer, 8);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3); // packet family
-    BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0); // packet class
-    BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0); // packet type
-    BOOST_TEST(headerWord1 == 20);                       // data length
-    BOOST_TEST(1000998 == readTimestamp);                // capture period
+    CHECK(((headerWord0 >> 26) & 0x0000003F) == 3); // packet family
+    CHECK(((headerWord0 >> 19) & 0x0000007F) == 0); // packet class
+    CHECK(((headerWord0 >> 16) & 0x00000007) == 0); // packet type
+    CHECK(headerWord1 == 20);                       // data length
+    CHECK(1000998 == readTimestamp);                // capture period
 
     uint32_t offset = 16;
     // Check Counter Index
     uint16_t readIndex = ReadUint16(readBuffer, offset);
-    BOOST_TEST(6 == readIndex);
+    CHECK(6 == readIndex);
 
     // Check Counter Value
     offset += 2;
     uint32_t readValue = ReadUint32(readBuffer, offset);
-    BOOST_TEST(700 == readValue);
+    CHECK(700 == readValue);
 
     // Check Counter Index
     offset += 4;
     readIndex = ReadUint16(readBuffer, offset);
-    BOOST_TEST(8 == readIndex);
+    CHECK(8 == readIndex);
 
     // Check Counter Value
     offset += 2;
     readValue = ReadUint32(readBuffer, offset);
-    BOOST_TEST(93 == readValue);
+    CHECK(93 == readValue);
 }
 
-BOOST_AUTO_TEST_CASE(CheckFileFormat) {
+TEST_CASE("CheckFileFormat") {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
 
@@ -3669,7 +3671,7 @@ BOOST_AUTO_TEST_CASE(CheckFileFormat) {
     armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
     options.m_EnableProfiling = true;
     // Check the default value set to binary
-    BOOST_CHECK(options.m_FileFormat == "binary");
+    CHECK(options.m_FileFormat == "binary");
 
     // Change file format to an unsupported value
     options.m_FileFormat = "json";
@@ -3678,7 +3680,7 @@ BOOST_AUTO_TEST_CASE(CheckFileFormat) {
     profilingService.ResetExternalProfilingOptions(options, true);
     // Start the command handler and the send thread
     profilingService.Update();
-    BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::NotConnected);
+    CHECK(profilingService.GetCurrentState()==ProfilingState::NotConnected);
 
     // Redirect the output to a local stream so that we can parse the warning message
     std::stringstream ss;
@@ -3694,8 +3696,8 @@ BOOST_AUTO_TEST_CASE(CheckFileFormat) {
     if (ss.str().find("Unsupported profiling file format, only binary is supported") == std::string::npos)
     {
         std::cout << ss.str();
-        BOOST_FAIL("Expected string not found.");
+        FAIL("Expected string not found.");
     }
 }
 
-BOOST_AUTO_TEST_SUITE_END()
+}