// Created by TraceCompiler 2.1.2

// DO NOT EDIT, CHANGES WILL BE LOST

#ifndef __TRACECOMPILERTESTERBASICTRACES_H__

#define __TRACECOMPILERTESTERBASICTRACES_H__

#define KOstTraceComponentID 0x20011112

#define TEST_BASIC_INT8 0xdf0001

#define TEST_BASIC_INT16 0xdf0002

#define TEST_BASIC_INT32 0xdf0003

#define TEST_BASIC_INT64 0xdf0004

#define TEST_BASIC_UINT8 0xdf0005

#define TEST_BASIC_UINT16 0xdf0006

#define TEST_BASIC_UINT32 0xdf0007

#define TEST_BASIC_UINT64 0xdf0008

#define TEST_BASIC_HEX8 0xdf0009

#define TEST_BASIC_HEX16 0xdf000a

#define TEST_BASIC_HEX32 0xdf000b

#define TEST_BASIC_HEX64 0xdf000c

#define TEST_BASIC_STRING8 0xdf000d

#define TEST_BASIC_STRING16 0xdf000e

#define TEST_BASIC_FFIX 0xdf000f

#define TEST_BASIC_FEXP 0xdf0010

#define TEST_BASIC_FOPT 0xdf0011

#define TEST_ARRAY_INT8 0xe00001

#define TEST_ARRAY_INT16 0xe00002

#define TEST_ARRAY_INT32 0xe00003

#define TEST_ARRAY_INT64 0xe00004

#define TEST_ARRAY_UINT8 0xe00005

#define TEST_ARRAY_UINT16 0xe00006

#define TEST_ARRAY_UINT32 0xe00007

#define TEST_ARRAY_UINT64 0xe00008

#define TEST_ARRAY_HEX8 0xe00009

#define TEST_ARRAY_HEX16 0xe0000a

#define TEST_ARRAY_HEX32 0xe0000b

#define TEST_ARRAY_HEX64 0xe0000c

#define TEST_ARRAY_FFIX 0xe0000d

#define TEST_ARRAY_FEXP 0xe0000e

#define TEST_ARRAY_FOPT 0xe0000f

#define TEST_BASIC_SIMILAR2_INT8 0xe10001

#define TEST_BASIC_SIMILAR2_INT16 0xe10002

#define TEST_BASIC_SIMILAR2_INT32 0xe10003

#define TEST_BASIC_SIMILAR2_INT64 0xe10004

#define TEST_BASIC_SIMILAR2_UINT8 0xe10005

#define TEST_BASIC_SIMILAR2_UINT16 0xe10006

#define TEST_BASIC_SIMILAR2_UINT32 0xe10007

#define TEST_BASIC_SIMILAR2_UINT64 0xe10008

#define TEST_BASIC_SIMILAR2_HEX8 0xe10009

#define TEST_BASIC_SIMILAR2_HEX16 0xe1000a

#define TEST_BASIC_SIMILAR2_HEX32 0xe1000b

#define TEST_BASIC_SIMILAR2_HEX64 0xe1000c

#define TEST_BASIC_SIMILAR2_STRING8 0xe1000d

#define TEST_BASIC_SIMILAR2_FFIX 0xe1000e

#define TEST_BASIC_SIMILAR2_FEXP 0xe1000f

#define TEST_BASIC_SIMILAR2_FOPT 0xe10010

#define TEST_ARRAY_SIMILAR2_INT8 0xe20001

#define TEST_ARRAY_SIMILAR2_INT16 0xe20002

#define TEST_ARRAY_SIMILAR2_INT32 0xe20003

#define TEST_ARRAY_SIMILAR2_INT64 0xe20004

#define TEST_ARRAY_SIMILAR2_UINT8 0xe20005

#define TEST_ARRAY_SIMILAR2_UINT16 0xe20006

#define TEST_ARRAY_SIMILAR2_UINT32 0xe20007

#define TEST_ARRAY_SIMILAR2_UINT64 0xe20008

#define TEST_ARRAY_SIMILAR2_HEX8 0xe20009

#define TEST_ARRAY_SIMILAR2_HEX16 0xe2000a

