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, 348 insertions, 346 deletions

diff --git a/src/profiling/test/SendCounterPacketTests.cpp b/src/profiling/test/SendCounterPacketTests.cpp
index 950f8ffad0..675d083644 100644
--- a/src/profiling/test/SendCounterPacketTests.cpp
+++ b/src/profiling/test/SendCounterPacketTests.cpp
@@ -20,7 +20,9 @@
 
 #include <common/include/Constants.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <armnn/utility/Assert.hpp>
+
+#include <doctest/doctest.h>
 
 #include <chrono>
 
@@ -48,7 +50,7 @@ void SetNotConnectedProfilingState(ProfilingStateMachine& profilingStateMachine)
     case ProfilingState::NotConnected:
         return;
     default:
-        BOOST_CHECK_MESSAGE(false, "Invalid profiling state");
+        CHECK_MESSAGE(false, "Invalid profiling state");
     }
 }
 
@@ -68,7 +70,7 @@ void SetWaitingForAckProfilingState(ProfilingStateMachine& profilingStateMachine
     case ProfilingState::WaitingForAck:
         return;
     default:
-        BOOST_CHECK_MESSAGE(false, "Invalid profiling state");
+        CHECK_MESSAGE(false, "Invalid profiling state");
     }
 }
 
@@ -89,17 +91,17 @@ void SetActiveProfilingState(ProfilingStateMachine& profilingStateMachine)
     case ProfilingState::Active:
         return;
     default:
-        BOOST_CHECK_MESSAGE(false, "Invalid profiling state");
+        CHECK_MESSAGE(false, "Invalid profiling state");
     }
 }
 
 } // Anonymous namespace
 
-BOOST_AUTO_TEST_SUITE(SendCounterPacketTests)
-
+TEST_SUITE("SendCounterPacketTests")
+{
 using PacketType = MockProfilingConnection::PacketType;
 
-BOOST_AUTO_TEST_CASE(MockSendCounterPacketTest)
+TEST_CASE("MockSendCounterPacketTest")
 {
     MockBufferManager mockBuffer(512);
     MockSendCounterPacket mockSendCounterPacket(mockBuffer);
@@ -109,7 +111,7 @@ BOOST_AUTO_TEST_CASE(MockSendCounterPacketTest)
     auto packetBuffer = mockBuffer.GetReadableBuffer();
     const char* buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
 
-    BOOST_TEST(strcmp(buffer, "SendStreamMetaDataPacket") == 0);
+    CHECK(strcmp(buffer, "SendStreamMetaDataPacket") == 0);
 
     mockBuffer.MarkRead(packetBuffer);
 
@@ -119,7 +121,7 @@ BOOST_AUTO_TEST_CASE(MockSendCounterPacketTest)
     packetBuffer = mockBuffer.GetReadableBuffer();
     buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
 
-    BOOST_TEST(strcmp(buffer, "SendCounterDirectoryPacket") == 0);
+    CHECK(strcmp(buffer, "SendCounterDirectoryPacket") == 0);
 
     mockBuffer.MarkRead(packetBuffer);
 
@@ -131,7 +133,7 @@ BOOST_AUTO_TEST_CASE(MockSendCounterPacketTest)
     packetBuffer = mockBuffer.GetReadableBuffer();
     buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
 
-    BOOST_TEST(strcmp(buffer, "SendPeriodicCounterCapturePacket") == 0);
+    CHECK(strcmp(buffer, "SendPeriodicCounterCapturePacket") == 0);
 
     mockBuffer.MarkRead(packetBuffer);
 
@@ -142,12 +144,12 @@ BOOST_AUTO_TEST_CASE(MockSendCounterPacketTest)
     packetBuffer = mockBuffer.GetReadableBuffer();
     buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
 
-    BOOST_TEST(strcmp(buffer, "SendPeriodicCounterSelectionPacket") == 0);
+    CHECK(strcmp(buffer, "SendPeriodicCounterSelectionPacket") == 0);
 
     mockBuffer.MarkRead(packetBuffer);
 }
 
-BOOST_AUTO_TEST_CASE(SendPeriodicCounterSelectionPacketTest)
+TEST_CASE("SendPeriodicCounterSelectionPacketTest")
 {
     // Error no space left in buffer
     MockBufferManager mockBuffer1(10);
@@ -155,7 +157,7 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterSelectionPacketTest)
 
     uint32_t capturePeriod = 1000;
     std::vector<uint16_t> selectedCounterIds;
-    BOOST_CHECK_THROW(sendPacket1.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds),
+    CHECK_THROWS_AS(sendPacket1.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds),
                       BufferExhaustion);
 
     // Packet without any counters
@@ -169,10 +171,10 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterSelectionPacketTest)
     uint32_t headerWord1 = ReadUint32(readBuffer2, 4);
     uint32_t period = ReadUint32(readBuffer2, 8);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
-    BOOST_TEST(headerWord1 == 4);                   // data lenght
-    BOOST_TEST(period == 1000);                     // capture period
+    CHECK(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
+    CHECK(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
+    CHECK(headerWord1 == 4);                   // data lenght
+    CHECK(period == 1000);                     // capture period
 
     // Full packet message
     MockBufferManager mockBuffer3(512);
@@ -191,10 +193,10 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterSelectionPacketTest)
     headerWord1 = ReadUint32(readBuffer3, 4);
     period = ReadUint32(readBuffer3, 8);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
-    BOOST_TEST(headerWord1 == 14);                  // data lenght
-    BOOST_TEST(period == 1000);                     // capture period
+    CHECK(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
+    CHECK(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
+    CHECK(headerWord1 == 14);                  // data lenght
+    CHECK(period == 1000);                     // capture period
 
     uint16_t counterId = 0;
     uint32_t offset = 12;
@@ -203,12 +205,12 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterSelectionPacketTest)
     for(const uint16_t& id : selectedCounterIds)
     {
         counterId = ReadUint16(readBuffer3, offset);
-        BOOST_TEST(counterId == id);
+        CHECK(counterId == id);
         offset += 2;
     }
 }
 
-BOOST_AUTO_TEST_CASE(SendPeriodicCounterCapturePacketTest)
+TEST_CASE("SendPeriodicCounterCapturePacketTest")
 {
     ProfilingStateMachine profilingStateMachine;
 
@@ -220,7 +222,7 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterCapturePacketTest)
     uint64_t time =  static_cast<uint64_t >(captureTimestamp.time_since_epoch().count());
     std::vector<CounterValue> indexValuePairs;
 
-    BOOST_CHECK_THROW(sendPacket1.SendPeriodicCounterCapturePacket(time, indexValuePairs),
+    CHECK_THROWS_AS(sendPacket1.SendPeriodicCounterCapturePacket(time, indexValuePairs),
                       BufferExhaustion);
 
     // Packet without any counters
@@ -234,11 +236,11 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterCapturePacketTest)
     uint32_t headerWord1 = ReadUint32(readBuffer2, 4);
     uint64_t readTimestamp = ReadUint64(readBuffer2, 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 == 8);                        // data length
-    BOOST_TEST(time == 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 == 8);                        // data length
+    CHECK(time == readTimestamp);                   // capture period
 
     // Full packet message
     MockBufferManager mockBuffer3(512);
@@ -257,11 +259,11 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterCapturePacketTest)
     headerWord1 = ReadUint32(readBuffer3, 4);
     uint64_t readTimestamp2 = ReadUint64(readBuffer3, 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 == 38);                       // data length
-    BOOST_TEST(time == readTimestamp2);                  // 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 == 38);                       // data length
+    CHECK(time == readTimestamp2);                  // capture period
 
     uint16_t counterIndex = 0;
     uint32_t counterValue = 100;
@@ -272,27 +274,27 @@ BOOST_AUTO_TEST_CASE(SendPeriodicCounterCapturePacketTest)
     {
         // Check Counter Index
         uint16_t readIndex = ReadUint16(readBuffer3, offset);
-        BOOST_TEST(counterIndex == readIndex);
+        CHECK(counterIndex == readIndex);
         counterIndex++;
         offset += 2;
 
         // Check Counter Value
         uint32_t readValue = ReadUint32(readBuffer3, offset);
-        BOOST_TEST(counterValue == readValue);
+        CHECK(counterValue == readValue);
         counterValue += 100;
         offset += 4;
     }
 
 }
 
-BOOST_AUTO_TEST_CASE(SendStreamMetaDataPacketTest)
+TEST_CASE("SendStreamMetaDataPacketTest")
 {
     uint32_t sizeUint32 = armnn::numeric_cast<uint32_t>(sizeof(uint32_t));
 
     // Error no space left in buffer
     MockBufferManager mockBuffer1(10);
     SendCounterPacket sendPacket1(mockBuffer1);
-    BOOST_CHECK_THROW(sendPacket1.SendStreamMetaDataPacket(), armnn::profiling::BufferExhaustion);
+    CHECK_THROWS_AS(sendPacket1.SendStreamMetaDataPacket(), armnn::profiling::BufferExhaustion);
 
     // Full metadata packet
 
@@ -345,8 +347,8 @@ BOOST_AUTO_TEST_CASE(SendStreamMetaDataPacketTest)
     uint32_t headerWord0 = ReadUint32(readBuffer2, 0);
     uint32_t headerWord1 = ReadUint32(readBuffer2, sizeUint32);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0); // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 0); // packet id
