//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include "ProfilingMocks.hpp"
#include "ProfilingTestUtils.hpp"
#include "ProfilingOptionsConverter.hpp"
#include <Runtime.hpp>
#include <ArmNNProfilingServiceInitialiser.hpp>

#include <armnn/profiling/ArmNNProfiling.hpp>

#include <client/src/BufferManager.hpp>
#include <client/src/ProfilingService.hpp>
#include <client/src/ProfilingUtils.hpp>
#include <client/src/SendTimelinePacket.hpp>
#include <client/src/TimelinePacketWriterFactory.hpp>

#include <common/include/LabelsAndEventClasses.hpp>
#include <common/include/SwTrace.hpp>
#include <common/include/Threads.hpp>

#include <doctest/doctest.h>

#include <functional>

using namespace arm::pipe;

TEST_SUITE("SendTimelinePacketTests")
{
TEST_CASE("SendTimelineMessageDirectoryPackageTest")
{
    MockBufferManager mockBuffer(512);
    TimelinePacketWriterFactory timelinePacketWriterFactory(mockBuffer);
    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket();

    sendTimelinePacket->SendTimelineMessageDirectoryPackage();

    // Get the readable buffer
    auto packetBuffer = mockBuffer.GetReadableBuffer();

    unsigned int uint8_t_size  = sizeof(uint8_t);
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // Check the packet header
    unsigned int offset = 0;
    uint32_t packetHeaderWord0 = ReadUint32(packetBuffer, offset);
    uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
    uint32_t packetClass  = (packetHeaderWord0 >> 19) & 0x0000007F;
    uint32_t packetType   = (packetHeaderWord0 >> 16) & 0x00000007;
    uint32_t streamId     = (packetHeaderWord0 >>  0) & 0x00000007;

    CHECK(packetFamily == 1);
    CHECK(packetClass  == 0);
    CHECK(packetType   == 0);
    CHECK(streamId     == 0);

    offset += uint32_t_size;
    uint32_t packetHeaderWord1 = ReadUint32(packetBuffer, offset);
    uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
    uint32_t dataLength       = (packetHeaderWord1 >>  0) & 0x00FFFFFF;
    CHECK(sequenceNumbered ==  0);
    CHECK(dataLength       == 443);

    offset += uint32_t_size;
    uint8_t readStreamVersion = ReadUint8(packetBuffer, offset);
    CHECK(readStreamVersion == 4);
    offset += uint8_t_size;
    uint8_t readPointerBytes = ReadUint8(packetBuffer, offset);
    CHECK(readPointerBytes == uint64_t_size);
    offset += uint8_t_size;
    uint8_t readThreadIdBytes = ReadUint8(packetBuffer, offset);
    CHECK(readThreadIdBytes == ThreadIdSize);

    offset += uint8_t_size;
    uint32_t DeclCount = ReadUint32(packetBuffer, offset);
    CHECK(DeclCount == 5);

    offset += uint32_t_size;
    arm::pipe::SwTraceMessage swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(),
                                                                             offset,
                                                                             packetBuffer->GetSize());

    CHECK(swTraceMessage.m_Id == 0);
    CHECK(swTraceMessage.m_Name == "declareLabel");
    CHECK(swTraceMessage.m_UiName == "declare label");
    CHECK(swTraceMessage.m_ArgTypes.size() == 2);
    CHECK(swTraceMessage.m_ArgTypes[0] == 'p');
    CHECK(swTraceMessage.m_ArgTypes[1] == 's');
    CHECK(swTraceMessage.m_ArgNames.size() == 2);
    CHECK(swTraceMessage.m_ArgNames[0] == "guid");
    CHECK(swTraceMessage.m_ArgNames[1] == "value");

    swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(),
                                                   offset,
                                                   packetBuffer->GetSize());

    CHECK(swTraceMessage.m_Id == 1);
    CHECK(swTraceMessage.m_Name == "declareEntity");
    CHECK(swTraceMessage.m_UiName == "declare entity");
    CHECK(swTraceMessage.m_ArgTypes.size() == 1);
    CHECK(swTraceMessage.m_ArgTypes[0] == 'p');
    CHECK(swTraceMessage.m_ArgNames.size() == 1);
    CHECK(swTraceMessage.m_ArgNames[0] == "guid");

    swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(),
                                                   offset,
                                                   packetBuffer->GetSize());

    CHECK(swTraceMessage.m_Id == 2);
    CHECK(swTraceMessage.m_Name == "declareEventClass");
    CHECK(swTraceMessage.m_UiName == "declare event class");
    CHECK(swTraceMessage.m_ArgTypes.size() == 2);
    CHECK(swTraceMessage.m_ArgTypes[0] == 'p');
    CHECK(swTraceMessage.m_ArgTypes[1] == 'p');
    CHECK(swTraceMessage.m_ArgNames.size() == 2);
    CHECK(swTraceMessage.m_ArgNames[0] == "guid");
    CHECK(swTraceMessage.m_ArgNames[1] == "nameGuid");

    swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(),
                                                   offset,
                                                   packetBuffer->GetSize());

    CHECK(swTraceMessage.m_Id == 3);
    CHECK(swTraceMessage.m_Name == "declareRelationship");
    CHECK(swTraceMessage.m_UiName == "declare relationship");
    CHECK(swTraceMessage.m_ArgTypes.size() == 5);
    CHECK(swTraceMessage.m_ArgTypes[0] == 'I');
    CHECK(swTraceMessage.m_ArgTypes[1] == 'p');
    CHECK(swTraceMessage.m_ArgTypes[2] == 'p');
    CHECK(swTraceMessage.m_ArgTypes[3] == 'p');
    CHECK(swTraceMessage.m_ArgTypes[4] == 'p');
    CHECK(swTraceMessage.m_ArgNames.size() == 5);
    CHECK(swTraceMessage.m_ArgNames[0] == "relationshipType");
    CHECK(swTraceMessage.m_ArgNames[1] == "relationshipGuid");
    CHECK(swTraceMessage.m_ArgNames[2] == "headGuid");
    CHECK(swTraceMessage.m_ArgNames[3] == "tailGuid");
    CHECK(swTraceMessage.m_ArgNames[4] == "attributeGuid");

    swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(),
                                                   offset,
                                                   packetBuffer->GetSize());

    CHECK(swTraceMessage.m_Id == 4);
    CHECK(swTraceMessage.m_Name == "declareEvent");
    CHECK(swTraceMessage.m_UiName == "declare event");
    CHECK(swTraceMessage.m_ArgTypes.size() == 3);
    CHECK(swTraceMessage.m_ArgTypes[0] == '@');
    CHECK(swTraceMessage.m_ArgTypes[1] == 't');
    CHECK(swTraceMessage.m_ArgTypes[2] == 'p');
    CHECK(swTraceMessage.m_ArgNames.size() == 3);
    CHECK(swTraceMessage.m_ArgNames[0] == "timestamp");
    CHECK(swTraceMessage.m_ArgNames[1] == "threadId");
    CHECK(swTraceMessage.m_ArgNames[2] == "eventGuid");
}

