UnitTests.hpp File Reference

#include <armnn/Logging.hpp>
#include <armnn/Utils.hpp>
#include <reference/RefWorkloadFactory.hpp>
#include <reference/test/RefWorkloadFactoryHelper.hpp>
#include <backendsCommon/test/LayerTests.hpp>
#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
#include "TensorHelpers.hpp"
#include <doctest/doctest.h>

Go to the source code of this file.

Macros
#define	ARMNN_SIMPLE_TEST_CASE(TestName, TestFunction)
#define	ARMNN_AUTO_TEST_CASE(TestName, TestFunction, ...)
#define	ARMNN_AUTO_TEST_FIXTURE(TestName, Fixture, TestFunction, ...)
#define	ARMNN_AUTO_TEST_CASE_WITH_THF(TestName, TestFunction, ...)
#define	ARMNN_AUTO_TEST_FIXTURE_WITH_THF(TestName, Fixture, TestFunction, ...)
#define	ARMNN_COMPARE_REF_AUTO_TEST_CASE(TestName, TestFunction, ...)
#define	ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF(TestName, TestFunction, ...)
#define	ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(TestName, Fixture, TestFunction, ...)
#define	ARMNN_COMPARE_REF_FIXTURE_TEST_CASE_WITH_THF(TestName, Fixture, TestFunction, ...)

Functions
void	ConfigureLoggingTest ()
template<typename T , std::size_t n>
void	CompareTestResultIfSupported (const std::string &testName, const LayerTestResult< T, n > &testResult)
	Executes CHECK_MESSAGE on CompareTensors() return value so that the predicate_result message is reported. More...
template<typename T , std::size_t n>
void	CompareTestResultIfSupported (const std::string &testName, const std::vector< LayerTestResult< T, n >> &testResult)
template<typename FactoryType , typename TFuncPtr , typename... Args>
void	RunTestFunction (const char *testName, TFuncPtr testFunction, Args... args)
template<typename FactoryType , typename TFuncPtr , typename... Args>
void	RunTestFunctionUsingTensorHandleFactory (const char *testName, TFuncPtr testFunction, Args... args)
template<typename FactoryType , typename TFuncPtr , typename... Args>
void	CompareRefTestFunction (const char *testName, TFuncPtr testFunction, Args... args)
template<typename FactoryType , typename TFuncPtr , typename... Args>
void	CompareRefTestFunctionUsingTensorHandleFactory (const char *testName, TFuncPtr testFunction, Args... args)

Macro Definition Documentation

ARMNN_AUTO_TEST_CASE

#define ARMNN_AUTO_TEST_CASE	(		TestName,
			TestFunction,
			...
	)

Value:

