/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/
#include <nkern.h>

#include "TraceCompilerTesterBasic.h"
#include "TraceCompilerTesterCommon1.h"
#include "TraceCompilerTesterCommon2.h"

#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "TraceCompilerTesterBasicTraces.h"
#include "TraceCompilerTesterCommon2Traces.h"
#endif

// Define group IDs. If TraceCompiler is missing, define these to get the code to compile.
// However, component still won't work properly.
#ifdef OST_TRACE_COMPILER_IN_USE
#define BASIC_OK_TEST TEST_BASIC_INT8 >> 16
#define ARRAY_OK_TEST TEST_ARRAY_INT8 >> 16
#define BASIC_TWO_SIMILAR_OK_TEST TEST_BASIC_SIMILAR2_INT8 >> 16
#define ARRAY_TWO_SIMILAR_OK_TEST TEST_ARRAY_SIMILAR2_INT8 >> 16
#define ENUM_OK_TEST TEST_ENUM_OK >> 16
#define TRACE_PERFORMANCE 0x4
#define TRACE_FLOW 0x7
#define INCLUDED_NON_SOURCE_FILE_TEST NON_SOURCE_FILE_TRACE1 >> 16
#define KEKKONEN TEXT1 >> 16
#else
#define BASIC_OK_TEST
#define ARRAY_OK_TEST
#define BASIC_TWO_SIMILAR_OK_TEST
#define ARRAY_TWO_SIMILAR_OK_TEST
#define ENUM_OK_TEST
#define EVENT_NO_VALUE_OK_TEST
#define EVENT_WITH_VALUE_OK_TEST
#define TRACE_PERFORMANCE
#define TRACE_FLOW
#define INCLUDED_NON_SOURCE_FILE_TEST
#define KEKKONEN
#endif

//- Local constants ---------------------------------------------------------

const TUint32 KComponentID = 0x20011112;

//- Macros ------------------------------------------------------------------


//- Member Functions --------------------------------------------------------

/**
 * Constructor
 */
DTraceCompilerTesterBasic::DTraceCompilerTesterBasic()
    {
    }

/**
 * EnergyMonitor Destructor
 */
DTraceCompilerTesterBasic::~DTraceCompilerTesterBasic()
    {

    }

/**
 * EnergyMonitor second-phase constructor
 *
 * @param
 * @return System-wide error code
 */
TInt DTraceCompilerTesterBasic::Construct()
    {

    TInt ret(KErrNone);
    
    Kern::Printf( "-------------- DTraceCompilerTesterBasic::Construct ----------------" );
    
    // Register notification receivers by using component ID and group IDs
    RegisterNotificationReceiver(KComponentID, BASIC_OK_TEST );
    RegisterNotificationReceiver(KComponentID, ARRAY_OK_TEST );
    RegisterNotificationReceiver(KComponentID, BASIC_TWO_SIMILAR_OK_TEST );
    RegisterNotificationReceiver(KComponentID, ARRAY_TWO_SIMILAR_OK_TEST );
    RegisterNotificationReceiver(KComponentID, ENUM_OK_TEST );
    RegisterNotificationReceiver(KComponentID, TRACE_PERFORMANCE );
    RegisterNotificationReceiver(KComponentID, TRACE_FLOW );
    RegisterNotificationReceiver(KComponentID, INCLUDED_NON_SOURCE_FILE_TEST );
    RegisterNotificationReceiver(KComponentID, KEKKONEN );

    return ret;
    }

/**
 * Callback function for Trace Activation
 * 
 * @param aComponentId
 * @param aGroupId         
 */