+    CHECK(((headerWord0 >> 26) & 0x3F) == 0); // packet family
+    CHECK(((headerWord0 >> 16) & 0x3FF) == 0); // packet id
 
     uint32_t totalLength = armnn::numeric_cast<uint32_t>(2 * sizeUint32 +
                                                          10 * sizeUint32 + infoSize +
@@ -354,82 +356,82 @@ BOOST_AUTO_TEST_CASE(SendStreamMetaDataPacketTest)
                                                          processNameSize + sizeUint32 +
                                                          2 * packetEntries * sizeUint32);
 
-    BOOST_TEST(headerWord1 == totalLength - (2 * sizeUint32)); // data length
+    CHECK(headerWord1 == totalLength - (2 * sizeUint32)); // data length
 
     uint32_t offset = sizeUint32 * 2;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == arm::pipe::PIPE_MAGIC); // pipe_magic
+    CHECK(ReadUint32(readBuffer2, offset) == arm::pipe::PIPE_MAGIC); // pipe_magic
     offset += sizeUint32;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == arm::pipe::EncodeVersion(1, 0, 0)); // stream_metadata_version
+    CHECK(ReadUint32(readBuffer2, offset) == arm::pipe::EncodeVersion(1, 0, 0)); // stream_metadata_version
     offset += sizeUint32;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == MAX_METADATA_PACKET_LENGTH); // max_data_len
+    CHECK(ReadUint32(readBuffer2, offset) == MAX_METADATA_PACKET_LENGTH); // max_data_len
     offset += sizeUint32;
     int pid = armnnUtils::Processes::GetCurrentId();
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == armnn::numeric_cast<uint32_t>(pid));
+    CHECK(ReadUint32(readBuffer2, offset) == armnn::numeric_cast<uint32_t>(pid));
     offset += sizeUint32;
     uint32_t poolOffset = 10 * sizeUint32;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == poolOffset); // offset_info
+    CHECK(ReadUint32(readBuffer2, offset) == poolOffset); // offset_info
     offset += sizeUint32;
     poolOffset += infoSize;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == poolOffset); // offset_hw_version
+    CHECK(ReadUint32(readBuffer2, offset) == poolOffset); // offset_hw_version
     offset += sizeUint32;
     poolOffset += hardwareVersionSize;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == poolOffset); // offset_sw_version
+    CHECK(ReadUint32(readBuffer2, offset) == poolOffset); // offset_sw_version
     offset += sizeUint32;
     poolOffset += softwareVersionSize;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == poolOffset); // offset_process_name
+    CHECK(ReadUint32(readBuffer2, offset) == poolOffset); // offset_process_name
     offset += sizeUint32;
     poolOffset += processNameSize;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == poolOffset); // offset_packet_version_table
+    CHECK(ReadUint32(readBuffer2, offset) == poolOffset); // offset_packet_version_table
     offset += sizeUint32;
-    BOOST_TEST(ReadUint32(readBuffer2, offset) == 0); // reserved
+    CHECK(ReadUint32(readBuffer2, offset) == 0); // reserved
 
     const unsigned char* readData2 = readBuffer2->GetReadableData();
 
     offset += sizeUint32;
     if (infoSize)
     {
-        BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetSoftwareInfo().c_str()) == 0);
+        CHECK(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetSoftwareInfo().c_str()) == 0);
         offset += infoSize;
     }
 
     if (hardwareVersionSize)
     {
-        BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetHardwareVersion().c_str()) == 0);
+        CHECK(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetHardwareVersion().c_str()) == 0);
         offset += hardwareVersionSize;
     }
 
     if (softwareVersionSize)
     {
-        BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetSoftwareVersion().c_str()) == 0);
+        CHECK(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetSoftwareVersion().c_str()) == 0);
         offset += softwareVersionSize;
     }
 
     if (processNameSize)
     {
-        BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetProcessName().c_str()) == 0);
+        CHECK(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetProcessName().c_str()) == 0);
         offset += processNameSize;
     }
 
     if (packetEntries)
     {
         uint32_t numberOfEntries = ReadUint32(readBuffer2, offset);
-        BOOST_TEST((numberOfEntries >> 16) == packetEntries);
+        CHECK((numberOfEntries >> 16) == packetEntries);
         offset += sizeUint32;
         for (std::pair<uint32_t, uint32_t>& packetVersion : packetVersions)
         {
             uint32_t readPacketId = ReadUint32(readBuffer2, offset);
-            BOOST_TEST(packetVersion.first == readPacketId);
+            CHECK(packetVersion.first == readPacketId);
             offset += sizeUint32;
             uint32_t readVersion = ReadUint32(readBuffer2, offset);
-            BOOST_TEST(packetVersion.second == readVersion);
+            CHECK(packetVersion.second == readVersion);
             offset += sizeUint32;
         }
     }
 
-    BOOST_TEST(offset == totalLength);
+    CHECK(offset == totalLength);
 }
 
-BOOST_AUTO_TEST_CASE(CreateDeviceRecordTest)
+TEST_CASE("CreateDeviceRecordTest")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -445,23 +447,23 @@ BOOST_AUTO_TEST_CASE(CreateDeviceRecordTest)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateDeviceRecordTest(device, deviceRecord, errorMessage);
 
-    BOOST_CHECK(result);
-    BOOST_CHECK(errorMessage.empty());
-    BOOST_CHECK(deviceRecord.size() == 6); // Size in words: header [2] + device name [4]
+    CHECK(result);
+    CHECK(errorMessage.empty());
+    CHECK(deviceRecord.size() == 6); // Size in words: header [2] + device name [4]
 
     uint16_t deviceRecordWord0[]
     {
         static_cast<uint16_t>(deviceRecord[0] >> 16),
         static_cast<uint16_t>(deviceRecord[0])
     };
-    BOOST_CHECK(deviceRecordWord0[0] == deviceUid); // uid
-    BOOST_CHECK(deviceRecordWord0[1] == deviceCores); // cores
-    BOOST_CHECK(deviceRecord[1] == 8); // name_offset
-    BOOST_CHECK(deviceRecord[2] == deviceName.size() + 1); // The length of the SWTrace string (name)
-    BOOST_CHECK(std::memcmp(deviceRecord.data() + 3, deviceName.data(), deviceName.size()) == 0); // name
+    CHECK(deviceRecordWord0[0] == deviceUid); // uid
+    CHECK(deviceRecordWord0[1] == deviceCores); // cores
+    CHECK(deviceRecord[1] == 8); // name_offset
+    CHECK(deviceRecord[2] == deviceName.size() + 1); // The length of the SWTrace string (name)
+    CHECK(std::memcmp(deviceRecord.data() + 3, deviceName.data(), deviceName.size()) == 0); // name
 }
 
-BOOST_AUTO_TEST_CASE(CreateInvalidDeviceRecordTest)
+TEST_CASE("CreateInvalidDeviceRecordTest")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -477,12 +479,12 @@ BOOST_AUTO_TEST_CASE(CreateInvalidDeviceRecordTest)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateDeviceRecordTest(device, deviceRecord, errorMessage);
 
-    BOOST_CHECK(!result);
-    BOOST_CHECK(!errorMessage.empty());
-    BOOST_CHECK(deviceRecord.empty());
+    CHECK(!result);
+    CHECK(!errorMessage.empty());
+    CHECK(deviceRecord.empty());
 }
 
-BOOST_AUTO_TEST_CASE(CreateCounterSetRecordTest)
+TEST_CASE("CreateCounterSetRecordTest")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -498,23 +500,23 @@ BOOST_AUTO_TEST_CASE(CreateCounterSetRecordTest)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateCounterSetRecordTest(counterSet, counterSetRecord, errorMessage);
 
-    BOOST_CHECK(result);
-    BOOST_CHECK(errorMessage.empty());
-    BOOST_CHECK(counterSetRecord.size() == 8); // Size in words: header [2] + counter set name [6]
+    CHECK(result);
+    CHECK(errorMessage.empty());
+    CHECK(counterSetRecord.size() == 8); // Size in words: header [2] + counter set name [6]
 
     uint16_t counterSetRecordWord0[]
     {
         static_cast<uint16_t>(counterSetRecord[0] >> 16),
         static_cast<uint16_t>(counterSetRecord[0])
     };
-    BOOST_CHECK(counterSetRecordWord0[0] == counterSetUid); // uid
-    BOOST_CHECK(counterSetRecordWord0[1] == counterSetCount); // cores
-    BOOST_CHECK(counterSetRecord[1] == 8); // name_offset
-    BOOST_CHECK(counterSetRecord[2] == counterSetName.size() + 1); // The length of the SWTrace string (name)
-    BOOST_CHECK(std::memcmp(counterSetRecord.data() + 3, counterSetName.data(), counterSetName.size()) == 0); // name
+    CHECK(counterSetRecordWord0[0] == counterSetUid); // uid
+    CHECK(counterSetRecordWord0[1] == counterSetCount); // cores
+    CHECK(counterSetRecord[1] == 8); // name_offset
+    CHECK(counterSetRecord[2] == counterSetName.size() + 1); // The length of the SWTrace string (name)
+    CHECK(std::memcmp(counterSetRecord.data() + 3, counterSetName.data(), counterSetName.size()) == 0); // name
 }
 
-BOOST_AUTO_TEST_CASE(CreateInvalidCounterSetRecordTest)
+TEST_CASE("CreateInvalidCounterSetRecordTest")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -530,12 +532,12 @@ BOOST_AUTO_TEST_CASE(CreateInvalidCounterSetRecordTest)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateCounterSetRecordTest(counterSet, counterSetRecord, errorMessage);
 