TEST_CASE(#TestName) \
    { \
        RunTestFunction<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 114 of file UnitTests.hpp.

Referenced by TEST_SUITE().

ARMNN_AUTO_TEST_CASE_WITH_THF

#define ARMNN_AUTO_TEST_CASE_WITH_THF	(		TestName,
			TestFunction,
			...
	)

Value:

TEST_CASE(#TestName) \
    { \
        RunTestFunctionUsingTensorHandleFactory<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 126 of file UnitTests.hpp.

Referenced by TEST_SUITE().

ARMNN_AUTO_TEST_FIXTURE

#define ARMNN_AUTO_TEST_FIXTURE	(		TestName,
			Fixture,
			TestFunction,
			...
	)

Value:

TEST_CASE_FIXTURE(Fixture, #TestName) \
    { \
        RunTestFunction<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 120 of file UnitTests.hpp.

Referenced by TEST_SUITE().

ARMNN_AUTO_TEST_FIXTURE_WITH_THF

#define ARMNN_AUTO_TEST_FIXTURE_WITH_THF	(		TestName,
			Fixture,
			TestFunction,
			...
	)

Value:

TEST_CASE_FIXTURE(Fixture, #TestName) \
    { \
        RunTestFunctionUsingTensorHandleFactory<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 132 of file UnitTests.hpp.

Referenced by TEST_SUITE().

ARMNN_COMPARE_REF_AUTO_TEST_CASE

#define ARMNN_COMPARE_REF_AUTO_TEST_CASE	(		TestName,
			TestFunction,
			...
	)

Value:

TEST_CASE(#TestName) \
    { \
        CompareRefTestFunction<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 166 of file UnitTests.hpp.

ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF

#define ARMNN_COMPARE_REF_AUTO_TEST_CASE_WITH_THF	(		TestName,
			TestFunction,
			...
	)

Value:

TEST_CASE(#TestName) \
    { \
        CompareRefTestFunctionUsingTensorHandleFactory<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 172 of file UnitTests.hpp.

Referenced by TEST_SUITE().

ARMNN_COMPARE_REF_FIXTURE_TEST_CASE

#define ARMNN_COMPARE_REF_FIXTURE_TEST_CASE	(		TestName,
			Fixture,
			TestFunction,
			...
	)

Value:

TEST_CASE_FIXTURE(Fixture, #TestName) \
    { \
        CompareRefTestFunction<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 178 of file UnitTests.hpp.

ARMNN_COMPARE_REF_FIXTURE_TEST_CASE_WITH_THF

#define ARMNN_COMPARE_REF_FIXTURE_TEST_CASE_WITH_THF	(		TestName,
			Fixture,
			TestFunction,
			...
	)

Value:

TEST_CASE_FIXTURE(Fixture, #TestName) \
    { \
        CompareRefTestFunctionUsingTensorHandleFactory<FactoryType>(#TestName, &TestFunction, ##__VA_ARGS__); \
    }

Definition at line 184 of file UnitTests.hpp.

Referenced by TEST_SUITE().

ARMNN_SIMPLE_TEST_CASE

#define ARMNN_SIMPLE_TEST_CASE	(		TestName,
			TestFunction
	)

Value:

TEST_CASE(#TestName) \
    { \
        TestFunction(); \
    }

Definition at line 108 of file UnitTests.hpp.

Referenced by TEST_SUITE().

Function Documentation

CompareRefTestFunction()

void CompareRefTestFunction	(	const char *	testName,
		TFuncPtr	testFunction,
		Args...	args
	)

Definition at line 139 of file UnitTests.hpp.

References CompareTestResultIfSupported().

{
    auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);

    armnn::RefWorkloadFactory refWorkloadFactory;

    auto testResult = (*testFunction)(workloadFactory, memoryManager, refWorkloadFactory, args...);
    CompareTestResultIfSupported(testName, testResult);
}

CompareRefTestFunctionUsingTensorHandleFactory()

void CompareRefTestFunctionUsingTensorHandleFactory	(	const char *	testName,
		TFuncPtr	testFunction,
		Args...	args
	)

Definition at line 151 of file UnitTests.hpp.

References CompareTestResultIfSupported().

{
    auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);

    armnn::RefWorkloadFactory refWorkloadFactory;
    auto tensorHandleFactory = WorkloadFactoryHelper<FactoryType>::GetTensorHandleFactory(memoryManager);
    auto refTensorHandleFactory =
        RefWorkloadFactoryHelper::GetTensorHandleFactory(memoryManager);

    auto testResult = (*testFunction)(
        workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory, args...);
    CompareTestResultIfSupported(testName, testResult);
}

CompareTestResultIfSupported() [1/2]

void CompareTestResultIfSupported	(	const std::string &	testName,
		const LayerTestResult< T, n > &	testResult
	)

Executes CHECK_MESSAGE on CompareTensors() return value so that the predicate_result message is reported.

If the test reports itself as not supported then the tensors are not compared. Additionally this checks that the supportedness reported by the test matches the name of the test. Unsupported tests must be 'tagged' by including "UNSUPPORTED" in their name. This is useful because it clarifies that the feature being tested is not actually supported (a passed test with the name of a feature would imply that feature was supported). If support is added for a feature, the test case will fail because the name incorrectly contains UNSUPPORTED. If support is removed for a feature, the test case will fail because the name doesn't contain UNSUPPORTED.

Definition at line 40 of file UnitTests.hpp.

References CompareTensors(), LayerTestResult< T, n >::m_ActualData, LayerTestResult< T, n >::m_ActualShape, LayerTestResult< T, n >::m_CompareBoolean, LayerTestResult< T, n >::m_ExpectedData, LayerTestResult< T, n >::m_ExpectedShape, and LayerTestResult< T, n >::m_Supported.

Referenced by CompareRefTestFunction(), CompareRefTestFunctionUsingTensorHandleFactory(), RunTestFunction(), and RunTestFunctionUsingTensorHandleFactory().

{
    bool testNameIndicatesUnsupported = testName.find("UNSUPPORTED") != std::string::npos;
    CHECK_MESSAGE(testNameIndicatesUnsupported != testResult.m_Supported,
                  "The test name does not match the supportedness it is reporting");
    if (testResult.m_Supported)
    {
        auto result = CompareTensors(testResult.m_ActualData,
                                     testResult.m_ExpectedData,
                                     testResult.m_ActualShape,
                                     testResult.m_ExpectedShape,
                                     testResult.m_CompareBoolean);
       CHECK_MESSAGE(result.m_Result, result.m_Message.str());
    }
}

CompareTestResultIfSupported() [2/2]

void CompareTestResultIfSupported	(	const std::string &	testName,
		const std::vector< LayerTestResult< T, n >> &	testResult
	)

Definition at line 57 of file UnitTests.hpp.

References CompareTensors().

{
    bool testNameIndicatesUnsupported = testName.find("UNSUPPORTED") != std::string::npos;
    for (unsigned int i = 0; i < testResult.size(); ++i)
    {
        CHECK_MESSAGE(testNameIndicatesUnsupported != testResult[i].m_Supported,
                      "The test name does not match the supportedness it is reporting");
        if (testResult[i].m_Supported)
        {
            auto result = CompareTensors(testResult[i].m_ActualData,
                                         testResult[i].m_ExpectedData,
                                         testResult[i].m_ActualShape,
                                         testResult[i].m_ExpectedShape);
            CHECK_MESSAGE(result.m_Result, result.m_Message.str());
        }
    }
}

ConfigureLoggingTest()

void ConfigureLoggingTest ( )

inline

Definition at line 19 of file UnitTests.hpp.

References armnn::ConfigureLogging(), and armnn::Fatal.

{
    // Configures logging for both the ARMNN library and this test program.
    armnn::ConfigureLogging(true, true, armnn::LogSeverity::Fatal);
}

RunTestFunction()

void RunTestFunction	(	const char *	testName,
		TFuncPtr	testFunction,
		Args...	args
	)

Definition at line 76 of file UnitTests.hpp.

References CompareTestResultIfSupported(), ProfilerManager::GetInstance(), and ProfilerManager::RegisterProfiler().

{
    std::unique_ptr<armnn::IProfiler> profiler = std::make_unique<armnn::IProfiler>();
    armnn::ProfilerManager::GetInstance().RegisterProfiler(profiler.get());

    auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);

    auto testResult = (*testFunction)(workloadFactory, memoryManager, args...);
    CompareTestResultIfSupported(testName, testResult);

    armnn::ProfilerManager::GetInstance().RegisterProfiler(nullptr);
}

RunTestFunctionUsingTensorHandleFactory()

void RunTestFunctionUsingTensorHandleFactory	(	const char *	testName,
		TFuncPtr	testFunction,
		Args...	args
	)

Definition at line 92 of file UnitTests.hpp.

References CompareTestResultIfSupported(), ProfilerManager::GetInstance(), and ProfilerManager::RegisterProfiler().

{
    std::unique_ptr<armnn::IProfiler> profiler = std::make_unique<armnn::IProfiler>();
    armnn::ProfilerManager::GetInstance().RegisterProfiler(profiler.get());

    auto memoryManager = WorkloadFactoryHelper<FactoryType>::GetMemoryManager();
    FactoryType workloadFactory = WorkloadFactoryHelper<FactoryType>::GetFactory(memoryManager);

    auto tensorHandleFactory = WorkloadFactoryHelper<FactoryType>::GetTensorHandleFactory(memoryManager);

    auto testResult = (*testFunction)(workloadFactory, memoryManager, tensorHandleFactory, args...);
    CompareTestResultIfSupported(testName, testResult);

    armnn::ProfilerManager::GetInstance().RegisterProfiler(nullptr);
}