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 --- .../reference/test/RefTensorHandleTests.cpp | 109 +++++++++++---------- 1 file changed, 55 insertions(+), 54 deletions(-) (limited to 'src/backends/reference/test/RefTensorHandleTests.cpp') diff --git a/src/backends/reference/test/RefTensorHandleTests.cpp b/src/backends/reference/test/RefTensorHandleTests.cpp index dadd1de1f2..39f5a2aeed 100644 --- a/src/backends/reference/test/RefTensorHandleTests.cpp +++ b/src/backends/reference/test/RefTensorHandleTests.cpp @@ -5,12 +5,13 @@ #include #include -#include +#include -BOOST_AUTO_TEST_SUITE(RefTensorHandleTests) +TEST_SUITE("RefTensorHandleTests") +{ using namespace armnn; -BOOST_AUTO_TEST_CASE(AcquireAndRelease) +TEST_CASE("AcquireAndRelease") { std::shared_ptr memoryManager = std::make_shared(); @@ -24,11 +25,11 @@ BOOST_AUTO_TEST_CASE(AcquireAndRelease) { float* buffer = reinterpret_cast(handle.Map()); - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer + CHECK(buffer != nullptr); // Yields a valid pointer buffer[0] = 2.5f; - BOOST_CHECK(buffer[0] == 2.5f); // Memory is writable and readable + CHECK(buffer[0] == 2.5f); // Memory is writable and readable } memoryManager->Release(); @@ -37,16 +38,16 @@ BOOST_AUTO_TEST_CASE(AcquireAndRelease) { float* buffer = reinterpret_cast(handle.Map()); - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer + CHECK(buffer != nullptr); // Yields a valid pointer buffer[0] = 3.5f; - BOOST_CHECK(buffer[0] == 3.5f); // Memory is writable and readable + CHECK(buffer[0] == 3.5f); // Memory is writable and readable } memoryManager->Release(); } -BOOST_AUTO_TEST_CASE(RefTensorHandleFactoryMemoryManaged) +TEST_CASE("RefTensorHandleFactoryMemoryManaged") { std::shared_ptr memoryManager = std::make_shared(); RefTensorHandleFactory handleFactory(memoryManager); @@ -60,31 +61,31 @@ BOOST_AUTO_TEST_CASE(RefTensorHandleFactoryMemoryManaged) memoryManager->Acquire(); { float* buffer = reinterpret_cast(handle->Map()); - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer + CHECK(buffer != nullptr); // Yields a valid pointer buffer[0] = 1.5f; buffer[1] = 2.5f; - BOOST_CHECK(buffer[0] == 1.5f); // Memory is writable and readable - BOOST_CHECK(buffer[1] == 2.5f); // Memory is writable and readable + CHECK(buffer[0] == 1.5f); // Memory is writable and readable + CHECK(buffer[1] == 2.5f); // Memory is writable and readable } memoryManager->Release(); memoryManager->Acquire(); { float* buffer = reinterpret_cast(handle->Map()); - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer + CHECK(buffer != nullptr); // Yields a valid pointer buffer[0] = 3.5f; buffer[1] = 4.5f; - BOOST_CHECK(buffer[0] == 3.5f); // Memory is writable and readable - BOOST_CHECK(buffer[1] == 4.5f); // Memory is writable and readable + CHECK(buffer[0] == 3.5f); // Memory is writable and readable + CHECK(buffer[1] == 4.5f); // Memory is writable and readable } memoryManager->Release(); float testPtr[2] = { 2.5f, 5.5f }; // Cannot import as import is disabled - BOOST_CHECK(!handle->Import(static_cast(testPtr), MemorySource::Malloc)); + CHECK(!handle->Import(static_cast(testPtr), MemorySource::Malloc)); } -BOOST_AUTO_TEST_CASE(RefTensorHandleFactoryImport) +TEST_CASE("RefTensorHandleFactoryImport") { std::shared_ptr memoryManager = std::make_shared(); RefTensorHandleFactory handleFactory(memoryManager); @@ -97,25 +98,25 @@ BOOST_AUTO_TEST_CASE(RefTensorHandleFactoryImport) memoryManager->Acquire(); // No buffer allocated when import is enabled - BOOST_CHECK_THROW(handle->Map(), armnn::NullPointerException); + CHECK_THROWS_AS(handle->Map(), armnn::NullPointerException); float testPtr[2] = { 2.5f, 5.5f }; // Correctly import - BOOST_CHECK(handle->Import(static_cast(testPtr), MemorySource::Malloc)); + CHECK(handle->Import(static_cast(testPtr), MemorySource::Malloc)); float* buffer = reinterpret_cast(handle->Map()); - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer after import - BOOST_CHECK(buffer == testPtr); // buffer is pointing to testPtr + CHECK(buffer != nullptr); // Yields a valid pointer after import + CHECK(buffer == testPtr); // buffer is pointing to testPtr // Memory is writable and readable with correct value - BOOST_CHECK(buffer[0] == 2.5f); - BOOST_CHECK(buffer[1] == 5.5f); + CHECK(buffer[0] == 2.5f); + CHECK(buffer[1] == 5.5f); buffer[0] = 3.5f; buffer[1] = 10.0f; - BOOST_CHECK(buffer[0] == 3.5f); - BOOST_CHECK(buffer[1] == 10.0f); + CHECK(buffer[0] == 3.5f); + CHECK(buffer[1] == 10.0f); memoryManager->Release(); } -BOOST_AUTO_TEST_CASE(RefTensorHandleImport) +TEST_CASE("RefTensorHandleImport") { TensorInfo info({ 1, 1, 2, 1 }, DataType::Float32); RefTensorHandle handle(info, static_cast(MemorySource::Malloc)); @@ -124,24 +125,24 @@ BOOST_AUTO_TEST_CASE(RefTensorHandleImport) handle.Allocate(); // No buffer allocated when import is enabled - BOOST_CHECK_THROW(handle.Map(), armnn::NullPointerException); + CHECK_THROWS_AS(handle.Map(), armnn::NullPointerException); float testPtr[2] = { 2.5f, 5.5f }; // Correctly import - BOOST_CHECK(handle.Import(static_cast(testPtr), MemorySource::Malloc)); + CHECK(handle.Import(static_cast(testPtr), MemorySource::Malloc)); float* buffer = reinterpret_cast(handle.Map()); - BOOST_CHECK(buffer != nullptr); // Yields a valid pointer after import - BOOST_CHECK(buffer == testPtr); // buffer is pointing to testPtr + CHECK(buffer != nullptr); // Yields a valid pointer after import + CHECK(buffer == testPtr); // buffer is pointing to testPtr // Memory is writable and readable with correct value - BOOST_CHECK(buffer[0] == 2.5f); - BOOST_CHECK(buffer[1] == 5.5f); + CHECK(buffer[0] == 2.5f); + CHECK(buffer[1] == 5.5f); buffer[0] = 3.5f; buffer[1] = 10.0f; - BOOST_CHECK(buffer[0] == 3.5f); - BOOST_CHECK(buffer[1] == 10.0f); + CHECK(buffer[0] == 3.5f); + CHECK(buffer[1] == 10.0f); } -BOOST_AUTO_TEST_CASE(RefTensorHandleGetCapabilities) +TEST_CASE("RefTensorHandleGetCapabilities") { std::shared_ptr memoryManager = std::make_shared(); RefTensorHandleFactory handleFactory(memoryManager); @@ -155,10 +156,10 @@ BOOST_AUTO_TEST_CASE(RefTensorHandleGetCapabilities) std::vector capabilities = handleFactory.GetCapabilities(input, output, CapabilityClass::PaddingRequired); - BOOST_CHECK(capabilities.empty()); + CHECK(capabilities.empty()); } -BOOST_AUTO_TEST_CASE(RefTensorHandleSupportsInPlaceComputation) +TEST_CASE("RefTensorHandleSupportsInPlaceComputation") { std::shared_ptr memoryManager = std::make_shared(); RefTensorHandleFactory handleFactory(memoryManager); @@ -167,7 +168,7 @@ BOOST_AUTO_TEST_CASE(RefTensorHandleSupportsInPlaceComputation) ARMNN_ASSERT(!(handleFactory.SupportsInPlaceComputation())); } -BOOST_AUTO_TEST_CASE(TestManagedConstTensorHandle) +TEST_CASE("TestManagedConstTensorHandle") { // Initialize arguments void* mem = nullptr; @@ -178,31 +179,31 @@ BOOST_AUTO_TEST_CASE(TestManagedConstTensorHandle) // Test managed handle is initialized with m_Mapped unset and once Map() called its set ManagedConstTensorHandle managedHandle(passThroughHandle); - BOOST_CHECK(!managedHandle.IsMapped()); + CHECK(!managedHandle.IsMapped()); managedHandle.Map(); - BOOST_CHECK(managedHandle.IsMapped()); + CHECK(managedHandle.IsMapped()); // Test it can then be unmapped managedHandle.Unmap(); - BOOST_CHECK(!managedHandle.IsMapped()); + CHECK(!managedHandle.IsMapped()); // Test member function - BOOST_CHECK(managedHandle.GetTensorInfo() == info); + CHECK(managedHandle.GetTensorInfo() == info); // Test that nullptr tensor handle doesn't get mapped ManagedConstTensorHandle managedHandleNull(nullptr); - BOOST_CHECK(!managedHandleNull.IsMapped()); - BOOST_CHECK_THROW(managedHandleNull.Map(), armnn::Exception); - BOOST_CHECK(!managedHandleNull.IsMapped()); + CHECK(!managedHandleNull.IsMapped()); + CHECK_THROWS_AS(managedHandleNull.Map(), armnn::Exception); + CHECK(!managedHandleNull.IsMapped()); // Check Unmap() when m_Mapped already false managedHandleNull.Unmap(); - BOOST_CHECK(!managedHandleNull.IsMapped()); + CHECK(!managedHandleNull.IsMapped()); } #if !defined(__ANDROID__) // Only run these tests on non Android platforms -BOOST_AUTO_TEST_CASE(CheckSourceType) +TEST_CASE("CheckSourceType") { TensorInfo info({1}, DataType::Float32); RefTensorHandle handle(info, static_cast(MemorySource::Malloc)); @@ -210,18 +211,18 @@ BOOST_AUTO_TEST_CASE(CheckSourceType) int* testPtr = new int(4); // Not supported - BOOST_CHECK(!handle.Import(static_cast(testPtr), MemorySource::DmaBuf)); + CHECK(!handle.Import(static_cast(testPtr), MemorySource::DmaBuf)); // Not supported - BOOST_CHECK(!handle.Import(static_cast(testPtr), MemorySource::DmaBufProtected)); + CHECK(!handle.Import(static_cast(testPtr), MemorySource::DmaBufProtected)); // Supported - BOOST_CHECK(handle.Import(static_cast(testPtr), MemorySource::Malloc)); + CHECK(handle.Import(static_cast(testPtr), MemorySource::Malloc)); delete testPtr; } -BOOST_AUTO_TEST_CASE(ReusePointer) +TEST_CASE("ReusePointer") { TensorInfo info({1}, DataType::Float32); RefTensorHandle handle(info, static_cast(MemorySource::Malloc)); @@ -231,12 +232,12 @@ BOOST_AUTO_TEST_CASE(ReusePointer) handle.Import(static_cast(testPtr), MemorySource::Malloc); // Reusing previously Imported pointer - BOOST_CHECK(handle.Import(static_cast(testPtr), MemorySource::Malloc)); + CHECK(handle.Import(static_cast(testPtr), MemorySource::Malloc)); delete testPtr; } -BOOST_AUTO_TEST_CASE(MisalignedPointer) +TEST_CASE("MisalignedPointer") { TensorInfo info({2}, DataType::Float32); RefTensorHandle handle(info, static_cast(MemorySource::Malloc)); @@ -247,11 +248,11 @@ BOOST_AUTO_TEST_CASE(MisalignedPointer) // Increment pointer by 1 byte void* misalignedPtr = static_cast(reinterpret_cast(testPtr) + 1); - BOOST_CHECK(!handle.Import(misalignedPtr, MemorySource::Malloc)); + CHECK(!handle.Import(misalignedPtr, MemorySource::Malloc)); delete[] testPtr; } #endif -BOOST_AUTO_TEST_SUITE_END() +} -- cgit v1.2.1