-    BOOST_CHECK(!result);
-    BOOST_CHECK(!errorMessage.empty());
-    BOOST_CHECK(counterSetRecord.empty());
+    CHECK(!result);
+    CHECK(!errorMessage.empty());
+    CHECK(counterSetRecord.empty());
 }
 
-BOOST_AUTO_TEST_CASE(CreateEventRecordTest)
+TEST_CASE("CreateEventRecordTest")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -569,9 +571,9 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordTest)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
 
-    BOOST_CHECK(result);
-    BOOST_CHECK(errorMessage.empty());
-    BOOST_CHECK(eventRecord.size() == 24); // Size in words: header [8] + counter name [6] + description [7] + units [3]
+    CHECK(result);
+    CHECK(errorMessage.empty());
+    CHECK(eventRecord.size() == 24); // Size in words: header [8] + counter name [6] + description [7] + units [3]
 
     uint16_t eventRecordWord0[]
     {
@@ -594,14 +596,14 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordTest)
         eventRecord[4]
     };
 
-    BOOST_CHECK(eventRecordWord0[0] == maxCounterUid); // max_counter_uid
-    BOOST_CHECK(eventRecordWord0[1] == counterUid); // counter_uid
-    BOOST_CHECK(eventRecordWord1[0] == deviceUid); // device
+    CHECK(eventRecordWord0[0] == maxCounterUid); // max_counter_uid
+    CHECK(eventRecordWord0[1] == counterUid); // counter_uid
+    CHECK(eventRecordWord1[0] == deviceUid); // device
 
-    BOOST_CHECK(eventRecordWord1[1] == counterSetUid); // counter_set
-    BOOST_CHECK(eventRecordWord2[0] == counterClass); // class
-    BOOST_CHECK(eventRecordWord2[1] == counterInterpolation); // interpolation
-    BOOST_CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier
+    CHECK(eventRecordWord1[1] == counterSetUid); // counter_set
+    CHECK(eventRecordWord2[0] == counterClass); // class
+    CHECK(eventRecordWord2[1] == counterInterpolation); // interpolation
+    CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier
 
     ARMNN_NO_CONVERSION_WARN_BEGIN
     uint32_t eventRecordBlockSize = 8u * sizeof(uint32_t);
@@ -620,49 +622,49 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordTest)
 
     ARMNN_NO_CONVERSION_WARN_END
 
-    BOOST_CHECK(eventRecord[5] == counterNameOffset); // name_offset
-    BOOST_CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset
-    BOOST_CHECK(eventRecord[7] == counterUnitsOffset); // units_offset
+    CHECK(eventRecord[5] == counterNameOffset); // name_offset
+    CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset
+    CHECK(eventRecord[7] == counterUnitsOffset); // units_offset
 
     // Offsets are relative to the start of the eventRecord
     auto eventRecordPool = reinterpret_cast<unsigned char*>(eventRecord.data());
     size_t uint32_t_size = sizeof(uint32_t);
 
     // The length of the SWTrace string (name)
-    BOOST_CHECK(eventRecordPool[counterNameOffset] == counterName.size() + 1);
+    CHECK(eventRecordPool[counterNameOffset] == counterName.size() + 1);
     // The counter name