#define TEST_ARRAY_SIMILAR2_HEX32 0xe2000b

#define TEST_ARRAY_SIMILAR2_HEX64 0xe2000c

#define TEST_ARRAY_SIMILAR2_FFIX 0xe2000d

#define TEST_ARRAY_SIMILAR2_FEXP 0xe2000e

#define TEST_ARRAY_SIMILAR2_FOPT 0xe2000f

#define TEST_ENUM_OK 0xe30001

#define TEST_ENUM_ARRAY_OK 0xe30002

#define EVENT_MY_EVENT_TRACE1_START 0x8b0001

#define EVENT_MY_EVENT_TRACE1_STOP 0x8b0002

#define EVENT_MY_EVENT_TRACE2_START 0x8b0003

#define EVENT_MY_EVENT_TRACE2_STOP 0x8b0004

inline TBool OstTraceGen1( TUint32 aTraceID, TInt8 aParam1 )

    {

    TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    if ( retval )

        {

        TUint8 data[ 4 ];

        TUint8* ptr = data;

        *( ( TInt8* )ptr ) = aParam1;

        ptr += sizeof ( TInt8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        ptr -= 4;

        retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, TInt16 aParam1 )

    {

    TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    if ( retval )

        {

        TUint8 data[ 4 ];

        TUint8* ptr = data;

        *( ( TInt16* )ptr ) = aParam1;

        ptr += sizeof ( TInt16 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        ptr -= 4;

        retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, TInt64 aParam1 )

    {

    TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    if ( retval )

        {

        TUint8 data[ 8 ];

        TUint8* ptr = data;

        *( ( TInt64* )ptr ) = aParam1;

        ptr += sizeof ( TInt64 );

        ptr -= 8;

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, TUint8 aParam1 )

    {

    TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    if ( retval )

        {

        TUint8 data[ 4 ];

        TUint8* ptr = data;

        *( ( TUint8* )ptr ) = aParam1;

        ptr += sizeof ( TUint8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        ptr -= 4;

        retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, TUint16 aParam1 )

    {

    TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    if ( retval )

        {

        TUint8 data[ 4 ];

        TUint8* ptr = data;

        *( ( TUint16* )ptr ) = aParam1;

        ptr += sizeof ( TUint16 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        *( ( TUint8* )ptr ) = 0;

        ptr += sizeof ( TUint8 );

        ptr -= 4;

        retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, TUint64 aParam1 )

    {

    TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    if ( retval )

        {

        TUint8 data[ 8 ];

        TUint8* ptr = data;

        *( ( TUint64* )ptr ) = aParam1;

        ptr += sizeof ( TUint64 );

        ptr -= 8;

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TDesC8& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

#ifndef __KERNEL_MODE__

inline TBool OstTraceGen1( TUint32 aTraceID, const TDesC16& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

#endif

inline TBool OstTraceGen1( TUint32 aTraceID, TReal aParam1 )

    {

    TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    if ( retval )

        {

        TUint8 data[ 8 ];

        TUint8* ptr = data;

        *( ( TReal* )ptr ) = aParam1;

        ptr += sizeof ( TReal );

        ptr -= 8;

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt8 >& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt16 >& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt >& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt32 >& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt64 >& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TUint8 >& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    return retval;

    }

inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TUint16 >& aParam1 )

    {

    TBool retval;

    TInt size = aParam1.Size();

    // BTrace assumes that parameter size is atleast 4 bytes

    if (size % 4 == 0)

        {

        TUint8* ptr = ( TUint8* )aParam1.Ptr();

        // Data is written directly and length is determined from trace message length

        retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

        }

    else

        {

        TUint8 data[ KOstMaxDataLength ];

        TUint8* ptr = data;

        if (size > KOstMaxDataLength)

            {

            size = KOstMaxDataLength;

            }

        TInt sizeAligned = ( size + 3 ) & ~3;

        memcpy( ptr, aParam1.Ptr(), size );

        ptr += size;

        // Fillers are written to get 32-bit alignment

        while ( size++ < sizeAligned )

            {

            *ptr++ = 0;

            }

        ptr -= sizeAligned;

        size = sizeAligned;