void DTraceCompilerTesterBasic::TraceActivated(TUint32 aComponentId,
        TUint16 aGroupId)
    {
    Kern::Printf(
            "DTraceCompilerTesterBasic::TraceActivated - ComponentId = 0x%x, GroupId = 0x%x",
            aComponentId, aGroupId);

    if (aGroupId == BASIC_OK_TEST)
        {
        Kern::Printf(
                "--------------TraceCompilerTesterBasic Array Basic START----------------");
        TUint8 unicodeStr[10];
        unicodeStr[0] = 'S';
        unicodeStr[1] = '\0';
        unicodeStr[2] = 'T';
        unicodeStr[3] = '\0';
        unicodeStr[4] = 'R';
        unicodeStr[5] = '\0';
        unicodeStr[6] = '1';
        unicodeStr[7] = '\0';
        unicodeStr[8] = '6';
        unicodeStr[9] = '\0';
        TPtrC8 unicodePtr(unicodeStr, 10);

        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_INT8, "int8: %hhd", ( TInt8 )1 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_INT16, "int16: %hd", ( TInt16 )2 );
        OstTrace1( BASIC_OK_TEST, TEST_BASIC_INT32, "int32: %d", ( TInt )3 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_INT64, "int64: %Ld", ( TInt64 )4 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_UINT8, "uint8: %hhu", ( TUint16 )5 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_UINT16, "uint16: %hu", ( TUint16 )6 );
        OstTrace1( BASIC_OK_TEST, TEST_BASIC_UINT32, "uint32: %u", ( TUint32 )7 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_UINT64, "uint64: %Lu", ( TUint64 )8 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_HEX8, "hex8: %hhx", ( TUint8 )9 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_HEX16, "hex16: %hx", ( TUint16 )10 );
        OstTrace1( BASIC_OK_TEST, TEST_BASIC_HEX32, "hex32: %x", ( TUint32 )11 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_HEX64, "hex64: %Lx", ( TUint64 )12 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_STRING8, "ascii: %s", _L8( "STR8" ) );
        // In kernel unicode strings do not exist -> This uses const TDesC8&
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_STRING16, "unicode: %S", unicodePtr );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_FFIX, "ffix: %f", 0.1 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_FEXP, "fexp: %e", 0.2 );
        OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_FOPT, "fopt: %g", 0.3 );
        Kern::Printf( "--------------TraceCompilerTesterBasic Array Basic END----------------" );
        }
    else if (aGroupId == ARRAY_OK_TEST)
        {
        
      
        Kern::Printf( "--------------TraceCompilerTesterBasic Array Test START----------------" );
        TInt buf8Len = 29;
        TInt8 buf8[ 29 ];
        TInt index = 0;
        TInt value = -17;
        while ( index < buf8Len )
            {
            buf8[ index++ ] = value;
            value++;
            }
        TInt buf16Len = 11;
        TInt16 buf16[ 11 ];
        index = 0;
        value = -3;
        while ( index < buf16Len )
            {
            buf16[ index++ ] = value;
            value += 7;
            }
        TInt buf32Len = 7;
        TInt buf32[ 7 ];
        index = 0;
        value = -73;
        while ( index < buf32Len )
            {
            buf32[ index++ ] = value;
            value += 150;
            }
        TInt buf64Len = 5;
        TInt64 buf64[ 5 ];
        index = 0;
        value = -100000000L;
        while ( index < buf64Len )
            {
            buf64[ index++ ] = value;
            value += 100000000L;
            }

#ifdef __WINS__
        TInt bufFloatLen = 7;
        TReal bufFloat[ 7 ];
        index = 0;
        TReal val = -0.5;
        while ( index < bufFloatLen )
            {
            bufFloat[ index++ ] = val;
            val += 1.5;
            }
#endif
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT8, "int8 array: %{int8[]}",
                TOstArray< TInt8>( ( TInt8* )buf8, buf8Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT16, "int16 array: %{int16[]}",
                TOstArray< TInt16>( ( TInt16* )buf16, buf16Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT32, "int32 array: %{int32[]}",
                TOstArray< TInt>( ( TInt* )buf32, buf32Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT64, "int64 array: %{int64[]}",
                TOstArray< TInt64>( ( TInt64* )buf64, buf64Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT8, "uint8 array: %{uint8[]}",
                TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT16, "uint16 array: %{uint16[]}",
                TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT32, "uint32 array: %{uint32[]}",
                TOstArray< TUint>( ( TUint* )buf32, buf32Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT64, "uint64 array: %{uint64[]}",
                TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX8, "hex8 array: %{hex8[]}",
                TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX16, "hex16 array: %{hex16[]}",
                TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX32, "hex32 array: %{hex32[]}",
                TOstArray< TUint>( ( TUint* )buf32, buf32Len ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX64, "hex64 array: %{hex64[]}",
                TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) );

#ifdef __WINS__
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_FFIX, "ffix array: %{ffix[]}",
                TOstArray< TReal>( bufFloat, bufFloatLen ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_FEXP, "fexp array: %{fexp[]}",
                TOstArray< TReal>( bufFloat, bufFloatLen ) );
        OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_FOPT, "fopt array: %{fopt[]}",
                TOstArray< TReal>( bufFloat, bufFloatLen ) );
#endif
        Kern::Printf( "--------------TraceCompilerTesterBasic Array Test END----------------" );
        }
    else if (aGroupId == BASIC_TWO_SIMILAR_OK_TEST)
        {
        Kern::Printf( "--------------TraceCompilerTesterBasic Basic Two Similar Test START----------------" );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT8,
                "int8: %hhd %hhd", ( TInt8 )1, ( TInt8 )1 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT16,
                "int16: %hd, %hd", ( TInt16 )2, ( TInt16 )2 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT32,
                "int32: %d, %d", ( TInt )3, ( TInt )3 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT64,
                "int64: %Ld, %Ld", ( TInt64 )4, ( TInt64 )4 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT8,
                "uint8: %hhu, %hhu", ( TUint8 )5, ( TUint8 )5 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT16,
                "uint16: %hu, %hu", ( TUint16 )6, ( TUint16 )6 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT32,
                "uint32: %u, %u", ( TUint )7, ( TUint )7 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT64,
                "uint64: %Lu, %Lu", ( TUint64 )8, ( TUint64 )8 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX8,
                "hex8: %hhx, %hhx", ( TUint8 )9, ( TUint8 )9 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX16,
                "hex16: %hx, %hx", ( TUint16 )10, ( TUint16 )10 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX32,
                "hex32: %x, %x", ( TUint )11, ( TUint )11 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX64,
                "hex64: %Lx, %Lx", ( TUint64 )12, ( TUint64 )12 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_STRING8,
                "ascii: %s, %s", _L8( "STR8" ), _L8( "STR8" ) );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_FFIX,
                "ffix: %f, %f", 0.1, 0.1 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_FEXP,
                "fexp: %e, %f", 0.2, 0.2 );
        OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_FOPT,
                "fopt: %g, %g", 0.3, 0.3 );
        Kern::Printf( "--------------TraceCompilerTesterBasic Basic Two Similar Test END----------------" );
        }
    else if (aGroupId == ARRAY_TWO_SIMILAR_OK_TEST)
        {
        Kern::Printf( "--------------TraceCompilerTesterBasic Array Two Similar Test START----------------" );
        TInt buf8Len = 29;
        TInt8 buf8[ 29 ];
        TInt index = 0;
        TInt value = -17;
        while ( index < buf8Len )
            {
            buf8[ index++ ] = value;
            value++;
            }
        TInt buf16Len = 11;
        TInt16 buf16[ 11 ];
        index = 0;
        value = -3;
        while ( index < buf16Len )
            {
            buf16[ index++ ] = value;
            value += 7;
            }
        TInt buf32Len = 7;
        TInt buf32[ 7 ];
        index = 0;
        value = -73;
        while ( index < buf32Len )
            {
            buf32[ index++ ] = value;
            value += 150;
            }
        TInt buf64Len = 5;
        TInt64 buf64[ 5 ];
        index = 0;
        value = -100000000L;
        while ( index < buf64Len )
            {
            buf64[ index++ ] = value;
            value += 100000000L;
            }

#ifdef __WINS__
        TInt bufFloatLen = 7;
        TReal bufFloat[ 7 ];
        index = 0;
        TReal val = -0.5;
        while ( index < bufFloatLen )
            {
            bufFloat[ index++ ] = val;
            val += 1.5;
            }
#endif

        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT8, "int8: %{int8[]} %{int8[]}",
                TOstArray< TInt8>( ( TInt8* )buf8, buf8Len ), TOstArray< TInt8>( ( TInt8* )buf8, buf8Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT16, "int16: %{int16[]} %{int16[]}",
                TOstArray< TInt16>( ( TInt16* )buf16, buf16Len ), TOstArray< TInt16>( ( TInt16* )buf16, buf16Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT32, "int32: %{int32[]} %{int32[]}",
                TOstArray< TInt>( ( TInt* )buf32, buf32Len ), TOstArray< TInt>( ( TInt* )buf32, buf32Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT64, "int64: %{int64[]} %{int64[]}",
                TOstArray< TInt64>( ( TInt64* )buf64, buf64Len ), TOstArray< TInt64>( ( TInt64* )buf64, buf64Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT8, "uint8: %{uint8[]} %{uint8[]}",
                TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ), TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT16, "uint16: %{uint16[]} %{uint16[]}",
                TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ), TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT32, "uint32: %{uint32[]} %{uint32[]}",
                TOstArray< TUint>( ( TUint* )buf32, buf32Len ), TOstArray< TUint>( ( TUint* )buf32, buf32Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT64, "uint64: %{uint64[]} %{uint64[]}",
                TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ), TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX8, "hex8: %{hex8[]} %{hex8[]}",
                TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ), TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX16, "hex16: %{hex16[]} %{hex16[]}",
                TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ), TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX32, "hex32: %{hex32[]} %{hex32[]}",
                TOstArray< TUint>( ( TUint* )buf32, buf32Len ), TOstArray< TUint>( ( TUint* )buf32, buf32Len ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX64, "hex64: %{hex64[]} %{hex64[]}",
                TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ), TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) );