-    BOOST_CHECK(std::memcmp(eventRecordPool +
+    CHECK(std::memcmp(eventRecordPool +
                             counterNameOffset + // Offset
                             uint32_t_size /* The length of the name */,
                             counterName.data(),
                             counterName.size()) == 0); // name
     // The null-terminator at the end of the name
-    BOOST_CHECK(eventRecordPool[counterNameOffset + uint32_t_size + counterName.size()] == '\0');
+    CHECK(eventRecordPool[counterNameOffset + uint32_t_size + counterName.size()] == '\0');
 
     // The length of the SWTrace string (description)
-    BOOST_CHECK(eventRecordPool[counterDescriptionOffset] == counterDescription.size() + 1);
+    CHECK(eventRecordPool[counterDescriptionOffset] == counterDescription.size() + 1);
     // The counter description
-    BOOST_CHECK(std::memcmp(eventRecordPool +
+    CHECK(std::memcmp(eventRecordPool +
                             counterDescriptionOffset + // Offset
                             uint32_t_size /* The length of the description */,
                             counterDescription.data(),
                             counterDescription.size()) == 0); // description
     // The null-terminator at the end of the description
-    BOOST_CHECK(eventRecordPool[counterDescriptionOffset + uint32_t_size + counterDescription.size()] == '\0');
+    CHECK(eventRecordPool[counterDescriptionOffset + uint32_t_size + counterDescription.size()] == '\0');
 
     // The length of the SWTrace namestring (units)
-    BOOST_CHECK(eventRecordPool[counterUnitsOffset] == counterUnits.size() + 1);
+    CHECK(eventRecordPool[counterUnitsOffset] == counterUnits.size() + 1);
     // The counter units
-    BOOST_CHECK(std::memcmp(eventRecordPool +
+    CHECK(std::memcmp(eventRecordPool +
                             counterUnitsOffset + // Offset
                             uint32_t_size /* The length of the units */,
                             counterUnits.data(),
                             counterUnits.size()) == 0); // units
     // The null-terminator at the end of the units
-    BOOST_CHECK(eventRecordPool[counterUnitsOffset + uint32_t_size + counterUnits.size()] == '\0');
+    CHECK(eventRecordPool[counterUnitsOffset + uint32_t_size + counterUnits.size()] == '\0');
 }
 
-BOOST_AUTO_TEST_CASE(CreateEventRecordNoUnitsTest)
+TEST_CASE("CreateEventRecordNoUnitsTest")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -695,9 +697,9 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordNoUnitsTest)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
 
-    BOOST_CHECK(result);
-    BOOST_CHECK(errorMessage.empty());
-    BOOST_CHECK(eventRecord.size() == 21); // Size in words: header [8] + counter name [6] + description [7]
+    CHECK(result);
+    CHECK(errorMessage.empty());
+    CHECK(eventRecord.size() == 21); // Size in words: header [8] + counter name [6] + description [7]
 
     uint16_t eventRecordWord0[]
     {
@@ -719,13 +721,13 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordNoUnitsTest)
         eventRecord[3],
         eventRecord[4]
     };
-    BOOST_CHECK(eventRecordWord0[0] == maxCounterUid); // max_counter_uid
-    BOOST_CHECK(eventRecordWord0[1] == counterUid); // counter_uid
-    BOOST_CHECK(eventRecordWord1[0] == deviceUid); // device
-    BOOST_CHECK(eventRecordWord1[1] == counterSetUid); // counter_set
-    BOOST_CHECK(eventRecordWord2[0] == counterClass); // class
-    BOOST_CHECK(eventRecordWord2[1] == counterInterpolation); // interpolation
-    BOOST_CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier
+    CHECK(eventRecordWord0[0] == maxCounterUid); // max_counter_uid
+    CHECK(eventRecordWord0[1] == counterUid); // counter_uid
+    CHECK(eventRecordWord1[0] == deviceUid); // device
+    CHECK(eventRecordWord1[1] == counterSetUid); // counter_set
+    CHECK(eventRecordWord2[0] == counterClass); // class
+    CHECK(eventRecordWord2[1] == counterInterpolation); // interpolation
+    CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier
 
     ARMNN_NO_CONVERSION_WARN_BEGIN
     uint32_t eventRecordBlockSize = 8u * sizeof(uint32_t);
@@ -737,38 +739,38 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordNoUnitsTest)
                                         1u; // Rounding to the next word
     ARMNN_NO_CONVERSION_WARN_END
 
-    BOOST_CHECK(eventRecord[5] == counterNameOffset); // name_offset
-    BOOST_CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset
-    BOOST_CHECK(eventRecord[7] == 0); // units_offset
+    CHECK(eventRecord[5] == counterNameOffset); // name_offset
+    CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset
+    CHECK(eventRecord[7] == 0); // units_offset
 
     // Offsets are relative to the start of the eventRecord
     auto eventRecordPool = reinterpret_cast<unsigned char*>(eventRecord.data());
     size_t uint32_t_size = sizeof(uint32_t);
 
     // The length of the SWTrace string (name)
-    BOOST_CHECK(eventRecordPool[counterNameOffset] == counterName.size() + 1);
+    CHECK(eventRecordPool[counterNameOffset] == counterName.size() + 1);
     // The counter name
-    BOOST_CHECK(std::memcmp(eventRecordPool +
+    CHECK(std::memcmp(eventRecordPool +
                             counterNameOffset + // Offset
                             uint32_t_size, // The length of the name
                             counterName.data(),
                             counterName.size()) == 0); // name
     // The null-terminator at the end of the name
-    BOOST_CHECK(eventRecordPool[counterNameOffset + uint32_t_size + counterName.size()] == '\0');
+    CHECK(eventRecordPool[counterNameOffset + uint32_t_size + counterName.size()] == '\0');
 
     // The length of the SWTrace string (description)
-    BOOST_CHECK(eventRecordPool[counterDescriptionOffset] == counterDescription.size() + 1);
+    CHECK(eventRecordPool[counterDescriptionOffset] == counterDescription.size() + 1);
     // The counter description
-    BOOST_CHECK(std::memcmp(eventRecordPool +
+    CHECK(std::memcmp(eventRecordPool +
                             counterDescriptionOffset + // Offset
                             uint32_t_size, // The length of the description
                             counterDescription.data(),
                             counterDescription.size()) == 0); // description
     // The null-terminator at the end of the description
-    BOOST_CHECK(eventRecordPool[counterDescriptionOffset + uint32_t_size + counterDescription.size()] == '\0');
+    CHECK(eventRecordPool[counterDescriptionOffset + uint32_t_size + counterDescription.size()] == '\0');
 }
 
-BOOST_AUTO_TEST_CASE(CreateInvalidEventRecordTest1)
+TEST_CASE("CreateInvalidEventRecordTest1")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -802,12 +804,12 @@ BOOST_AUTO_TEST_CASE(CreateInvalidEventRecordTest1)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
 
-    BOOST_CHECK(!result);
-    BOOST_CHECK(!errorMessage.empty());
-    BOOST_CHECK(eventRecord.empty());
+    CHECK(!result);
+    CHECK(!errorMessage.empty());
+    CHECK(eventRecord.empty());
 }
 
-BOOST_AUTO_TEST_CASE(CreateInvalidEventRecordTest2)
+TEST_CASE("CreateInvalidEventRecordTest2")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -841,12 +843,12 @@ BOOST_AUTO_TEST_CASE(CreateInvalidEventRecordTest2)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
 
-    BOOST_CHECK(!result);
-    BOOST_CHECK(!errorMessage.empty());
-    BOOST_CHECK(eventRecord.empty());
+    CHECK(!result);
+    CHECK(!errorMessage.empty());
+    CHECK(eventRecord.empty());
 }
 
-BOOST_AUTO_TEST_CASE(CreateInvalidEventRecordTest3)
+TEST_CASE("CreateInvalidEventRecordTest3")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -880,12 +882,12 @@ BOOST_AUTO_TEST_CASE(CreateInvalidEventRecordTest3)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
 
-    BOOST_CHECK(!result);
-    BOOST_CHECK(!errorMessage.empty());
-    BOOST_CHECK(eventRecord.empty());
+    CHECK(!result);
+    CHECK(!errorMessage.empty());
+    CHECK(eventRecord.empty());
 }
 
-BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
+TEST_CASE("CreateCategoryRecordTest")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -947,9 +949,9 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateCategoryRecordTest(category, counters, categoryRecord, errorMessage);
 
-    BOOST_CHECK(result);
-    BOOST_CHECK(errorMessage.empty());
-    BOOST_CHECK(categoryRecord.size() == 79); // Size in words: header [3] + event pointer table [3] +
+    CHECK(result);
+    CHECK(errorMessage.empty());
+    CHECK(categoryRecord.size() == 79); // Size in words: header [3] + event pointer table [3] +
                                               //                category name [5] + event records [68 = 22 + 20 + 26]
 
     uint16_t categoryRecordWord1[]
@@ -957,8 +959,8 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
         static_cast<uint16_t>(categoryRecord[0] >> 16),
         static_cast<uint16_t>(categoryRecord[0])
     };
-    BOOST_CHECK(categoryRecordWord1[0] == categoryEventCount); // event_count
-    BOOST_CHECK(categoryRecordWord1[1] == 0); // reserved
+    CHECK(categoryRecordWord1[0] == categoryEventCount); // event_count
+    CHECK(categoryRecordWord1[1] == 0); // reserved
 
     size_t uint32_t_size = sizeof(uint32_t);
 
@@ -969,8 +971,8 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
                                   categoryEventCount * uint32_t_size; // The size of the event pointer table
     ARMNN_NO_CONVERSION_WARN_END
 
-    BOOST_CHECK(categoryRecord[1] == eventPointerTableOffset); // event_pointer_table_offset
-    BOOST_CHECK(categoryRecord[2] == categoryNameOffset); // name_offset
+    CHECK(categoryRecord[1] == eventPointerTableOffset); // event_pointer_table_offset
+    CHECK(categoryRecord[2] == categoryNameOffset); // name_offset
     // Offsets are relative to the start of the category record
     auto categoryRecordPool = reinterpret_cast<unsigned char*>(categoryRecord.data());
 
@@ -978,20 +980,20 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
     uint32_t eventRecord0Offset = categoryRecordPool[eventPointerTableOffset + 0 * uint32_t_size];
     uint32_t eventRecord1Offset = categoryRecordPool[eventPointerTableOffset + 1 * uint32_t_size];
     uint32_t eventRecord2Offset = categoryRecordPool[eventPointerTableOffset + 2 * uint32_t_size];
-    BOOST_CHECK(eventRecord0Offset == 32);
-    BOOST_CHECK(eventRecord1Offset == 120);
-    BOOST_CHECK(eventRecord2Offset == 200);
+    CHECK(eventRecord0Offset == 32);
+    CHECK(eventRecord1Offset == 120);
+    CHECK(eventRecord2Offset == 200);
 
     // The length of the SWTrace namestring (name)
-    BOOST_CHECK(categoryRecordPool[categoryNameOffset] == categoryName.size() + 1);
+    CHECK(categoryRecordPool[categoryNameOffset] == categoryName.size() + 1);
     // The category name
-    BOOST_CHECK(std::memcmp(categoryRecordPool +
+    CHECK(std::memcmp(categoryRecordPool +
                             categoryNameOffset + // Offset
                             uint32_t_size, // The length of the name
                             categoryName.data(),
                             categoryName.size()) == 0); // name
     // The null-terminator at the end of the name
-    BOOST_CHECK(categoryRecordPool[categoryNameOffset + uint32_t_size + categoryName.size()] == '\0');
+    CHECK(categoryRecordPool[categoryNameOffset + uint32_t_size + categoryName.size()] == '\0');
 
     // For brevity, checking only the UIDs, max counter UIDs and names of the counters in the event records,
     // as the event records already have a number of unit tests dedicated to them
@@ -1000,22 +1002,22 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
     uint16_t eventRecord0Word0[2] = { 0u, 0u };
     std::memcpy(eventRecord0Word0, categoryRecordPool + categoryRecordBlockSize + eventRecord0Offset,
                 sizeof(eventRecord0Word0));
-    BOOST_CHECK(eventRecord0Word0[0] == counter1->m_Uid);
-    BOOST_CHECK(eventRecord0Word0[1] == counter1->m_MaxCounterUid);
+    CHECK(eventRecord0Word0[0] == counter1->m_Uid);
+    CHECK(eventRecord0Word0[1] == counter1->m_MaxCounterUid);
 
     // Counter1 name
     uint32_t counter1NameOffset = 0;
     std::memcpy(&counter1NameOffset, categoryRecordPool  + eventRecord0Offset + 5u * uint32_t_size, uint32_t_size);
-    BOOST_CHECK(counter1NameOffset == 0);
+    CHECK(counter1NameOffset == 0);
     // The length of the SWTrace string (name)
-    BOOST_CHECK(categoryRecordPool[eventRecord0Offset +       // Offset to the event record
+    CHECK(categoryRecordPool[eventRecord0Offset +       // Offset to the event record
                                    categoryRecordBlockSize  + // Offset to the end of the category record block
                                    8u * uint32_t_size +       // Offset to the event record pool
                                    counter1NameOffset         // Offset to the name of the counter
                                   ] == counter1->m_Name.size() + 1); // The length of the name including the
                                                                      // null-terminator
     // The counter1 name
-    BOOST_CHECK(std::memcmp(categoryRecordPool +      // The beginning of the category pool
+    CHECK(std::memcmp(categoryRecordPool +      // The beginning of the category pool
                             categoryRecordBlockSize + // Offset to the end of the category record block
                             eventRecord0Offset +      // Offset to the event record
                             8u * uint32_t_size +      // Offset to the event record pool
@@ -1024,7 +1026,7 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
                             counter1->m_Name.data(),
                             counter1->m_Name.size()) == 0); // name
     // The null-terminator at the end of the counter1 name
-    BOOST_CHECK(categoryRecordPool[eventRecord0Offset +      // Offset to the event record
+    CHECK(categoryRecordPool[eventRecord0Offset +      // Offset to the event record
                                    categoryRecordBlockSize + // Offset to the end of the category record block
                                    8u * uint32_t_size +      // Offset to the event record pool
                                    counter1NameOffset +      // Offset to the name of the counter
@@ -1039,16 +1041,16 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
                                      eventRecord1Offset +
                                      5u * uint32_t_size,
                                      uint32_t_size);
-    BOOST_CHECK(counter2NameOffset == 8u * uint32_t_size );
+    CHECK(counter2NameOffset == 8u * uint32_t_size );
     // The length of the SWTrace string (name)
 
-    BOOST_CHECK(categoryRecordPool[eventRecord1Offset + // Offset to the event record
+    CHECK(categoryRecordPool[eventRecord1Offset + // Offset to the event record
                                    categoryRecordBlockSize +
                                    counter2NameOffset   // Offset to the name of the counter
                                   ] == counter2->m_Name.size() + 1); // The length of the name including the
                                                                      // null-terminator
     // The counter2 name
-    BOOST_CHECK(std::memcmp(categoryRecordPool +      // The beginning of the category pool
+    CHECK(std::memcmp(categoryRecordPool +      // The beginning of the category pool
                             categoryRecordBlockSize + // Offset to the end of the category record block
                             eventRecord1Offset +      // Offset to the event record
                             counter2NameOffset +      // Offset to the name of the counter
@@ -1058,7 +1060,7 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
 
 
     // The null-terminator at the end of the counter2 name
-    BOOST_CHECK(categoryRecordPool[eventRecord1Offset +      // Offset to the event record
+    CHECK(categoryRecordPool[eventRecord1Offset +      // Offset to the event record
                                    categoryRecordBlockSize + // Offset to the end of the category record block
                                    counter2NameOffset +      // Offset to the name of the counter
                                    uint32_t_size +           // The length of the name
@@ -1068,16 +1070,16 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
     // Counter3 name
     uint32_t counter3NameOffset = 0;
     std::memcpy(&counter3NameOffset, categoryRecordPool + eventRecord2Offset + 5u * uint32_t_size, uint32_t_size);
-    BOOST_CHECK(counter3NameOffset == 0);
+    CHECK(counter3NameOffset == 0);
     // The length of the SWTrace string (name)
-    BOOST_CHECK(categoryRecordPool[eventRecord2Offset + // Offset to the event record
+    CHECK(categoryRecordPool[eventRecord2Offset + // Offset to the event record
                                    categoryRecordBlockSize +
                                    8u * uint32_t_size + // Offset to the event record pool
                                    counter3NameOffset   // Offset to the name of the counter
                                   ] == counter3->m_Name.size() + 1); // The length of the name including the
                                                                      // null-terminator
     // The counter3 name
-    BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool
+    CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool
                             categoryRecordBlockSize +
                             eventRecord2Offset + // Offset to the event record
                             8u * uint32_t_size + // Offset to the event record pool
@@ -1086,7 +1088,7 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
                             counter3->m_Name.data(),
                             counter3->m_Name.size()) == 0); // name
     // The null-terminator at the end of the counter3 name
-    BOOST_CHECK(categoryRecordPool[eventRecord2Offset +    // Offset to the event record
+    CHECK(categoryRecordPool[eventRecord2Offset +    // Offset to the event record
                                    categoryRecordBlockSize +
                                    8u * uint32_t_size +    // Offset to the event record pool
                                    counter3NameOffset +    // Offset to the name of the counter
@@ -1095,7 +1097,7 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest)
                                    ] == '\0');
 }
 
-BOOST_AUTO_TEST_CASE(CreateInvalidCategoryRecordTest1)
+TEST_CASE("CreateInvalidCategoryRecordTest1")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -1103,7 +1105,7 @@ BOOST_AUTO_TEST_CASE(CreateInvalidCategoryRecordTest1)
     // Create a category for testing
     const std::string categoryName = "some invalid category";
     const CategoryPtr category = std::make_unique<Category>(categoryName);
-    BOOST_CHECK(category);
+    CHECK(category);
 
     // Create a category record
     Counters counters;
@@ -1111,12 +1113,12 @@ BOOST_AUTO_TEST_CASE(CreateInvalidCategoryRecordTest1)
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateCategoryRecordTest(category, counters, categoryRecord, errorMessage);
 
-    BOOST_CHECK(!result);
-    BOOST_CHECK(!errorMessage.empty());
-    BOOST_CHECK(categoryRecord.empty());
+    CHECK(!result);
+    CHECK(!errorMessage.empty());
+    CHECK(categoryRecord.empty());
 }
 
-BOOST_AUTO_TEST_CASE(CreateInvalidCategoryRecordTest2)
+TEST_CASE("CreateInvalidCategoryRecordTest2")
 {
     MockBufferManager mockBuffer(0);
     SendCounterPacketTest sendCounterPacketTest(mockBuffer);
@@ -1124,7 +1126,7 @@ BOOST_AUTO_TEST_CASE(CreateInvalidCategoryRecordTest2)
     // Create a category for testing
     const std::string categoryName = "some_category";
     const CategoryPtr category = std::make_unique<Category>(categoryName);
-    BOOST_CHECK(category);
+    CHECK(category);
     category->m_Counters = { 11u, 23u, 5670u };
 
     // Create a collection of counters
@@ -1143,19 +1145,19 @@ BOOST_AUTO_TEST_CASE(CreateInvalidCategoryRecordTest2)
                                                                                 0))));
 
     Counter* counter1 = counters.find(11)->second.get();
-    BOOST_CHECK(counter1);
+    CHECK(counter1);
 
     // Create a category record
     SendCounterPacket::CategoryRecord categoryRecord;
     std::string errorMessage;
     bool result = sendCounterPacketTest.CreateCategoryRecordTest(category, counters, categoryRecord, errorMessage);
 
-    BOOST_CHECK(!result);
-    BOOST_CHECK(!errorMessage.empty());
-    BOOST_CHECK(categoryRecord.empty());
+    CHECK(!result);
+    CHECK(!errorMessage.empty());
+    CHECK(categoryRecord.empty());
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest1)
+TEST_CASE("SendCounterDirectoryPacketTest1")
 {
     // The counter directory used for testing
     CounterDirectory counterDirectory;
@@ -1163,25 +1165,25 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest1)
     // Register a device
     const std::string device1Name = "device1";
     const Device* device1 = nullptr;
-    BOOST_CHECK_NO_THROW(device1 = counterDirectory.RegisterDevice(device1Name, 3));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device1);
+    CHECK_NOTHROW(device1 = counterDirectory.RegisterDevice(device1Name, 3));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device1);
 
     // Register a device
     const std::string device2Name = "device2";
     const Device* device2 = nullptr;
-    BOOST_CHECK_NO_THROW(device2 = counterDirectory.RegisterDevice(device2Name));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
-    BOOST_CHECK(device2);
+    CHECK_NOTHROW(device2 = counterDirectory.RegisterDevice(device2Name));
+    CHECK(counterDirectory.GetDeviceCount() == 2);
+    CHECK(device2);
 
     // Buffer with not enough space
     MockBufferManager mockBuffer(10);
     SendCounterPacket sendCounterPacket(mockBuffer);
-    BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory),
+    CHECK_THROWS_AS(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory),
                       armnn::profiling::BufferExhaustion);
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
+TEST_CASE("SendCounterDirectoryPacketTest2")
 {
     // The counter directory used for testing
     CounterDirectory counterDirectory;
@@ -1189,43 +1191,43 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
     // Register a device
     const std::string device1Name = "device1";
     const Device* device1 = nullptr;
-    BOOST_CHECK_NO_THROW(device1 = counterDirectory.RegisterDevice(device1Name, 3));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device1);
+    CHECK_NOTHROW(device1 = counterDirectory.RegisterDevice(device1Name, 3));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device1);
 
     // Register a device
     const std::string device2Name = "device2";
     const Device* device2 = nullptr;
-    BOOST_CHECK_NO_THROW(device2 = counterDirectory.RegisterDevice(device2Name));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
-    BOOST_CHECK(device2);
+    CHECK_NOTHROW(device2 = counterDirectory.RegisterDevice(device2Name));
+    CHECK(counterDirectory.GetDeviceCount() == 2);
+    CHECK(device2);
 
     // Register a counter set
     const std::string counterSet1Name = "counterset1";
     const CounterSet* counterSet1 = nullptr;
-    BOOST_CHECK_NO_THROW(counterSet1 = counterDirectory.RegisterCounterSet(counterSet1Name));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(counterSet1);
+    CHECK_NOTHROW(counterSet1 = counterDirectory.RegisterCounterSet(counterSet1Name));
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(counterSet1);
 
     // Register a category associated to "device1" and "counterset1"
     const std::string category1Name = "category1";
     const Category* category1 = nullptr;
-    BOOST_CHECK_NO_THROW(category1 = counterDirectory.RegisterCategory(category1Name));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category1);
+    CHECK_NOTHROW(category1 = counterDirectory.RegisterCategory(category1Name));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category1);
 
     // Register a category not associated to "device2" but no counter set
     const std::string category2Name = "category2";
     const Category* category2 = nullptr;
-    BOOST_CHECK_NO_THROW(category2 = counterDirectory.RegisterCategory(category2Name));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
-    BOOST_CHECK(category2);
+    CHECK_NOTHROW(category2 = counterDirectory.RegisterCategory(category2Name));
+    CHECK(counterDirectory.GetCategoryCount() == 2);
+    CHECK(category2);
 
     uint16_t numberOfCores = 4;
 
     // Register a counter associated to "category1"
     const Counter* counter1 = nullptr;
-    BOOST_CHECK_NO_THROW(counter1 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counter1 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                      0,
                                                                      category1Name,
                                                                      0,
@@ -1235,12 +1237,12 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
                                                                      "counter1description",
                                                                      std::string("counter1units"),
                                                                      numberOfCores));
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 4);
-    BOOST_CHECK(counter1);
+    CHECK(counterDirectory.GetCounterCount() == 4);
+    CHECK(counter1);
 
     // Register a counter associated to "category1"
     const Counter* counter2 = nullptr;
-    BOOST_CHECK_NO_THROW(counter2 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counter2 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                      4,
                                                                      category1Name,
                                                                      1,
@@ -1252,12 +1254,12 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
                                                                      armnn::EmptyOptional(),
                                                                      device2->m_Uid,
                                                                      0));
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 5);
-    BOOST_CHECK(counter2);
+    CHECK(counterDirectory.GetCounterCount() == 5);
+    CHECK(counter2);
 
     // Register a counter associated to "category2"
     const Counter* counter3 = nullptr;
-    BOOST_CHECK_NO_THROW(counter3 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counter3 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                      5,
                                                                      category2Name,
                                                                      1,
@@ -1269,13 +1271,13 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
                                                                      numberOfCores,
                                                                      device2->m_Uid,
                                                                      counterSet1->m_Uid));
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 9);
-    BOOST_CHECK(counter3);
+    CHECK(counterDirectory.GetCounterCount() == 9);
+    CHECK(counter3);
 
     // Buffer with enough space
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(mockBuffer);
-    BOOST_CHECK_NO_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory));
+    CHECK_NOTHROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory));
 
     // Get the readable buffer
     auto readBuffer = mockBuffer.GetReadableBuffer();
