From 1625efc870f1a8b7c6e6382277ddbb245f91a294 Mon Sep 17 00:00:00 2001 From: Sadik Armagan Date: Thu, 10 Jun 2021 18:24:34 +0100 Subject: IVGCVSW-5963 'Move unit tests to new framework' * Used doctest in ArmNN unit tests Signed-off-by: Sadik Armagan Change-Id: Ia9cf5fc72775878885c5f864abf2c56b3a935f1a --- src/profiling/test/ProfilingTests.cpp | 1908 +++++++++++++++++---------------- 1 file changed, 955 insertions(+), 953 deletions(-) (limited to 'src/profiling/test/ProfilingTests.cpp') 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 #include +#include + #include #include #include @@ -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 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 packetData0 = std::make_unique(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 packetDataA; std::unique_ptr 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& 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> periodIdMap; std::vector 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 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 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 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 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 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 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 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 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("")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("_")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("0123")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("valid_string")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("VALID_string_456")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString(" ")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("valid string")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("!$%")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("valid|\\~string#123")); + CHECK(arm::pipe::IsValidSwTraceString("")); + CHECK(arm::pipe::IsValidSwTraceString("_")); + CHECK(arm::pipe::IsValidSwTraceString("0123")); + CHECK(arm::pipe::IsValidSwTraceString("valid_string")); + CHECK(arm::pipe::IsValidSwTraceString("VALID_string_456")); + CHECK(arm::pipe::IsValidSwTraceString(" ")); + CHECK(arm::pipe::IsValidSwTraceString("valid string")); + CHECK(arm::pipe::IsValidSwTraceString("!$%")); + CHECK(arm::pipe::IsValidSwTraceString("valid|\\~string#123")); // Invalid SWTrace strings - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("€£")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("invalid‡string")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("12Ž34")); + CHECK(!arm::pipe::IsValidSwTraceString("€£")); + CHECK(!arm::pipe::IsValidSwTraceString("invalid‡string")); + CHECK(!arm::pipe::IsValidSwTraceString("12Ž34")); } -BOOST_AUTO_TEST_CASE(IsValidSwTraceNameStringTest) +TEST_CASE("IsValidSwTraceNameStringTest") { // Valid SWTrace name strings - BOOST_CHECK(arm::pipe::IsValidSwTraceString("")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("_")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("0123")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("valid_string")); - BOOST_CHECK(arm::pipe::IsValidSwTraceString("VALID_string_456")); + CHECK(arm::pipe::IsValidSwTraceString("")); + CHECK(arm::pipe::IsValidSwTraceString("_")); + CHECK(arm::pipe::IsValidSwTraceString("0123")); + CHECK(arm::pipe::IsValidSwTraceString("valid_string")); + CHECK(arm::pipe::IsValidSwTraceString("VALID_string_456")); // Invalid SWTrace name strings - BOOST_CHECK(!arm::pipe::IsValidSwTraceString(" ")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("invalid string")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("!$%")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("invalid|\\~string#123")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("€£")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("invalid‡string")); - BOOST_CHECK(!arm::pipe::IsValidSwTraceString("12Ž34")); + CHECK(!arm::pipe::IsValidSwTraceString(" ")); + CHECK(!arm::pipe::IsValidSwTraceString("invalid string")); + CHECK(!arm::pipe::IsValidSwTraceString("!$%")); + CHECK(!arm::pipe::IsValidSwTraceString("invalid|\\~string#123")); + CHECK(!arm::pipe::IsValidSwTraceString("€£")); + CHECK(!arm::pipe::IsValidSwTraceString("invalid‡string")); + CHECK(!arm::pipe::IsValidSwTraceString("12Ž34")); } template void StringToSwTraceStringTestHelper(const std::string& testString, std::vector buffer, size_t expectedSize) { // Convert the test string to a SWTrace string - BOOST_CHECK(arm::pipe::StringToSwTraceString(testString, buffer)); + CHECK(arm::pipe::StringToSwTraceString(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(buffer.data())[nullTerminatorIndex] == '\0'); + CHECK(reinterpret_cast(buffer.data())[nullTerminatorIndex] == '\0'); } -BOOST_AUTO_TEST_CASE(StringToSwTraceStringTest) +TEST_CASE("StringToSwTraceStringTest") { std::vector buffer; @@ -2247,15 +2249,15 @@ BOOST_AUTO_TEST_CASE(StringToSwTraceStringTest) StringToSwTraceStringTestHelper("valid|\\~string#123", buffer, 6); // Invalid SWTrace strings - BOOST_CHECK(!arm::pipe::StringToSwTraceString("€£", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("invalid‡string", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("12Ž34", buffer)); - BOOST_CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("€£", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("invalid‡string", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("12Ž34", buffer)); + CHECK(buffer.empty()); } -BOOST_AUTO_TEST_CASE(StringToSwTraceNameStringTest) +TEST_CASE("StringToSwTraceNameStringTest") { std::vector buffer; @@ -2267,23 +2269,23 @@ BOOST_AUTO_TEST_CASE(StringToSwTraceNameStringTest) StringToSwTraceStringTestHelper("VALID_string_456", buffer, 6); // Invalid SWTrace namestrings - BOOST_CHECK(!arm::pipe::StringToSwTraceString(" ", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("invalid string", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("!$%", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("invalid|\\~string#123", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("€£", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("invalid‡string", buffer)); - BOOST_CHECK(buffer.empty()); - BOOST_CHECK(!arm::pipe::StringToSwTraceString("12Ž34", buffer)); - BOOST_CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString(" ", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("invalid string", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("!$%", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("invalid|\\~string#123", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("€£", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("invalid‡string", buffer)); + CHECK(buffer.empty()); + CHECK(!arm::pipe::StringToSwTraceString("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(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(bodyHeader1Word0 >> 16); const uint16_t counterSetRecordCount = armnn::numeric_cast(bodyHeader1Word2 >> 16); const uint16_t categoryRecordCount = armnn::numeric_cast(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( 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(0, cpuRefId))); - BOOST_CHECK(counterIdMap.GetBackendId(1) == (std::pair(1, cpuRefId))); - BOOST_CHECK(counterIdMap.GetBackendId(2) == (std::pair(2, cpuRefId))); - BOOST_CHECK(counterIdMap.GetBackendId(3) == (std::pair(3, cpuRefId))); - BOOST_CHECK(counterIdMap.GetBackendId(4) == (std::pair(0, cpuAccId))); - BOOST_CHECK(counterIdMap.GetBackendId(5) == (std::pair(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(0, cpuRefId))); + CHECK(counterIdMap.GetBackendId(1) == (std::pair(1, cpuRefId))); + CHECK(counterIdMap.GetBackendId(2) == (std::pair(2, cpuRefId))); + CHECK(counterIdMap.GetBackendId(3) == (std::pair(3, cpuRefId))); + CHECK(counterIdMap.GetBackendId(4) == (std::pair(0, cpuAccId))); + CHECK(counterIdMap.GetBackendId(5) == (std::pair(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 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 cpuRefCounterStatus = backendProfilingCpuRef.GetActiveCounters(); std::vector 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() +} -- cgit v1.2.1