#include <SerializerTestUtils.hpp>

Inheritance diagram for LayerVerifierBase:

Public Member Functions
	LayerVerifierBase (const std::string &layerName, const std::vector< armnn::TensorInfo > &inputInfos, const std::vector< armnn::TensorInfo > &outputInfos)

void	ExecuteStrategy (const armnn::IConnectableLayer layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char name, const armnn::LayerBindingId id=0) override

Public Member Functions inherited from IStrategy
virtual void	ExecuteStrategy (const armnn::IConnectableLayer layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char name, const armnn::LayerBindingId id=0)=0

virtual void	FinishStrategy ()

Protected Member Functions
void	VerifyNameAndConnections (const armnn::IConnectableLayer layer, const char name)

void	VerifyConstTensors (const std::string &tensorName, const armnn::ConstTensor expectedPtr, const armnn::ConstTensor actualPtr)

Protected Member Functions inherited from IStrategy
	IStrategy ()

virtual	~IStrategy ()

Detailed Description

Definition at line 24 of file SerializerTestUtils.hpp.

Constructor & Destructor Documentation

◆ LayerVerifierBase()

LayerVerifierBase	(	const std::string &	layerName,
		const std::vector< armnn::TensorInfo > &	inputInfos,
		const std::vector< armnn::TensorInfo > &	outputInfos
	)

Definition at line 11 of file SerializerTestUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE().

                                      : m_LayerName(layerName)
                                      , m_InputTensorInfos(inputInfos)
                                      , m_OutputTensorInfos(outputInfos)
 {}

Member Function Documentation

◆ ExecuteStrategy()

void ExecuteStrategy	(	const armnn::IConnectableLayer *	layer,
		const armnn::BaseDescriptor &	descriptor,
		const std::vector< armnn::ConstTensor > &	constants,
		const char *	name,
		const armnn::LayerBindingId	id = `0`
	)

override

Definition at line 19 of file SerializerTestUtils.cpp.

References IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::Input, armnn::Output, and VerifyNameAndConnections().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     armnn::IgnoreUnused(descriptor, constants, id);
     switch (layer->GetType())
     {
         case armnn::LayerType::Input: break;
         case armnn::LayerType::Output: break;
         default:
         {
             VerifyNameAndConnections(layer, name);
         }
     }
 }

◆ VerifyConstTensors()

void VerifyConstTensors	(	const std::string &	tensorName,
		const armnn::ConstTensor *	expectedPtr,
		const armnn::ConstTensor *	actualPtr
	)

protected

Definition at line 71 of file SerializerTestUtils.cpp.

References TensorInfo::GetDataType(), armnn::GetDataTypeName(), BaseTensor< MemoryType >::GetInfo(), BaseTensor< MemoryType >::GetMemoryArea(), BaseTensor< MemoryType >::GetNumBytes(), and TensorInfo::GetShape().

Referenced by ConstantVector2LstmInputParams().

 {
     if (expectedPtr == nullptr)
     {
         BOOST_CHECK_MESSAGE(actualPtr == nullptr, tensorName + " should not exist");
     }
     else
     {
         BOOST_CHECK_MESSAGE(actualPtr != nullptr, tensorName + " should have been set");
         if (actualPtr != nullptr)
         {
             const armnn::TensorInfo& expectedInfo = expectedPtr->GetInfo();
             const armnn::TensorInfo& actualInfo = actualPtr->GetInfo();
 
             BOOST_CHECK_MESSAGE(expectedInfo.GetShape() == actualInfo.GetShape(),
                                 tensorName + " shapes don't match");
             BOOST_CHECK_MESSAGE(
                     GetDataTypeName(expectedInfo.GetDataType()) == GetDataTypeName(actualInfo.GetDataType()),
                     tensorName + " data types don't match");
 
             BOOST_CHECK_MESSAGE(expectedPtr->GetNumBytes() == actualPtr->GetNumBytes(),
                                 tensorName + " (GetNumBytes) data sizes do not match");
             if (expectedPtr->GetNumBytes() == actualPtr->GetNumBytes())
             {
                 //check the data is identical
                 const char* expectedData = static_cast<const char*>(expectedPtr->GetMemoryArea());
                 const char* actualData = static_cast<const char*>(actualPtr->GetMemoryArea());
                 bool same = true;
                 for (unsigned int i = 0; i < expectedPtr->GetNumBytes(); ++i)
                 {
                     same = expectedData[i] == actualData[i];
                     if (!same)
                     {
                         break;
                     }
                 }
                 BOOST_CHECK_MESSAGE(same, tensorName + " data does not match");
             }
         }
     }
 }

◆ VerifyNameAndConnections()

void VerifyNameAndConnections	(	const armnn::IConnectableLayer *	layer,
		const char *	name
	)

protected

Definition at line 38 of file SerializerTestUtils.cpp.

References IInputSlot::GetConnection(), TensorInfo::GetDataType(), armnn::GetDataTypeName(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetNumInputSlots(), IConnectableLayer::GetNumOutputSlots(), IConnectableLayer::GetOutputSlot(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::GetShape(), and IOutputSlot::GetTensorInfo().

Referenced by BOOST_AUTO_TEST_CASE(), ConstantVector2LstmInputParams(), ExecuteStrategy(), LayerVerifierBaseWithDescriptor< armnn::OriginsDescriptor >::ExecuteStrategy(), and LayerVerifierBaseWithDescriptorAndConstants< Descriptor >::ExecuteStrategy().

 {
     BOOST_TEST(name == m_LayerName.c_str());
 
     BOOST_TEST(layer->GetNumInputSlots() == m_InputTensorInfos.size());
     BOOST_TEST(layer->GetNumOutputSlots() == m_OutputTensorInfos.size());
 
     for (unsigned int i = 0; i < m_InputTensorInfos.size(); i++)
     {
         const armnn::IOutputSlot* connectedOutput = layer->GetInputSlot(i).GetConnection();
         BOOST_CHECK(connectedOutput);
 
         const armnn::TensorInfo& connectedInfo = connectedOutput->GetTensorInfo();
         BOOST_TEST(connectedInfo.GetShape() == m_InputTensorInfos[i].GetShape());
         BOOST_TEST(
             GetDataTypeName(connectedInfo.GetDataType()) == GetDataTypeName(m_InputTensorInfos[i].GetDataType()));
 
         BOOST_TEST(connectedInfo.GetQuantizationScale() == m_InputTensorInfos[i].GetQuantizationScale());
         BOOST_TEST(connectedInfo.GetQuantizationOffset() == m_InputTensorInfos[i].GetQuantizationOffset());
     }
 
     for (unsigned int i = 0; i < m_OutputTensorInfos.size(); i++)
     {
         const armnn::TensorInfo& outputInfo = layer->GetOutputSlot(i).GetTensorInfo();
         BOOST_TEST(outputInfo.GetShape() == m_OutputTensorInfos[i].GetShape());
         BOOST_TEST(
             GetDataTypeName(outputInfo.GetDataType()) == GetDataTypeName(m_OutputTensorInfos[i].GetDataType()));
 
         BOOST_TEST(outputInfo.GetQuantizationScale() == m_OutputTensorInfos[i].GetQuantizationScale());
         BOOST_TEST(outputInfo.GetQuantizationOffset() == m_OutputTensorInfos[i].GetQuantizationOffset());
     }
 }

The documentation for this class was generated from the following files:

src/armnnSerializer/test/SerializerTestUtils.hpp
src/armnnSerializer/test/SerializerTestUtils.cpp

Public Member Functions