@@ -1283,9 +1285,9 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
     // Check the packet header
     const uint32_t packetHeaderWord0 = ReadUint32(readBuffer, 0);
     const uint32_t packetHeaderWord1 = ReadUint32(readBuffer, 4);
-    BOOST_TEST(((packetHeaderWord0 >> 26) & 0x3F) == 0);  // packet_family
-    BOOST_TEST(((packetHeaderWord0 >> 16) & 0x3FF) == 2); // packet_id
-    BOOST_TEST(packetHeaderWord1 == 432);                 // data_length
+    CHECK(((packetHeaderWord0 >> 26) & 0x3F) == 0);  // packet_family
+    CHECK(((packetHeaderWord0 >> 16) & 0x3FF) == 2); // packet_id
+    CHECK(packetHeaderWord1 == 432);                 // data_length
 
     // Check the body header
     const uint32_t bodyHeaderWord0 = ReadUint32(readBuffer,  8);
@@ -1297,28 +1299,28 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
     const uint16_t deviceRecordCount     = static_cast<uint16_t>(bodyHeaderWord0 >> 16);
     const uint16_t counterSetRecordCount = static_cast<uint16_t>(bodyHeaderWord2 >> 16);
     const uint16_t categoryRecordCount   = static_cast<uint16_t>(bodyHeaderWord4 >> 16);