TEST_CASE("SendTimelineEntityWithEventClassPacketTest")
{
    MockBufferManager bufferManager(40);
    TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager);
    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket();

    const uint64_t entityBinaryPacketProfilingGuid = 123456u;
    sendTimelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);

    const uint64_t eventClassBinaryPacketProfilingGuid = 789123u;
    const uint64_t eventClassBinaryPacketNameGuid = 8845u;
    sendTimelinePacket->SendTimelineEventClassBinaryPacket(
        eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid);

    // Commit the messages
    sendTimelinePacket->Commit();

    // Get the readable buffer
    auto packetBuffer = bufferManager.GetReadableBuffer();

    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // Check the packet header
    unsigned int offset = 0;

    // Reading TimelineEntityClassBinaryPacket
    uint32_t entityBinaryPacketHeaderWord0  = ReadUint32(packetBuffer, offset);
    uint32_t entityBinaryPacketFamily       = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
    uint32_t entityBinaryPacketClass        = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
    uint32_t entityBinaryPacketType         = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007;
    uint32_t entityBinaryPacketStreamId     = (entityBinaryPacketHeaderWord0 >>  0) & 0x00000007;

    CHECK(entityBinaryPacketFamily       == 1);
    CHECK(entityBinaryPacketClass        == 0);
    CHECK(entityBinaryPacketType         == 1);
    CHECK(entityBinaryPacketStreamId     == 0);

    offset += uint32_t_size;

    uint32_t entityBinaryPacketHeaderWord1      = ReadUint32(packetBuffer, offset);

    uint32_t entityBinaryPacketSequenceNumbered = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
    uint32_t entityBinaryPacketDataLength       = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;

    CHECK(entityBinaryPacketSequenceNumbered == 0);
    CHECK(entityBinaryPacketDataLength       == 32);

    // Check the decl_id
    offset += uint32_t_size;
    uint32_t entitytDecId = ReadUint32(packetBuffer, offset);

    CHECK(entitytDecId == uint32_t(1));

    // Check the profiling GUID
    offset += uint32_t_size;
    uint64_t readProfilingGuid = ReadUint64(packetBuffer, offset);

    CHECK(readProfilingGuid == entityBinaryPacketProfilingGuid);

    // Reading TimelineEventClassBinaryPacket
    offset += uint64_t_size;

    uint32_t eventClassDeclId = ReadUint32(packetBuffer, offset);
    CHECK(eventClassDeclId == uint32_t(2));

    // Check the profiling GUID
    offset += uint32_t_size;
    readProfilingGuid = ReadUint64(packetBuffer, offset);
    CHECK(readProfilingGuid == eventClassBinaryPacketProfilingGuid);

    offset += uint64_t_size;
    uint64_t readEventClassNameGuid = ReadUint64(packetBuffer, offset);
    CHECK(readEventClassNameGuid == eventClassBinaryPacketNameGuid);

    bufferManager.MarkRead(packetBuffer);
}