#ifdef __WINS__
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_FFIX, "ffix: %{ffix[]} %{ffix[]}",
                TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ), TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_FEXP, "fexp: %{fexp[]} %{fexp[]}",
                TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ), TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ) );
        OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_FOPT, "fopt: %{fopt[]} %{fopt[]}",
                TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ), TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ) );

#endif         
        Kern::Printf( "--------------TraceCompilerTesterBasic Array Two Similar Test END----------------" );
        }
    else if (aGroupId == ENUM_OK_TEST)
        {
        Kern::Printf( "--------------TraceCompilerTesterBasic Enum Test START----------------" );
        TInt buf[3];
        buf[0] = KErrNone;
        buf[1] = KErrNotFound;
        buf[2] = KErrGeneral;
        TInt ret = KErrGeneral;
        OstTrace1( ENUM_OK_TEST, TEST_ENUM_OK, "Enum: %{TErrorCodes}", ret );
        OstTraceExt1( ENUM_OK_TEST, TEST_ENUM_ARRAY_OK, "Enum Array: %{TErrorCodes[]}",
                TOstArray< TInt>( ( TInt* )buf, 3 ) );
        Kern::Printf( "--------------TraceCompilerTesterBasic Enum Test END----------------" );
        }
    else if (aGroupId == TRACE_PERFORMANCE)
        {
        Kern::Printf( "--------------TraceCompilerTesterBasic Event Test START----------------" );
       
        OstTraceEventStart0( EVENT_MY_EVENT_TRACE1_START, "Event1" );
        OstTraceEventStop( EVENT_MY_EVENT_TRACE1_STOP, "Event1", EVENT_MY_EVENT_TRACE1_START );

        OstTraceEventStart1( EVENT_MY_EVENT_TRACE2_START, "Event2", 123 );
        OstTraceEventStop( EVENT_MY_EVENT_TRACE2_STOP, "Event2", EVENT_MY_EVENT_TRACE2_START );
        
        Kern::Printf( "--------------TraceCompilerTesterBasic Event Test END----------------" );
        }
    else if (aGroupId == TRACE_FLOW)
        {
        // This test can also use to test function parameters
        Kern::Printf( "--------------TraceCompilerTesterBasic Common Source File Test START----------------");
        DTraceCompilerTesterCommon1* common1 = new DTraceCompilerTesterCommon1();
        TInt32 sum = common1->SumValues(1, 2, 3, 4);
        delete common1;
        Kern::Printf( "--------------TraceCompilerTesterBasic Common Source File Test END----------------");
        }
    else if (aGroupId == INCLUDED_NON_SOURCE_FILE_TEST)
        {
        // Print out traces from included non-source file that is defined in trace.properties file
        Kern::Printf( "--------------TraceCompilerTesterBasic Included Non-Source File Test START----------------" );

        TUint32 value1 = GetBigValue1000();
        TUint32 value2 = GetBigValue2000();

        Kern::Printf( "--------------TraceCompilerTesterBasic Included Non-Source File Test END----------------" );
        }
    else if (aGroupId == KEKKONEN)
        {
        Kern::Printf( "--------------TraceCompilerTesterBasic Kekkonen START----------------" );
        DTraceCompilerTesterCommon2* common2 = new DTraceCompilerTesterCommon2();
        common2->Kekkonen();
        delete common2;
        Kern::Printf( "--------------TraceCompilerTesterBasic Kekkonen END----------------" );
        }
    }

/**
 * Callback function for Trace Deactivation
 * 
 * @param aComponentId
 * @param aGroupId     
 */
void DTraceCompilerTesterBasic::TraceDeactivated(TUint32 aComponentId,
        TUint16 aGroupId)
    {
    Kern::Printf(
            "DTraceCompilerTesterBasic::TraceDeactivated - ComponentId = 0x%x, GroupId = 0x%x",
            aComponentId, aGroupId);
    }
/**
 * The entry point for a standard extension. Creates Long Trace Tester extension.
 *
 *  @return KErrNone, if successful
 */
DECLARE_STANDARD_EXTENSION()
    {

    TInt ret(KErrNone);

    DTraceCompilerTesterBasic* longTraceTester =
            new DTraceCompilerTesterBasic();

    if (longTraceTester == NULL)
        {
        ret = KErrNoMemory;
        }

    if (ret == KErrNone)
        {
        // construct instance
        ret = longTraceTester->Construct();
        }

    return ret;
    }
// End of File