-    BOOST_TEST(deviceRecordCount == 2);                      // device_records_count
-    BOOST_TEST(bodyHeaderWord1 == bodyHeaderSize * 4);           // device_records_pointer_table_offset
-    BOOST_TEST(counterSetRecordCount == 1);                  // counter_set_count
-    BOOST_TEST(bodyHeaderWord3 == 8 + bodyHeaderSize * 4);       // counter_set_pointer_table_offset
-    BOOST_TEST(categoryRecordCount == 2);                    // categories_count
-    BOOST_TEST(bodyHeaderWord5 == 12 + bodyHeaderSize * 4);      // categories_pointer_table_offset
+    CHECK(deviceRecordCount == 2);                      // device_records_count
+    CHECK(bodyHeaderWord1 == bodyHeaderSize * 4);           // device_records_pointer_table_offset
+    CHECK(counterSetRecordCount == 1);                  // counter_set_count
+    CHECK(bodyHeaderWord3 == 8 + bodyHeaderSize * 4);       // counter_set_pointer_table_offset
+    CHECK(categoryRecordCount == 2);                    // categories_count
+    CHECK(bodyHeaderWord5 == 12 + bodyHeaderSize * 4);      // categories_pointer_table_offset
 
     // Check the device records pointer table
     const uint32_t deviceRecordOffset0 = ReadUint32(readBuffer, 32);
     const uint32_t deviceRecordOffset1 = ReadUint32(readBuffer, 36);
-    BOOST_TEST(deviceRecordOffset0 == 20); // Device record offset for "device1"
-    BOOST_TEST(deviceRecordOffset1 == 40); // Device record offset for "device2"
+    CHECK(deviceRecordOffset0 == 20); // Device record offset for "device1"
+    CHECK(deviceRecordOffset1 == 40); // Device record offset for "device2"
 
     // Check the counter set pointer table
     const uint32_t counterSetRecordOffset0 = ReadUint32(readBuffer, 40);
-    BOOST_TEST(counterSetRecordOffset0 == 52); // Counter set record offset for "counterset1"
+    CHECK(counterSetRecordOffset0 == 52); // Counter set record offset for "counterset1"
 
     // Check the category pointer table
     const uint32_t categoryRecordOffset0 = ReadUint32(readBuffer, 44);
     const uint32_t categoryRecordOffset1 = ReadUint32(readBuffer, 48);
-    BOOST_TEST(categoryRecordOffset0 ==  72); // Category record offset for "category1"
-    BOOST_TEST(categoryRecordOffset1 == 176); // Category record offset for "category2"
+    CHECK(categoryRecordOffset0 ==  72); // Category record offset for "category1"
+    CHECK(categoryRecordOffset1 == 176); // Category record offset for "category2"
 
     // Get the device record pool offset
     const uint32_t uint32_t_size = sizeof(uint32_t);
@@ -1373,7 +1375,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
         deviceRecord.name_length = deviceRecordNameLength; // name_length
         unsigned char deviceRecordNameNullTerminator = // name null-terminator
                 ReadUint8(readBuffer, deviceRecordPoolOffset + uint32_t_size + deviceRecordNameLength - 1);
-        BOOST_CHECK(deviceRecordNameNullTerminator == '\0');
+        CHECK(deviceRecordNameNullTerminator == '\0');
         std::vector<unsigned char> deviceRecordNameBuffer(deviceRecord.name_length - 1);
         std::memcpy(deviceRecordNameBuffer.data(),
                     readData + deviceRecordPoolOffset + uint32_t_size, deviceRecordNameBuffer.size());
@@ -1383,14 +1385,14 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
     }
 
     // Check that the device records are correct
-    BOOST_CHECK(deviceRecords.size() == 2);
+    CHECK(deviceRecords.size() == 2);
     for (const DeviceRecord& deviceRecord : deviceRecords)
     {
         const Device* device = counterDirectory.GetDevice(deviceRecord.uid);
-        BOOST_CHECK(device);
-        BOOST_CHECK(device->m_Uid   == deviceRecord.uid);
-        BOOST_CHECK(device->m_Cores == deviceRecord.cores);
-        BOOST_CHECK(device->m_Name  == deviceRecord.name);
+        CHECK(device);
+        CHECK(device->m_Uid   == deviceRecord.uid);
+        CHECK(device->m_Cores == deviceRecord.cores);
+        CHECK(device->m_Name  == deviceRecord.name);
     }
 
 
@@ -1433,7 +1435,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
         counterSetRecord.name_length = counterSetRecordNameLength; // name_length
         unsigned char counterSetRecordNameNullTerminator = // name null-terminator
                 ReadUint8(readBuffer, counterSetRecordPoolOffset + uint32_t_size + counterSetRecordNameLength - 1);
-        BOOST_CHECK(counterSetRecordNameNullTerminator == '\0');
+        CHECK(counterSetRecordNameNullTerminator == '\0');
         std::vector<unsigned char> counterSetRecordNameBuffer(counterSetRecord.name_length - 1);
         std::memcpy(counterSetRecordNameBuffer.data(),
                     readData + counterSetRecordPoolOffset + uint32_t_size, counterSetRecordNameBuffer.size());
@@ -1443,14 +1445,14 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
     }
 
     // Check that the counter set records are correct
-    BOOST_CHECK(counterSetRecords.size() == 1);
+    CHECK(counterSetRecords.size() == 1);
     for (const CounterSetRecord& counterSetRecord : counterSetRecords)
     {
         const CounterSet* counterSet = counterDirectory.GetCounterSet(counterSetRecord.uid);
-        BOOST_CHECK(counterSet);
-        BOOST_CHECK(counterSet->m_Uid   == counterSetRecord.uid);
-        BOOST_CHECK(counterSet->m_Count == counterSetRecord.count);
-        BOOST_CHECK(counterSet->m_Name  == counterSetRecord.name);
+        CHECK(counterSet);
+        CHECK(counterSet->m_Uid   == counterSetRecord.uid);
+        CHECK(counterSet->m_Count == counterSetRecord.count);
+        CHECK(counterSet->m_Name  == counterSetRecord.name);
     }
 
     // Event record structure/collection used for testing
@@ -1517,7 +1519,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
                           categoryRecord.name_offset +
                           uint32_t_size +
                           categoryRecordNameLength - 1); // name null-terminator
-        BOOST_CHECK(categoryRecordNameNullTerminator == '\0');
+        CHECK(categoryRecordNameNullTerminator == '\0');
         std::vector<unsigned char> categoryRecordNameBuffer(categoryRecord.name_length - 1);
         std::memcpy(categoryRecordNameBuffer.data(),
                     readData +
@@ -1570,7 +1572,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
                               eventRecord.name_offset +
                               uint32_t_size +
                               eventRecordNameLength - 1); // name null-terminator
-            BOOST_CHECK(eventRecordNameNullTerminator == '\0');
+            CHECK(eventRecordNameNullTerminator == '\0');
             std::vector<unsigned char> eventRecordNameBuffer(eventRecord.name_length - 1);
             std::memcpy(eventRecordNameBuffer.data(),
                         readData +
@@ -1589,7 +1591,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
                               eventRecord.description_offset +
                               uint32_t_size +
                               eventRecordDescriptionLength - 1); // description null-terminator
-            BOOST_CHECK(eventRecordDescriptionNullTerminator == '\0');
+            CHECK(eventRecordDescriptionNullTerminator == '\0');
             std::vector<unsigned char> eventRecordDescriptionBuffer(eventRecord.description_length - 1);
             std::memcpy(eventRecordDescriptionBuffer.data(),
                         readData +
@@ -1611,7 +1613,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
                                   eventRecord.units_offset +
                                   uint32_t_size +
                                   eventRecordUnitsLength - 1); // units null-terminator
