--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/traceservices/tracefw/integ_test/ost/TEF/te_ostv2integsuite_common/src/te_ostv2integsuite_basewrapper.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1268 @@
+// Copyright (c) 2007-2009 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:
+//
+
+
+
+/**
+ @file te_uloggerostv2integsuite_stepbase.cpp
+ @internalTechnology
+*/
+
+#include "te_ostv2integsuite_basewrapper.h"
+
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "te_instrumentationpoints_enabledTraces.h"
+#else
+#include "te_instrumentationpoints_disabledTraces.h"
+#endif
+
+
+CTe_MCLSuiteBaseWrapper::~CTe_MCLSuiteBaseWrapper()
+ {
+ iLoggedTraces.ResetAndDestroy();
+ iLoggedTraces.Close();
+ iSentTraces.ResetAndDestroy();
+ iSentTraces.Close();
+ }
+
+CTe_MCLSuiteBaseWrapper::CTe_MCLSuiteBaseWrapper()
+ {
+ iAlignPosition=-1;
+ iNumMatchingTraces=0;
+ iPosition=0;
+ }
+
+CTe_MCLSuiteBaseWrapper* CTe_MCLSuiteBaseWrapper::NewLC()
+ {
+ CTe_MCLSuiteBaseWrapper* self = new (ELeave)CTe_MCLSuiteBaseWrapper();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+CTe_MCLSuiteBaseWrapper* CTe_MCLSuiteBaseWrapper::NewL()
+ {
+ CTe_MCLSuiteBaseWrapper* self=CTe_MCLSuiteBaseWrapper::NewLC();
+ CleanupStack::Pop(); // self;
+ return self;
+ }
+
+void CTe_MCLSuiteBaseWrapper::ConstructL()
+ {
+ }
+
+TAny* CTe_MCLSuiteBaseWrapper::GetObject()
+ {
+ return NULL;
+ }
+TBool CTe_MCLSuiteBaseWrapper::DoCommandL( const TTEFFunction& /*aCommand*/,
+ const TTEFSectionName& /*aSection*/,
+ const TInt /*aAsyncErrorIndex*/)
+ {
+ return EFalse;
+ }
+
+
+
+
+
+TBool CTe_MCLSuiteBaseWrapper::CreateTraceObject(TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc,RPointerArray<TTraceConfigs> & aTraceObjects)
+ {
+ INFO_PRINTF1(_L("-------- Creating Trace configuration object --------"));
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, UPTNone, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, aGroupId, aComponentId, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace);
+ if(trace && aHasContext)
+ {
+ trace->iContextId = RThread().BTraceId() + 704; //704 is the offset into the RThread and DThread object until we get to the NThread
+ }
+ if (trace)
+ return ETrue;
+ return EFalse;
+ }
+
+TBool CTe_MCLSuiteBaseWrapper::CreateTraceObject(TUPTApiUsed aApi, THasThreadIdentification aHasContext, THasProgramCounter aHasPc,RPointerArray<TTraceConfigs> & aTraceObjects)
+ {
+ INFO_PRINTF1(_L("-------- Creating Trace configuration object --------"));
+ TBool setThreadId = EFalse;
+
+ switch(aApi)
+ {
+ //Tests for all kinds of traces in order to make sure all
+ //payloads are exactly as wanted depending on what trace api you are using.
+ //SetOptions(TTraceConfigs&, TTraceApiUsed, aLoggingEnabled, aTracingBuiltIn);
+ //SetHeader(TTraceConfigs&, TGroupId, TComponentId, THasThreadIdentification, THasProgramCounter, TTraceId);
+ _LIT8(KStateName,"Test State Name");
+ _LIT8(KStateValue,"Test State Value");
+
+ case EUptPrintTDesC8_big:
+ case EUptKernelPrintfDesc8_big:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);
+ TTraceConfigsOperator::SetData(*trace, KStringDesc8);//TPtrC8((const TUint8*)KBigData8, KBigSize8)
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+
+ case EUptPrintTDesC8_huge:
+ case EUptKernelPrintfDesc8_huge:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);
+ TTraceConfigsOperator::SetData(*trace, KStringDescHuge8);//TPtrC8((const TUint8*)KHugeData8, KHugeSize8)
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+
+
+
+ case EUptPrintTDesC16_big:
+#ifndef __KERNEL_MODE__
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintfUnicode);
+ TTraceConfigsOperator::SetData(*trace,KStringDesc16 );//TPtrC16((const TUint16*)KBigData16, KBigSize16)
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+#endif
+ break;
+
+ case EUptPrintTDesC16_huge:
+#ifndef __KERNEL_MODE__
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintfUnicode);
+ TTraceConfigsOperator::SetData(*trace, KStringDescHuge16);//TPtrC16((const TUint16*)KHugeData16, KHugeSize16)
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+#endif
+ break;
+
+// ***
+
+ case EUptTraceTDesC8_big:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KStringDesc8);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+
+ case EUptTraceTDesC8_huge:
+ case EUptKernelTraceDesc8_huge:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KStringDescHuge8);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+
+
+
+ case EUptTraceTDesC16_big:
+#ifndef __KERNEL_MODE__
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace,KStringDesc16);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+#endif
+ break;
+
+ case EUptTraceTDesC16_huge:
+#ifndef __KERNEL_MODE__
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KStringDescHuge16);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+#endif
+ break;
+
+
+ case EUptPrintfchar:
+ case EUptKernelPrintfchar:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);
+ TTraceConfigsOperator::SetData(*trace, KPrintfCStyleString, KPrintfCStyleStringSize);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+
+ case EUptPrintfTRefByValueTDesC8:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TBuf8<42> buf;
+ buf.AppendFormat(KDesC8Formatted,2);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintf);
+ TTraceConfigsOperator::SetData(*trace, buf);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+
+ case EUptPrintfTRefByValueTDesC16:
+#ifndef __KERNEL_MODE__
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TBuf16<44> buf;
+ buf.AppendFormat(KDesCFormatted16,2);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KFormatPrintfUnicode);
+ TTraceConfigsOperator::SetData(*trace, buf);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+#endif
+ break;
+ case EUptTrace:
+ case EUptKernelTrace:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ //There is no additional data
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTUint32:
+ case EUptKernelTraceTUint32:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KData1);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTUint32TUint32:
+ case EUptKernelTraceTUint32TUint32:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData2);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTAnySmallStruct:
+ case EUptKernelTraceTAnySmallStruct:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, (TAny*)KSmallData, KSmallSize);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTAnyBigStruct:
+ case EUptKernelTraceTAnyBigStruct:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KBigData8, KBigSize8);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTAnyHugeStruct:
+ case EUptKernelTraceTAnyHugeStruct:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KHugeData8, KHugeSize8);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTemplatedSmallStruct:
+ case EUptKernelTraceTemplatedSmallStruct:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KStructForTemplated);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTemplatedBigStruct:
+ case EUptKernelTraceTemplatedBigStruct:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KBigData8, KBigSize8);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptTraceTemplatedHugeStruct:
+ case EUptKernelTraceTemplatedHugeStruct:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ TTraceConfigsOperator::SetData(*trace, KHugeData8, KHugeSize8);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EUptIsTraceActive:
+ case EUptKernelIsTraceActive:
+ break;
+ case UPTTraceTest:
+ break;
+ case UPTKernelTraceTest:
+ case UPTKernelNegativeFunctionalityTest:
+ {
+ TTraceConfigs* trace1 = new TTraceConfigs;
+ ASSERT(trace1);
+ TTraceConfigsOperator::Init(*trace1);
+ TTraceConfigsOperator::SetOptions(*trace1, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace1, KGroupId+1, KComponentId+1, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace1);
+
+ TTraceConfigs* trace2 = new TTraceConfigs;
+ ASSERT(trace2);
+ TTraceConfigsOperator::Init(*trace2);
+ TTraceConfigsOperator::SetOptions(*trace2, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace2, KGroupId+2, KComponentId+2, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace2);
+
+ setThreadId = aHasContext;
+ }
+ break;
+ case UPTKernelMultipleFunctionalityTest:
+ {
+ TTraceConfigs* trace1 = new TTraceConfigs;
+ ASSERT(trace1);
+ TTraceConfigsOperator::Init(*trace1);
+ TTraceConfigsOperator::SetOptions(*trace1, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace1, KGroupId, KComponentId, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace1);
+
+ TTraceConfigs* trace2 = new TTraceConfigs;
+ ASSERT(trace2);
+ TTraceConfigsOperator::Init(*trace2);
+ TTraceConfigsOperator::SetOptions(*trace2, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace2, KGroupId+1, KComponentId, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace2);
+
+ TTraceConfigs* trace3 = new TTraceConfigs;
+ ASSERT(trace3);
+ TTraceConfigsOperator::Init(*trace3);
+ TTraceConfigsOperator::SetOptions(*trace3, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace3, KGroupId+2, KComponentId, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace3);
+
+ TTraceConfigs* trace4 = new TTraceConfigs;
+ ASSERT(trace4);
+ TTraceConfigsOperator::Init(*trace4);
+ TTraceConfigsOperator::SetOptions(*trace4, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace4, KGroupId, KComponentId+2, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace4);
+
+ TTraceConfigs* trace5 = new TTraceConfigs;
+ ASSERT(trace5);
+ TTraceConfigsOperator::Init(*trace5);
+ TTraceConfigsOperator::SetOptions(*trace5, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace5, KGroupId+2, KComponentId+2, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace5);
+
+ TTraceConfigs* trace6 = new TTraceConfigs;
+ ASSERT(trace6);
+ TTraceConfigsOperator::Init(*trace6);
+ TTraceConfigsOperator::SetOptions(*trace6, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace6, KGroupId+1, KComponentId+2, aHasContext, aHasPc, KTraceId);
+ aTraceObjects.Append(trace6);
+
+ TTraceConfigs* trace7 = new TTraceConfigs;
+ ASSERT(trace7);
+ TTraceConfigsOperator::Init(*trace7);
+ TTraceConfigsOperator::SetOptions(*trace7, aApi, ETrue, ETrue);
+ aTraceObjects.Append(trace7);
+
+ setThreadId = aHasContext;
+ }
+ break;
+
+ //OST
+
+ case EOstTraceDef0:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDef0&TRACEIDMASK)>>TRACEIDSHIFT);
+ //TTraceConfigsOperator::SetData(*trace, TEST_OstTraceDef0); //no additional data
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceDef1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDef1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceDefData:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefData&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, &KData1, sizeof(KData1) );
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceDefExt1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, (TUint32*)KDefault8().Ptr(),KDefault8().Size());
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceDefExt2:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt2&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceDefExt3:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt3&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceDefExt4:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt4&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceDefExt5:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceDefExt5&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTrace0:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACE0&TRACEIDMASK)>>TRACEIDSHIFT);
+ //TTraceConfigsOperator::SetData(*trace, TEST_OSTTRACE0);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTrace1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACE1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace,KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceData:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEDATA&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, &KData1, sizeof(KData1) );
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceExt1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData8);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceExt2:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT2&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceExt3:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT3&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceExt4:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT4&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceExt5:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace,TRACE_FATAL, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEXT5&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1, KData1, KData1, KData1, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceFunctionEntry0:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTraceFunctionalityEntry0&TRACEIDMASK)>>TRACEIDSHIFT);
+ //TTraceConfigsOperator::SetData(*trace, TEST_OSTTraceFunctionalityEntry0);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceFunctionEntry1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTraceFunctionalityEntry1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceFunctionEntryExt:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (0x8a0003&TRACEIDMASK)>>TRACEIDSHIFT);
+ //fix this - should be a list of the function arguments of this method all these traces are insturmented in
+ TTraceConfigsOperator::SetData(*trace, KData1);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceFunctionExit0:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OstTraceFunctionExit0&TRACEIDMASK)>>TRACEIDSHIFT);
+ //TTraceConfigsOperator::SetData(*trace, TEST_OstTraceFunctionExit0);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceFunctionExit1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEFUNCTIONEXIT1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceFunctionExitExt:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_FLOW, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEFUNCTIONEXITEXT&TRACEIDMASK)>>TRACEIDSHIFT);
+ //fix this
+ TTraceConfigsOperator::SetData(*trace, (TUint32)KData1, (TUint32)0);
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceEventStart0:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_PERFORMANCE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEVENTSTART0&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace,(TUint32)1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceEventStart1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_PERFORMANCE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEVENTSTART1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceEventStop:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_PERFORMANCE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACEEVENTSTOP&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace,0,(TUint32)(TEST_OSTTRACEEVENTSTART0 & TRACEIDMASK));
+ setThreadId = aHasContext;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceState0:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_STATE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACESTATE0&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KStateName,KStateValue);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ case EOstTraceState1:
+ {
+ TTraceConfigs* trace = new TTraceConfigs;
+ ASSERT(trace);
+ TTraceConfigsOperator::Init(*trace);
+ TTraceConfigsOperator::SetOptions(*trace, aApi, ETrue, ETrue);
+ TTraceConfigsOperator::SetHeader(*trace, TRACE_STATE, KComponentId, EAddThreadIdentification, ENoProgramCounter, (TEST_OSTTRACESTATE1&TRACEIDMASK)>>TRACEIDSHIFT);
+ TTraceConfigsOperator::SetData(*trace, KStateName,KStateValue,KData1);
+ setThreadId = EAddThreadIdentification;
+ aTraceObjects.Append(trace);
+ }
+ break;
+ default:
+ //delete trace;
+ //trace = NULL;
+ break;
+ }
+
+ for(TInt i = 0; i <= (aTraceObjects.Count()-1); i++)
+ {
+ if(aTraceObjects[i] && setThreadId)
+ {
+ aTraceObjects[i]->iContextId = RThread().BTraceId() + 704; //704 is the offset into the RThread and DThread object until we get to the NThread
+ }
+ }
+
+ TBool realTrace=EFalse;
+ if (aTraceObjects.Count())
+ {
+ realTrace=ETrue;
+ }
+ switch(aApi)
+ {
+ case UPTTraceTest:
+ case UPTKernelTraceTest:
+ case UPTKernelNegativeFunctionalityTest:
+ case UPTKernelMultipleFunctionalityTest:
+ case UPTBaseline:
+ case UPTKernelBaseline:
+ case UPTFooUserTime:
+ case UPTFooKernelTime:
+ realTrace = EFalse;
+ break;
+ default:
+ break;
+ }
+
+ return realTrace;
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::StoreTraceInfo(TBool aEnumBased,TUPTApiUsed anApi,TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc)
+ {
+ INFO_PRINTF1(_L("-------- Storing trace information --------"));
+ TInt lastError = KErrNone;
+ RPointerArray<TTraceConfigs> traceObjects(10);
+ TBool realTrace=EFalse;
+
+ if (aEnumBased)
+ {
+ realTrace=CreateTraceObject(anApi,aHasContext,aHasPc,traceObjects);
+ }
+ else
+ {
+ realTrace=CreateTraceObject(aComponentId, aGroupId,aHasContext, aHasPc, traceObjects);
+ }
+
+
+ if(traceObjects.Count()&&realTrace)
+ {
+ for(TInt i = 0; i <=(traceObjects.Count()-1); i++)
+ {
+ iSentTraces.Append(traceObjects[i]);
+ }
+ }
+
+ if (!realTrace)
+ {
+ lastError=KErrNone;
+ INFO_PRINTF3(_L("INFO: Trace object (TTraceConfigs) not created, because no actual trace sent error %i, API %i. "), lastError,anApi);
+ }
+ traceObjects.Reset();
+ return lastError;
+ }
+
+void CTe_MCLSuiteBaseWrapper::CreateTraceHeaderObject(TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc,TTraceHeaderInfo*& aHeaderInfo)
+ {
+ //INFO_PRINTF1(_L("-------- Creating Trace header object --------"));
+ TTraceConfigsOperator::Init(*aHeaderInfo);
+ TTraceConfigsOperator::SetHeader(*aHeaderInfo, aGroupId, aComponentId, aHasContext, aHasPc, KInitialClientFormat);
+ if(aHasContext)
+ {
+ aHeaderInfo->iContextId = RThread().BTraceId() + 704; //704 is the offset into the RThread and DThread object until we get to the NThread
+ }
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::StoreTraceHeaderInfo(TComponentId aComponentId, TGroupId aGroupId,THasThreadIdentification aHasContext, THasProgramCounter aHasPc)
+ {
+ //INFO_PRINTF1(_L("-------- Storing trace header information --------"));
+ TInt lastError = KErrNone;
+ TTraceHeaderInfo* headerInfo= new TTraceHeaderInfo;
+ ASSERT(headerInfo);
+ CreateTraceHeaderObject(aComponentId, aGroupId,aHasContext, aHasPc, headerInfo);
+
+ TRAP(lastError,(iSentTraceHeaders->AppendL(headerInfo)));
+ if (lastError)
+ {
+ INFO_PRINTF2(_L("Error: Unable to append trace header object to array. error: %i "), lastError);
+ delete headerInfo;
+ }
+
+ return lastError;
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::ReadFromLogFile(const TDesC& aFileName)
+ {
+ INFO_PRINTF2(_L("-------- Reading from log file -------- %S"), &aFileName);
+ //read data...
+ TUint bufferSize = 0;
+ TUint8* traceBuffer = NULL;
+
+
+ TRAPD(error, (error = GetDataL(traceBuffer, bufferSize, aFileName)));
+ if(!bufferSize || error)
+ {
+ INFO_PRINTF2(_L("ERROR: Error reading from logfile %i. "), error);
+ return error;
+ }
+ // process all the complete traces in buffer...
+ error = iParser.ParseRawBuffer(traceBuffer, bufferSize, iLoggedTraces);
+ INFO_PRINTF2(_L("Number of additional traces (not sent from test suite) is %d"),iParser.iNumSystemTraces);
+ delete traceBuffer; //done with it, so delete it
+ return error;
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::ReadHeaderFromLogFile(const TDesC& aFileName)
+ {
+ INFO_PRINTF1(_L("-------- Reading headers info from log file --------"));
+ TUint bufferSize = 1;
+ TUint8* traceBuffer = NULL;
+ TUint position= 0;
+ iHeaderParser.iNumSystemTraces=0;
+ iPosition=0;
+ iAlignPosition=-1;
+ iNumMatchingTraces=0;
+ TInt error=KErrNone;
+ //read data...
+ while (bufferSize&&!error)
+ {
+ TRAP(error, (error = GetDataL(traceBuffer, bufferSize, position, aFileName)));
+ if(!bufferSize || error)
+ {
+ INFO_PRINTF2(_L("ERROR: Error reading from logfile %i. "), error);
+ if (traceBuffer)
+ delete traceBuffer;
+ break;
+ }
+ // process all the complete traces in buffer...
+ error = iHeaderParser.ParseRawBuffer(traceBuffer, bufferSize, iLoggedTraceHeaders);
+ if (error)
+ INFO_PRINTF2(_L("ERROR: Error parsing info from logfile %i. "), error);
+ delete traceBuffer; //done with it for now, so delete it (GetDataL() always allocates new memory)
+ if (!error)
+ CompareTraceHeaders();
+ for (TInt i=0; i<iLoggedTraceHeaders->Count(); i++)
+ {
+ delete iLoggedTraceHeaders->At(i);
+ }
+ iLoggedTraceHeaders->Delete(0,iLoggedTraceHeaders->Count()); //empty out array to save space
+
+ if (iSentTraceHeaders->Count()>=1)
+ {
+ for (TInt i=0; i<iPosition; i++)
+ {
+ delete iSentTraceHeaders->At(i);
+ }
+ iSentTraceHeaders->Delete(0,iPosition);
+ iSentTraceHeaders->Compress();
+ }
+ iPosition=0;
+ position+=bufferSize;
+ }
+ INFO_PRINTF2(_L("Number of additional traces (not sent from test suite) is %d"),iHeaderParser.iNumSystemTraces);
+ INFO_PRINTF2(_L("Number of matching traces is %d"),iNumMatchingTraces);
+ INFO_PRINTF2(_L("Position of alignment is %d"),iAlignPosition);
+ return error;
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::CompareTraces()
+ {
+ INFO_PRINTF1(_L("-------- Comparing Traces --------"));
+ TInt error = KErrNone;
+ if(iLoggedTraces.Count() != iSentTraces.Count())
+ {
+ INFO_PRINTF3(_L("ERROR: Different amount of traces written (%i) and read (%i). "), iSentTraces.Count(), iLoggedTraces.Count());
+ error = KErrCorrupt;//will be ignored..
+ }
+
+ TInt count = 0;
+ if(iLoggedTraces.Count() > iSentTraces.Count())
+ count = iSentTraces.Count();
+ else
+ count = iLoggedTraces.Count();
+
+ for(TInt i = 0; i < count; i++)
+ {
+ TTraceConfigs* logged = iLoggedTraces[i];
+ TTraceConfigs* sent = iSentTraces[i];
+
+ INFO_PRINTF2(_L("--- Trace %i ---"), sent->iApiUsed);
+
+ //module uid ...
+ if(logged->iComponentId == sent->iComponentId)
+ INFO_PRINTF2(_L("ComponentId %i - ok"), sent->iComponentId);
+ else
+ {
+ INFO_PRINTF3(_L("ComponentId - ERROR: sent %i, logged %i"), sent->iComponentId, logged->iComponentId);
+ error = KErrCorrupt;
+ }
+
+ //GroupId ...
+ if(logged->iGroupId == sent->iGroupId)
+ INFO_PRINTF2(_L("GroupId %i - ok"), logged->iGroupId);
+ else
+ {
+ INFO_PRINTF3(_L("GroupId - ERROR: sent %i, logged %i"), sent->iGroupId, logged->iGroupId);
+ error = KErrCorrupt;
+ }
+
+ //sub-category ...
+ if(logged->iSubCategory == sent->iSubCategory)
+ INFO_PRINTF2(_L("SubCategory %i - ok"), sent->iSubCategory);
+ else
+ {
+ INFO_PRINTF3(_L("SubCategory - ERROR: sent %i, logged %i"), sent->iSubCategory, logged->iSubCategory);
+ error = KErrCorrupt;
+ }
+
+ //format id ...
+ if(logged->iTraceId == sent->iTraceId)
+ {
+ INFO_PRINTF2(_L("TraceId %i - ok"), sent->iTraceId);
+ }
+ else
+ {
+ INFO_PRINTF3(_L("TraceId - ERROR: sent %i, logged %i"), sent->iTraceId, logged->iTraceId);
+ error = KErrCorrupt;
+ }
+
+ //context id present ...
+ if(logged->iHasThreadId == sent->iHasThreadId)
+ INFO_PRINTF2(_L("ContextId included %i - ok"), (TInt) sent->iHasThreadId);
+ else
+ {
+ INFO_PRINTF3(_L("ContextId included - ERROR: sent %i, logged %i"), sent->iHasThreadId, logged->iHasThreadId);
+ error = KErrCorrupt;
+ }
+
+ //pc present ...
+ if(logged->iHasProgramCounter == sent->iHasProgramCounter)
+ INFO_PRINTF2(_L("Pc included %i - ok"), (TInt) sent->iHasProgramCounter);
+ else
+ {
+ INFO_PRINTF3(_L("Pc included - ERROR: sent %i, logged %i"), sent->iHasProgramCounter, logged->iHasProgramCounter);
+ error = KErrCorrupt;
+ }
+
+ //context id value ...
+ if(sent->iContextId == logged->iContextId)
+ INFO_PRINTF2(_L("ContextId value 0x%x - ok"), (TInt) sent->iContextId);
+ else
+ {
+ //INFO_PRINTF3(_L("ContextId value - ERROR: sent 0x%x, logged 0x%x"), sent->iContextId, logged->iContextId);
+ //INFO_PRINTF1(_L("Integration test suite does not support checking of context ID - this is done in the unit test suite"));
+ //error = KErrCorrupt;
+ }
+
+ //pc value...
+ if(sent->iPc == logged->iPc)
+ INFO_PRINTF2(_L("Pc value 0x%x - ok"), (TInt) sent->iPc);
+ else
+ {
+ //not set to be corrupt now because PC isn't working properly yet
+ INFO_PRINTF3(_L("Pc value - ERROR: sent 0x%x, logged 0x%x"), sent->iPc, logged->iPc);
+ //error = KErrCorrupt;
+ }
+
+ //payload ...
+ TInt j = sizeof(sent->iRawData)/4 - 1;
+ TBool payloadIsEqual = ETrue;
+ while(j >= 0)
+ {
+ if(sent->iRawData[j] != logged->iRawData[j])
+ {
+ payloadIsEqual = EFalse;
+ break; //bad payload
+ }
+ j--;
+ }
+ if(payloadIsEqual)
+ INFO_PRINTF2(_L("Payload \"%s\" - ok"), sent->iRawData);
+ else
+ {
+ TUint16* sentPtr = (TUint16*) sent->iRawData;
+ TUint16* loggedPtr = (TUint16*) logged->iRawData;
+ INFO_PRINTF3(_L("Payload - ERROR: sent \"%s\", logged \"%s\""), sentPtr, loggedPtr);
+ INFO_PRINTF7(_L("Payload - sent [0x%x][0x%x][0x%x][0x%x][0x%x][0x%x]"), sent->iRawData[0],sent->iRawData[1],sent->iRawData[2],sent->iRawData[3],sent->iRawData[4],sent->iRawData[5]);
+ INFO_PRINTF7(_L("Payload - logged [0x%x][0x%x][0x%x][0x%x][0x%x][0x%x]"), logged->iRawData[0], logged->iRawData[1], logged->iRawData[2], logged->iRawData[3], logged->iRawData[4], logged->iRawData[5]);
+ error = KErrCorrupt;
+ }
+ }
+ return error;
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::CompareTraceHeaders()
+ {
+ TInt error = KErrCorrupt;
+
+ for(TInt i = iPosition; ((error!=KErrNone)&&(iSentTraceHeaders->Count()>iPosition)); i++)
+ {
+
+ if (iLoggedTraceHeaders->Count()==0)
+ {
+ INFO_PRINTF1(_L("iLoggedTraceHeaders array is empty"));
+ break;
+ }
+ TTraceHeaderInfo* logged = iLoggedTraceHeaders->At(0);
+ TTraceHeaderInfo* sent = iSentTraceHeaders->At(i);
+
+ //module uid ...
+ if(logged->iComponentId == sent->iComponentId)
+ {
+ error = KErrNone;
+ }
+ else
+ {
+ error = KErrCorrupt;
+ }
+
+ //GroupId ...
+ if(logged->iGroupId == sent->iGroupId){}
+ else
+ {
+ error = KErrCorrupt;
+ }
+
+ //sub-category ...
+ if(logged->iSubCategory == sent->iSubCategory){}
+ else
+ {
+ error = KErrCorrupt;
+ }
+
+ //format id ...
+ if(logged->iTraceId == sent->iTraceId)
+ {}
+ else
+ {
+ error = KErrCorrupt;
+ }
+
+ //context id present ...
+ if(logged->iHasThreadId == sent->iHasThreadId){}
+ else
+ {
+ error = KErrCorrupt;
+ }
+
+ //pc present ...
+ if(logged->iHasProgramCounter == sent->iHasProgramCounter){}
+
+ else
+ {
+ error = KErrCorrupt;
+ }
+
+ //context id value ...
+ if(sent->iContextId == logged->iContextId){}
+ else
+ {
+ error = KErrCorrupt;
+ }
+
+ //pc value...
+ if(sent->iPc == logged->iPc){}
+ else
+ {
+ //wont set to be corrupt now because PC isn't working properly yet
+ //error = KErrCorrupt;
+ }
+
+ if (error==KErrNone)
+ {
+ iNumMatchingTraces++;
+ if(iAlignPosition==-1)
+ {
+ iAlignPosition=iPosition;
+ }
+ }
+ iPosition++;
+ }
+ return error;
+ }
+
+
+TInt CTe_MCLSuiteBaseWrapper::GetDataL(TUint8*& aData, TUint& aSize,const TDesC& aFileName)
+ {
+ RFs fsSession;
+ CleanupClosePushL(fsSession);
+ User::LeaveIfError(fsSession.Connect());
+
+ RFile file;
+ TInt error = file.Open(fsSession, aFileName, EFileRead);
+ if(error == KErrNone)
+ {
+ TInt size = 0;
+ file.Size(size);
+ aSize = size;
+ aData = new TUint8[aSize];
+ if(!aData)
+ error = KErrNoMemory;
+ if(!error)
+ {
+ TPtr8 ptr(aData, aSize);
+ error = file.Read(ptr);
+ }
+ file.Close();//is really called at fsSession.Close();
+ fsSession.Close();
+ }
+ CleanupStack::PopAndDestroy();//fsSession
+ return error;
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::GetDataL(TUint8*& aData, TUint& aBytesRead, TUint aPosition, const TDesC& aFileName)
+ {
+ RFs fsSession;
+ CleanupClosePushL(fsSession);
+ User::LeaveIfError(fsSession.Connect());
+
+ RFile file;
+ TInt error = file.Open(fsSession, aFileName, EFileRead);
+ if(error == KErrNone)
+ {
+ TUint8* size= new TUint8;
+ TInt traceSize;
+ //file.Size(size);
+ TPtr8 ptr(size, 1); //read first byte from start position, which should be size of trace
+ error = file.Read(aPosition, ptr, 1);
+ traceSize = *size;
+ aData = new TUint8[traceSize];
+ if(!aData)
+ error = KErrNoMemory;
+ if(!error)
+ {
+ TPtr8 ptr2(aData, traceSize);
+ error = file.Read(aPosition,ptr2,traceSize);
+ aBytesRead=ptr2.Length();
+ }
+ file.Close();//is really called at fsSession.Close();
+ fsSession.Close();
+ }
+ CleanupStack::PopAndDestroy();//fsSession
+ return error;
+ }
+
+TInt CTe_MCLSuiteBaseWrapper::EmptyFile(const TDesC& aFileName)
+ {
+ RFs outputFileSession;
+ RFile outputFile;
+ TInt err = outputFileSession.Connect();
+ //delete the output file (i.e. replace with a zero length file) and close the sessions
+ err=outputFile.Replace(outputFileSession, aFileName ,EFileWrite);
+ outputFile.Close();
+ outputFileSession.Close();
+
+ return err;
+ }
+