TEST_CASE("SendEventClassAfterTimelineEntityPacketTest")
{
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    MockBufferManager bufferManager(512);
    TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager);
    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket();

    // Send TimelineEntityClassBinaryPacket
    const uint64_t entityBinaryPacketProfilingGuid = 123456u;
    sendTimelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);

    // Commit the buffer
    sendTimelinePacket->Commit();

    // Get the readable buffer
    auto packetBuffer = bufferManager.GetReadableBuffer();

    // Check the packet header
    unsigned int offset = 0;

    // Reading TimelineEntityClassBinaryPacket
    uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(packetBuffer, offset);
    uint32_t entityBinaryPacketFamily = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
    uint32_t entityBinaryPacketClass  = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
    uint32_t entityBinaryPacketType   = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007;
    uint32_t entityBinaryPacketStreamId     = (entityBinaryPacketHeaderWord0 >>  0) & 0x00000007;

    CHECK(entityBinaryPacketFamily == 1);
    CHECK(entityBinaryPacketClass  == 0);
    CHECK(entityBinaryPacketType   == 1);
    CHECK(entityBinaryPacketStreamId     == 0);

    offset += uint32_t_size;
    uint32_t entityBinaryPacketHeaderWord1 = ReadUint32(packetBuffer, offset);
    uint32_t entityBinaryPacketSequenceNumbered = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
    uint32_t entityBinaryPacketDataLength       = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
    CHECK(entityBinaryPacketSequenceNumbered == 0);
    CHECK(entityBinaryPacketDataLength       == 12);

    // Check the decl_id
    offset += uint32_t_size;
    uint32_t entitytDecId = ReadUint32(packetBuffer, offset);

    CHECK(entitytDecId == uint32_t(1));

    // Check the profiling GUID
    offset += uint32_t_size;
    uint64_t readProfilingGuid = ReadUint64(packetBuffer, offset);

    CHECK(readProfilingGuid == entityBinaryPacketProfilingGuid);

    bufferManager.MarkRead(packetBuffer);

    // Send TimelineEventClassBinaryPacket
    const uint64_t eventClassBinaryPacketProfilingGuid = 789123u;
    const uint64_t eventClassBinaryPacketNameGuid = 8845u;
    sendTimelinePacket->SendTimelineEventClassBinaryPacket(
        eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid);

    // Commit the buffer
    sendTimelinePacket->Commit();

    // Get the readable buffer
    packetBuffer = bufferManager.GetReadableBuffer();

    // Check the packet header
    offset = 0;

    // Reading TimelineEventClassBinaryPacket
    uint32_t eventClassBinaryPacketHeaderWord0 = ReadUint32(packetBuffer, offset);
    uint32_t eventClassBinaryPacketFamily = (eventClassBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
    uint32_t eventClassBinaryPacketClass  = (eventClassBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
    uint32_t eventClassBinaryPacketType   = (eventClassBinaryPacketHeaderWord0 >> 16) & 0x00000007;
    uint32_t eventClassBinaryPacketStreamId     = (eventClassBinaryPacketHeaderWord0 >>  0) & 0x00000007;

    CHECK(eventClassBinaryPacketFamily == 1);
    CHECK(eventClassBinaryPacketClass  == 0);
    CHECK(eventClassBinaryPacketType   == 1);
    CHECK(eventClassBinaryPacketStreamId     == 0);

    offset += uint32_t_size;
    uint32_t eventClassBinaryPacketHeaderWord1 = ReadUint32(packetBuffer, offset);
    uint32_t eventClassBinaryPacketSequenceNumbered = (eventClassBinaryPacketHeaderWord1 >> 24) & 0x00000001;
    uint32_t eventClassBinaryPacketDataLength       = (eventClassBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
    CHECK(eventClassBinaryPacketSequenceNumbered == 0);
    CHECK(eventClassBinaryPacketDataLength       == 20);

    offset += uint32_t_size;
    uint32_t eventClassDeclId = ReadUint32(packetBuffer, offset);
    CHECK(eventClassDeclId == uint32_t(2));

    // Check the profiling GUID
    offset += uint32_t_size;
    readProfilingGuid = ReadUint64(packetBuffer, offset);
    CHECK(readProfilingGuid == eventClassBinaryPacketProfilingGuid);

    offset += uint64_t_size;
    uint64_t readEventClassNameGuid = ReadUint64(packetBuffer, offset);
    CHECK(readEventClassNameGuid == eventClassBinaryPacketNameGuid);

    bufferManager.MarkRead(packetBuffer);

    // Send TimelineEventBinaryPacket
    const uint64_t timestamp = 456789u;
    const int threadId = arm::pipe::GetCurrentThreadId();
    const uint64_t eventProfilingGuid = 123456u;
    sendTimelinePacket->SendTimelineEventBinaryPacket(timestamp, threadId, eventProfilingGuid);

    // Commit the buffer
    sendTimelinePacket->Commit();

    // Get the readable buffer
    packetBuffer = bufferManager.GetReadableBuffer();

    // Check the packet header
    offset = 0;

    // Reading TimelineEventBinaryPacket
    uint32_t eventBinaryPacketHeaderWord0 = ReadUint32(packetBuffer, offset);
    uint32_t eventBinaryPacketFamily = (eventBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
    uint32_t eventBinaryPacketClass  = (eventBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
    uint32_t eventBinaryPacketType   = (eventBinaryPacketHeaderWord0 >> 16) & 0x00000007;
    uint32_t eventBinaryPacketStreamId     = (eventBinaryPacketHeaderWord0 >>  0) & 0x00000007;

    CHECK(eventBinaryPacketFamily == 1);
    CHECK(eventBinaryPacketClass  == 0);
    CHECK(eventBinaryPacketType   == 1);
    CHECK(eventBinaryPacketStreamId     == 0);

    offset += uint32_t_size;
    uint32_t eventBinaryPacketHeaderWord1 = ReadUint32(packetBuffer, offset);
    uint32_t eventBinaryPacketSequenceNumbered = (eventBinaryPacketHeaderWord1 >> 24) & 0x00000001;
    uint32_t eventBinaryPacketDataLength       = (eventBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
    CHECK(eventBinaryPacketSequenceNumbered == 0);
    CHECK(eventBinaryPacketDataLength == 20 + ThreadIdSize);

    // Check the decl_id
    offset += uint32_t_size;
    uint32_t eventDeclId = ReadUint32(packetBuffer, offset);
    CHECK(eventDeclId == 4);

    // Check the timestamp
    offset += uint32_t_size;
    uint64_t eventTimestamp = ReadUint64(packetBuffer, offset);
    CHECK(eventTimestamp == timestamp);

    // Check the thread id
    offset += uint64_t_size;
    std::vector<uint8_t> readThreadId(ThreadIdSize, 0);
    ReadBytes(packetBuffer, offset, ThreadIdSize, readThreadId.data());
    CHECK(readThreadId == threadId);

    // Check the profiling GUID
    offset += ThreadIdSize;
    readProfilingGuid = ReadUint64(packetBuffer, offset);
    CHECK(readProfilingGuid == eventProfilingGuid);
}

TEST_CASE("SendTimelinePacketTests2")
{
    MockBufferManager bufferManager(40);
    TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager);
    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket();

    CHECK_THROWS_AS(sendTimelinePacket->SendTimelineMessageDirectoryPackage(),
                    arm::pipe::ProfilingException);
}

TEST_CASE("SendTimelinePacketTests3")
{
    MockBufferManager bufferManager(512);
    TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager);
    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket();

    // Send TimelineEntityClassBinaryPacket
    const uint64_t entityBinaryPacketProfilingGuid = 123456u;
    sendTimelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);

    // Commit the buffer
    sendTimelinePacket->Commit();

    // Get the readable buffer
    auto packetBuffer = bufferManager.GetReadableBuffer();

    // Send TimelineEventClassBinaryPacket
    const uint64_t eventClassBinaryPacketProfilingGuid = 789123u;
    const uint64_t eventClassBinaryPacketNameGuid = 8845u;
    CHECK_THROWS_AS(sendTimelinePacket->SendTimelineEventClassBinaryPacket(
                      eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid),
                      BufferExhaustion);
}

TEST_CASE("GetGuidsFromProfilingService")
{
    LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);

    armnn::IRuntime::CreationOptions options;
    options.m_ProfilingOptions.m_EnableProfiling = true;
    armnn::RuntimeImpl runtime(options);
    armnn::ArmNNProfilingServiceInitialiser initialiser;
    ProfilingService profilingService(arm::pipe::MAX_ARMNN_COUNTER,
                                      initialiser,
                                      arm::pipe::ARMNN_SOFTWARE_INFO,
                                      arm::pipe::ARMNN_SOFTWARE_VERSION,
                                      arm::pipe::ARMNN_HARDWARE_VERSION,
                                      runtime);

    profilingService.ResetExternalProfilingOptions(
        ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
    ProfilingStaticGuid staticGuid = profilingService.GetStaticId("dummy");
    std::hash<std::string> hasher;
    uint64_t hash = static_cast<uint64_t>(hasher("dummy"));
    ProfilingStaticGuid expectedStaticValue(hash | MIN_STATIC_GUID);
    CHECK(staticGuid == expectedStaticValue);
    ProfilingDynamicGuid dynamicGuid = profilingService.GetNextGuid();
    uint64_t dynamicGuidValue = static_cast<uint64_t>(dynamicGuid);
    ++dynamicGuidValue;
    ProfilingDynamicGuid expectedDynamicValue(dynamicGuidValue);
    dynamicGuid = profilingService.GetNextGuid();
    CHECK(dynamicGuid == expectedDynamicValue);
}

TEST_CASE("GetTimelinePackerWriterFromProfilingService")
{
    LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);

    ProfilingOptions options;
    options.m_EnableProfiling = true;
    armnn::ArmNNProfilingServiceInitialiser initialiser;
    ProfilingService profilingService(arm::pipe::MAX_ARMNN_COUNTER,
                                      initialiser,
                                      arm::pipe::ARMNN_SOFTWARE_INFO,
                                      arm::pipe::ARMNN_SOFTWARE_VERSION,
                                      arm::pipe::ARMNN_HARDWARE_VERSION);
    profilingService.ResetExternalProfilingOptions(options, true);

    std::unique_ptr<ISendTimelinePacket> writer = profilingService.GetSendTimelinePacket();
    CHECK(writer != nullptr);
}

TEST_CASE("CheckStaticGuidsAndEvents")
{
    CHECK("name" == LabelsAndEventClasses::NAME_LABEL);
    CHECK("type" == LabelsAndEventClasses::TYPE_LABEL);
    CHECK("index" == LabelsAndEventClasses::INDEX_LABEL);

    std::hash<std::string> hasher;

    uint64_t hash = static_cast<uint64_t>(hasher(LabelsAndEventClasses::NAME_LABEL));
    ProfilingStaticGuid expectedNameGuid(hash | MIN_STATIC_GUID);
    CHECK(LabelsAndEventClasses::NAME_GUID == expectedNameGuid);

    hash = static_cast<uint64_t>(hasher(LabelsAndEventClasses::TYPE_LABEL));
    ProfilingStaticGuid expectedTypeGuid(hash | MIN_STATIC_GUID);
    CHECK(LabelsAndEventClasses::TYPE_GUID == expectedTypeGuid);

    hash = static_cast<uint64_t>(hasher(LabelsAndEventClasses::INDEX_LABEL));
    ProfilingStaticGuid expectedIndexGuid(hash | MIN_STATIC_GUID);
    CHECK(LabelsAndEventClasses::INDEX_GUID == expectedIndexGuid);

    hash = static_cast<uint64_t>(hasher("ARMNN_PROFILING_SOL"));
    ProfilingStaticGuid expectedSol(hash | MIN_STATIC_GUID);
    CHECK(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS == expectedSol);

    hash = static_cast<uint64_t>(hasher("ARMNN_PROFILING_EOL"));
    ProfilingStaticGuid expectedEol(hash | MIN_STATIC_GUID);
    CHECK(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS == expectedEol);
}

}