-                BOOST_CHECK(eventRecordUnitsNullTerminator == '\0');
+                CHECK(eventRecordUnitsNullTerminator == '\0');
                 std::vector<unsigned char> eventRecordUnitsBuffer(eventRecord.units_length - 1);
                 std::memcpy(eventRecordUnitsBuffer.data(),
                             readData +
@@ -1629,34 +1631,34 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2)
     }
 
     // Check that the category records are correct
-    BOOST_CHECK(categoryRecords.size() == 2);
+    CHECK(categoryRecords.size() == 2);
     for (const CategoryRecord& categoryRecord : categoryRecords)
     {
         const Category* category = counterDirectory.GetCategory(categoryRecord.name);
-        BOOST_CHECK(category);
-        BOOST_CHECK(category->m_Name == categoryRecord.name);
-        BOOST_CHECK(category->m_Counters.size() == categoryRecord.event_count + static_cast<size_t>(numberOfCores) -1);
-        BOOST_CHECK(category->m_Counters.size() == categoryRecord.event_count + static_cast<size_t>(numberOfCores) -1);
+        CHECK(category);
+        CHECK(category->m_Name == categoryRecord.name);
+        CHECK(category->m_Counters.size() == categoryRecord.event_count + static_cast<size_t>(numberOfCores) -1);
+        CHECK(category->m_Counters.size() == categoryRecord.event_count + static_cast<size_t>(numberOfCores) -1);
 
         // Check that the event records are correct
         for (const EventRecord& eventRecord : categoryRecord.event_records)
         {
             const Counter* counter = counterDirectory.GetCounter(eventRecord.counter_uid);
-            BOOST_CHECK(counter);
-            BOOST_CHECK(counter->m_MaxCounterUid == eventRecord.max_counter_uid);
-            BOOST_CHECK(counter->m_DeviceUid == eventRecord.device);
-            BOOST_CHECK(counter->m_CounterSetUid == eventRecord.counter_set);
-            BOOST_CHECK(counter->m_Class == eventRecord.counter_class);
-            BOOST_CHECK(counter->m_Interpolation == eventRecord.interpolation);
-            BOOST_CHECK(counter->m_Multiplier == eventRecord.multiplier);
-            BOOST_CHECK(counter->m_Name == eventRecord.name);
-            BOOST_CHECK(counter->m_Description == eventRecord.description);
-            BOOST_CHECK(counter->m_Units == eventRecord.units);
+            CHECK(counter);
+            CHECK(counter->m_MaxCounterUid == eventRecord.max_counter_uid);
+            CHECK(counter->m_DeviceUid == eventRecord.device);
+            CHECK(counter->m_CounterSetUid == eventRecord.counter_set);
+            CHECK(counter->m_Class == eventRecord.counter_class);
+            CHECK(counter->m_Interpolation == eventRecord.interpolation);
+            CHECK(counter->m_Multiplier == eventRecord.multiplier);
+            CHECK(counter->m_Name == eventRecord.name);
+            CHECK(counter->m_Description == eventRecord.description);
+            CHECK(counter->m_Units == eventRecord.units);
         }
     }
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest3)
+TEST_CASE("SendCounterDirectoryPacketTest3")
 {
     // Using a mock counter directory that allows to register invalid objects
     MockCounterDirectory counterDirectory;
@@ -1664,17 +1666,17 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest3)
     // Register an invalid device
     const std::string deviceName = "inv@lid dev!c€";
     const Device* device = nullptr;
-    BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName, 3));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device);
+    CHECK_NOTHROW(device = counterDirectory.RegisterDevice(deviceName, 3));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device);
 
     // Buffer with enough space
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(mockBuffer);
-    BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
+    CHECK_THROWS_AS(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest4)
+TEST_CASE("SendCounterDirectoryPacketTest4")
 {
     // Using a mock counter directory that allows to register invalid objects
     MockCounterDirectory counterDirectory;
@@ -1682,17 +1684,17 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest4)
     // Register an invalid counter set
     const std::string counterSetName = "inv@lid count€rs€t";
     const CounterSet* counterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(counterSet);
+    CHECK_NOTHROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(counterSet);
 
     // Buffer with enough space
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(mockBuffer);
-    BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
+    CHECK_THROWS_AS(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest5)
+TEST_CASE("SendCounterDirectoryPacketTest5")
 {
     // Using a mock counter directory that allows to register invalid objects
     MockCounterDirectory counterDirectory;
@@ -1700,17 +1702,17 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest5)
     // Register an invalid category
     const std::string categoryName = "c@t€gory";
     const Category* category = nullptr;
-    BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category);
+    CHECK_NOTHROW(category = counterDirectory.RegisterCategory(categoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category);
 
     // Buffer with enough space
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(mockBuffer);
-    BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
+    CHECK_THROWS_AS(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest6)
+TEST_CASE("SendCounterDirectoryPacketTest6")
 {
     // Using a mock counter directory that allows to register invalid objects
     MockCounterDirectory counterDirectory;
@@ -1718,31 +1720,31 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest6)
     // Register an invalid device
     const std::string deviceName = "inv@lid dev!c€";
     const Device* device = nullptr;
-    BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName, 3));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device);
+    CHECK_NOTHROW(device = counterDirectory.RegisterDevice(deviceName, 3));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device);
 
     // Register an invalid counter set
     const std::string counterSetName = "inv@lid count€rs€t";
     const CounterSet* counterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(counterSet);
+    CHECK_NOTHROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(counterSet);
 
     // Register an invalid category associated to an invalid device and an invalid counter set
     const std::string categoryName = "c@t€gory";
     const Category* category = nullptr;
-    BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category);
+    CHECK_NOTHROW(category = counterDirectory.RegisterCategory(categoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category);
 
     // Buffer with enough space
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(mockBuffer);
-    BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
+    CHECK_THROWS_AS(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest7)
+TEST_CASE("SendCounterDirectoryPacketTest7")
 {
     // Using a mock counter directory that allows to register invalid objects
     MockCounterDirectory counterDirectory;
@@ -1750,27 +1752,27 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest7)
     // Register an valid device
     const std::string deviceName = "valid device";
     const Device* device = nullptr;
-    BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName, 3));
-    BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
-    BOOST_CHECK(device);
+    CHECK_NOTHROW(device = counterDirectory.RegisterDevice(deviceName, 3));
+    CHECK(counterDirectory.GetDeviceCount() == 1);
+    CHECK(device);
 
     // Register an valid counter set
     const std::string counterSetName = "valid counterset";
     const CounterSet* counterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
-    BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
-    BOOST_CHECK(counterSet);
+    CHECK_NOTHROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
+    CHECK(counterDirectory.GetCounterSetCount() == 1);
+    CHECK(counterSet);
 
     // Register an valid category associated to a valid device and a valid counter set
     const std::string categoryName = "category";
     const Category* category = nullptr;
-    BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
-    BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
-    BOOST_CHECK(category);
+    CHECK_NOTHROW(category = counterDirectory.RegisterCategory(categoryName));
+    CHECK(counterDirectory.GetCategoryCount() == 1);
+    CHECK(category);
 
     // Register an invalid counter associated to a valid category
     const Counter* counter = nullptr;
-    BOOST_CHECK_NO_THROW(counter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
+    CHECK_NOTHROW(counter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
                                                                     0,
                                                                     categoryName,
                                                                     0,
@@ -1782,16 +1784,16 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest7)
                                                                     5,
                                                                     device->m_Uid,
                                                                     counterSet->m_Uid));
-    BOOST_CHECK(counterDirectory.GetCounterCount() == 5);
-    BOOST_CHECK(counter);
+    CHECK(counterDirectory.GetCounterCount() == 5);
+    CHECK(counter);
 
     // Buffer with enough space
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(mockBuffer);
-    BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
+    CHECK_THROWS_AS(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadTest0)
+TEST_CASE("SendThreadTest0")
 {
     ProfilingStateMachine profilingStateMachine;
     SetActiveProfilingState(profilingStateMachine);
@@ -1804,18 +1806,18 @@ BOOST_AUTO_TEST_CASE(SendThreadTest0)
     // Try to start the send thread many times, it must only start once
 
     sendThread.Start(mockProfilingConnection);
-    BOOST_CHECK(sendThread.IsRunning());
+    CHECK(sendThread.IsRunning());
     sendThread.Start(mockProfilingConnection);
     sendThread.Start(mockProfilingConnection);
     sendThread.Start(mockProfilingConnection);
     sendThread.Start(mockProfilingConnection);
-    BOOST_CHECK(sendThread.IsRunning());
+    CHECK(sendThread.IsRunning());
 
     sendThread.Stop();
-    BOOST_CHECK(!sendThread.IsRunning());
+    CHECK(!sendThread.IsRunning());
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadTest1)
+TEST_CASE("SendThreadTest1")
 {
     ProfilingStateMachine profilingStateMachine;
     SetActiveProfilingState(profilingStateMachine);
@@ -1918,12 +1920,12 @@ BOOST_AUTO_TEST_CASE(SendThreadTest1)
 
     sendThread.Stop();
 
-    BOOST_CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadableSize()  == totalWrittenSize);
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadSize()      == totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetReadableSize()  == totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetReadSize()      == totalWrittenSize);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadTest2)
+TEST_CASE("SendThreadTest2")
 {
     ProfilingStateMachine profilingStateMachine;
     SetActiveProfilingState(profilingStateMachine);
@@ -2036,12 +2038,12 @@ BOOST_AUTO_TEST_CASE(SendThreadTest2)
     // read all what's remaining in the buffer
     sendThread.Stop();
 
-    BOOST_CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadableSize()  == totalWrittenSize);
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadSize()      == totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetReadableSize()  == totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetReadSize()      == totalWrittenSize);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadTest3)
+TEST_CASE("SendThreadTest3")
 {
     ProfilingStateMachine profilingStateMachine;
     SetActiveProfilingState(profilingStateMachine);
@@ -2137,14 +2139,14 @@ BOOST_AUTO_TEST_CASE(SendThreadTest3)
     // thread is not guaranteed to flush the buffer)
     sendThread.Stop();
 
-    BOOST_CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadableSize()  <= totalWrittenSize);
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadSize()      <= totalWrittenSize);
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadSize()      <= mockStreamCounterBuffer.GetReadableSize());
-    BOOST_CHECK(mockStreamCounterBuffer.GetReadSize()      <= mockStreamCounterBuffer.GetCommittedSize());
+    CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetReadableSize()  <= totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetReadSize()      <= totalWrittenSize);
+    CHECK(mockStreamCounterBuffer.GetReadSize()      <= mockStreamCounterBuffer.GetReadableSize());
+    CHECK(mockStreamCounterBuffer.GetReadSize()      <= mockStreamCounterBuffer.GetCommittedSize());
 }
 
-BOOST_AUTO_TEST_CASE(SendCounterPacketTestWithSendThread)
+TEST_CASE("SendCounterPacketTestWithSendThread")
 {
     ProfilingStateMachine profilingStateMachine;
     SetWaitingForAckProfilingState(profilingStateMachine);
@@ -2160,7 +2162,7 @@ BOOST_AUTO_TEST_CASE(SendCounterPacketTestWithSendThread)
     sendThread.Stop();
 
     // check for packet in ProfilingConnection
-    BOOST_CHECK(mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize}) == 1);
+    CHECK(mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize}) == 1);
 
     SetActiveProfilingState(profilingStateMachine);
     sendThread.Start(mockProfilingConnection);
@@ -2172,7 +2174,7 @@ BOOST_AUTO_TEST_CASE(SendCounterPacketTestWithSendThread)
     sendThread.Stop();
     unsigned int counterDirectoryPacketSize = 32;
     // check for packet in ProfilingConnection
-    BOOST_CHECK(mockProfilingConnection.CheckForPacket(
+    CHECK(mockProfilingConnection.CheckForPacket(
         {PacketType::CounterDirectory, counterDirectoryPacketSize}) == 1);
 
     sendThread.Start(mockProfilingConnection);
@@ -2187,11 +2189,11 @@ BOOST_AUTO_TEST_CASE(SendCounterPacketTestWithSendThread)
     sendThread.Stop();
 
     unsigned int periodicCounterCapturePacketSize = 28;
-    BOOST_CHECK(mockProfilingConnection.CheckForPacket(
+    CHECK(mockProfilingConnection.CheckForPacket(
         {PacketType::PeriodicCounterCapture, periodicCounterCapturePacketSize}) == 1);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadBufferTest)
+TEST_CASE("SendThreadBufferTest")
 {
     ProfilingStateMachine profilingStateMachine;
     SetActiveProfilingState(profilingStateMachine);
@@ -2208,10 +2210,10 @@ BOOST_AUTO_TEST_CASE(SendThreadBufferTest)
     // Read data from the buffer
     // Buffer should become readable after commit by SendStreamMetaDataPacket
     auto packetBuffer = bufferManager.GetReadableBuffer();
-    BOOST_TEST(packetBuffer.get());
+    CHECK(packetBuffer.get());
 
     unsigned int streamMetadataPacketsize = GetStreamMetaDataPacketSize();
-    BOOST_TEST(packetBuffer->GetSize() == streamMetadataPacketsize);
+    CHECK(packetBuffer->GetSize() == streamMetadataPacketsize);
 
     // Recommit to be read by sendCounterPacket
     bufferManager.Commit(packetBuffer, streamMetadataPacketsize);
@@ -2231,26 +2233,26 @@ BOOST_AUTO_TEST_CASE(SendThreadBufferTest)
 
     // The buffer is read by the send thread so it should not be in the readable buffer.
     auto readBuffer = bufferManager.GetReadableBuffer();
-    BOOST_TEST(!readBuffer);
+    CHECK(!readBuffer);
 
     // Successfully reserved the buffer with requested size
     unsigned int reservedSize = 0;
     auto reservedBuffer = bufferManager.Reserve(512, reservedSize);
-    BOOST_TEST(reservedSize == 512);
-    BOOST_TEST(reservedBuffer.get());
+    CHECK(reservedSize == 512);
+    CHECK(reservedBuffer.get());
 
     const auto writtenDataSize = mockProfilingConnection.GetWrittenDataSize();
     const auto metaDataPacketCount =
             mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize});
 
-    BOOST_TEST(metaDataPacketCount >= 1);
-    BOOST_TEST(mockProfilingConnection.CheckForPacket({PacketType::CounterDirectory, 32}) == 1);
-    BOOST_TEST(mockProfilingConnection.CheckForPacket({PacketType::PeriodicCounterCapture, 28}) == 1);
+    CHECK(metaDataPacketCount >= 1);
+    CHECK(mockProfilingConnection.CheckForPacket({PacketType::CounterDirectory, 32}) == 1);
+    CHECK(mockProfilingConnection.CheckForPacket({PacketType::PeriodicCounterCapture, 28}) == 1);
     // Check that we only received the packets we expected
-    BOOST_TEST(metaDataPacketCount + 2 == writtenDataSize);
+    CHECK(metaDataPacketCount + 2 == writtenDataSize);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket1)
+TEST_CASE("SendThreadSendStreamMetadataPacket1")
 {
     ProfilingStateMachine profilingStateMachine;
 
@@ -2261,10 +2263,10 @@ BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket1)
     sendThread.Start(mockProfilingConnection);
 
     // The profiling state is set to "Uninitialized", so the send thread should throw an exception
-    BOOST_CHECK_THROW(sendThread.Stop(), armnn::RuntimeException);
+    CHECK_THROWS_AS(sendThread.Stop(), armnn::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket2)
+TEST_CASE("SendThreadSendStreamMetadataPacket2")
 {
     ProfilingStateMachine profilingStateMachine;
     SetNotConnectedProfilingState(profilingStateMachine);
@@ -2276,10 +2278,10 @@ BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket2)
     sendThread.Start(mockProfilingConnection);
 
     // The profiling state is set to "NotConnected", so the send thread should throw an exception
-    BOOST_CHECK_THROW(sendThread.Stop(), armnn::RuntimeException);
+    CHECK_THROWS_AS(sendThread.Stop(), armnn::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket3)
+TEST_CASE("SendThreadSendStreamMetadataPacket3")
 {
     ProfilingStateMachine profilingStateMachine;
     SetWaitingForAckProfilingState(profilingStateMachine);
@@ -2294,17 +2296,17 @@ BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket3)
 
     // The profiling state is set to "WaitingForAck", so the send thread should send a Stream Metadata packet
     // Wait for sendThread to join
-    BOOST_CHECK_NO_THROW(sendThread.Stop());
+    CHECK_NOTHROW(sendThread.Stop());
 
     // Check that the buffer contains at least one Stream Metadata packet and no other packets
     const auto writtenDataSize = mockProfilingConnection.GetWrittenDataSize();
 
-    BOOST_TEST(writtenDataSize >= 1u);
-    BOOST_TEST(mockProfilingConnection.CheckForPacket(
+    CHECK(writtenDataSize >= 1u);
+    CHECK(mockProfilingConnection.CheckForPacket(
                   {PacketType::StreamMetaData, streamMetadataPacketsize}) == writtenDataSize);
 }
 
-BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket4)
+TEST_CASE("SendThreadSendStreamMetadataPacket4")
 {
     ProfilingStateMachine profilingStateMachine;
     SetWaitingForAckProfilingState(profilingStateMachine);
@@ -2323,10 +2325,10 @@ BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket4)
 
     sendThread.Start(mockProfilingConnection);
     // Check that the profiling state is still "WaitingForAck"
-    BOOST_TEST((profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck));
+    CHECK((profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck));
 
     // Check that the buffer contains at least one Stream Metadata packet
-    BOOST_TEST(mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize}) >= 1);
+    CHECK(mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize}) >= 1);
 
     mockProfilingConnection.Clear();
 
@@ -2337,17 +2339,17 @@ BOOST_AUTO_TEST_CASE(SendThreadSendStreamMetadataPacket4)
     sendThread.SetReadyToRead();
 
     // Wait for sendThread to join
-    BOOST_CHECK_NO_THROW(sendThread.Stop());
+    CHECK_NOTHROW(sendThread.Stop());
 
     // Check that the profiling state is still "WaitingForAck"
-    BOOST_TEST((profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck));
+    CHECK((profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck));
 
     // Check that the buffer contains at least one Stream Metadata packet and no other packets
     const auto writtenDataSize = mockProfilingConnection.GetWrittenDataSize();
 
-    BOOST_TEST(writtenDataSize >= 1u);
-    BOOST_TEST(mockProfilingConnection.CheckForPacket(
+    CHECK(writtenDataSize >= 1u);
+    CHECK(mockProfilingConnection.CheckForPacket(
                   {PacketType::StreamMetaData, streamMetadataPacketsize}) == writtenDataSize);
 }
 
-BOOST_AUTO_TEST_SUITE_END()
+}