// Copyright (c) 2006-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:

//

#include <e32base.h>

#include "symbianelfformatter.h"

#include "tsymbianelfformatter.h"

CSymbianElfFormatterTest * CSymbianElfFormatterTest::NewL(RTest &itest)

{

    CSymbianElfFormatterTest *self = CSymbianElfFormatterTest::NewLC(itest);

    CleanupStack::Pop();

    return self;

}

CSymbianElfFormatterTest * CSymbianElfFormatterTest::NewLC(RTest &itest)

{

    CSymbianElfFormatterTest *self = new(ELeave) CSymbianElfFormatterTest(itest);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

void CSymbianElfFormatterTest::ConstructL()

{

    server = new(ELeave) CTestCrashDataSource;

    formatter = CSymbianElfFormatter::NewL();

	iStrInfoTbl = CStringInfoTable::NewL();

    writer = CTestDataSave::NewL();

    formatter->ConfigureDataSaveL(writer);

    formatter->ConfigureDataSourceL(server);

}

CSymbianElfFormatterTest::CSymbianElfFormatterTest(RTest &aTest) : itest(aTest) { }

CSymbianElfFormatterTest::~CSymbianElfFormatterTest()

{

    delete server;

    delete writer;

    delete iStrInfoTbl;

    delete formatter;

}

void CSymbianElfFormatterTest::CleanupEComArray(TAny* aArray)

{

	(static_cast<RImplInfoPtrArray*> (aArray))->ResetAndDestroy();

    REComSession::FinalClose();

}

void CSymbianElfFormatterTest::TestSuiteL(TSuite aSuite)

{

    RDebug::Print(_L("-> TestSuite(%d)\n"), aSuite);

    TInt err;

    //TInt handle;

    //           123456789012345678901

    TBuf<23> name(KTestName); 

    name.AppendNum(aSuite);

    itest.Next(name);

	iCrashInfo.iType = TCrashInfo::ECrashException;

	iCrashInfo.iExcNumber = KCrashExcCode;

	iCrashInfo.iTime = KCrashTime;

	iCrashInfo.iPid = KCrashPid;

	iCrashInfo.iTid = KCrashTid;

	iCrashInfo.iContext.iFaultAddress = KCrashFaultAddress;

	iCrashInfo.iContext.iFaultStatus = KCrashFaultStatus;

	iCrashInfo.iContext.iR15 = KRegValue32 + KCrashTid;

	iCrashInfo.iContext.iR13Svc = iCrashInfo.iContext.iR15 + 1;

	iCrashInfo.iContext.iR14Svc = iCrashInfo.iContext.iR15 + 2;

	iCrashInfo.iContext.iSpsrSvc = iCrashInfo.iContext.iR15 + 3;

	if( iStrInfoTbl )

		delete iStrInfoTbl;

	iStrInfoTbl = CStringInfoTable::NewLC();

	formatter->iStrInfoTbl = iStrInfoTbl;

    RBuf8 reference;

    switch(aSuite)

    {

        case EConfigData:

        {

            RDebug::Print(_L("EConfigData starting...\n"));

            TRAP(err, formatter->ConfigureDataSourceL(server));

            itest(err == KErrNone);

            itest(server == formatter->iDataSource);

            TRAP(err, formatter->ConfigureDataSaveL(writer));

            itest(err == KErrNone);

            itest(writer == formatter->iDataSave);

            TRAP(err, formatter->ConfigureDataSourceL(NULL)); 

            itest(err == KErrNoMemory);

            TRAP(err, formatter->ConfigureDataSaveL(NULL));

            itest(err == KErrNoMemory);

            RDebug::Print(_L("EConfigData passed!\n"));

            break;

        }

        case EFindImplementation:

        {

            RDebug::Print(_L("EFindImplementation starting...\n"));

            RImplInfoPtrArray infoArray;

            TCleanupItem cleanup(CSymbianElfFormatterTest::CleanupEComArray, (TAny*)&infoArray);

            CleanupStack::PushL(cleanup);

            TRAPD(err, CSymbianElfFormatter::ListAllImplementationsL(infoArray));

            itest(err == KErrNone);

            CCoreDumpFormatter* formatter = 0;

            RBuf description;

            description.CreateL(MaxPluginDescription);

            CleanupClosePushL(description);

            err = KErrNotFound;

            for (TInt i = 0; i < infoArray.Count(); i++)

            {

                TUid uid = infoArray[i]->ImplementationUid();

                formatter = CCoreDumpFormatter::NewL(uid);

                formatter->GetDescription(description);

                delete formatter;

                RDebug::Print(_L("found plugin[%d]: (%S)\n"), i, &description);

                if(description == KPluginDescription())

                {

                    itest(uid == KSymbianElfFormatterUid);

                    err = KErrNone;

                    break;

                }

                description.Zero();

            }

            CleanupStack::PopAndDestroy();

            description.Close();

            itest(err == KErrNone);

            CleanupStack::PopAndDestroy(); // infoArray, results in a call to CleanupEComArray

            break;

        }

        case EWriteSymbianInfo:

        {

			RDebug::Print(_L("EWriteSymbianInfo starting...\n"));

            TRAP(err, formatter->ConfigureDataSourceL(server));

            itest(err == KErrNone);

            itest(server == formatter->iDataSource);

            TRAP(err, formatter->ConfigureDataSaveL(writer));

            itest(err == KErrNone);

            itest(writer == formatter->iDataSave);

            reference.CreateL( sizeof(Sym32_dhdr) + sizeof(Sym32_syminfod) );

            CleanupClosePushL(reference);

            TPtrC8 ptr;

            Sym32_dhdr dhdr;

            ptr.Set(reinterpret_cast<TUint8*>(&dhdr), sizeof(Sym32_dhdr));

            TInt32 index = iStrInfoTbl->GetIndex(KSymbian);

            dhdr.d_name	= (index == KErrNotFound) ? ESYM_STR_UNDEF : index;

            dhdr.d_descrsz	= sizeof(Sym32_syminfod);

            dhdr.d_type	= ESYM_NOTE_SYM;

            dhdr.d_version = iStrInfoTbl->GetIndex(KSymbianElfCoreDumpVersion);

            dhdr.d_elemnum = 1;

            reference.Append(ptr);

            Sym32_syminfod seg;

            ptr.Set(reinterpret_cast<TUint8*>(&seg), sizeof(Sym32_syminfod));

            seg.sd_date_time = (Elf64_Word)KCrashTime;

            seg.sd_exit_type = KCrashType;

            seg.sd_exit_reason = KCrashReason;

            seg.sd_thread_id = KCrashTid;

            seg.sd_proc_id = KCrashPid;

            TBuf8<KMaxExitCategoryName> buf;

            buf.Copy(KCrashCategory);

            if (buf.Length() > 0)

            {

                iStrInfoTbl->AddStringL(buf);

            }

            index = iStrInfoTbl->GetIndex(buf);

            seg.sd_exit_cat = (index == KErrNotFound) ? ESYM_STR_UNDEF : index;

            Sym32_execid id = {I64LOW(KCrashTime), KCrc32};            

            seg.sd_execid = id;

            reference.Append(ptr);

            writer->OpenL(_L("") ); //clear writer buffer

			formatter->iOffset = 0;

            TInt offset = 0;

			RDebug::Print(_L("->formatter->WriteSymbianInfoL( )\n"));

			formatter->WriteSymbianInfoL( iCrashInfo, KCrc32 );

			RDebug::Print(_L("<-formatter->WriteSymbianInfoL( )\n"));

            itest(offset + sizeof(Sym32_dhdr) + sizeof(Sym32_syminfod) == formatter->iOffset);

			itest(offset != formatter->iOffset);

			//RDebug::Print(_L("itest3\n"));

            //itest(reference == writer->iData);

			//writer->Print();						

            itest(reference != _L8(""));

            CleanupStack::PopAndDestroy(&reference);

            break;

        }

        case EWriteCodeSegments:

        {

			RDebug::Print(_L("EWriteCodeSegments starting...\n"));

            TRAP(err, formatter->ConfigureDataSourceL(server));

            itest(err == KErrNone);

            itest(server == formatter->iDataSource);

            TRAP(err, formatter->ConfigureDataSaveL(writer));

            itest(err == KErrNone);

            itest(writer == formatter->iDataSave);

			RCodeSegPointerList codeSegs;

			RArray<TUint> codeSegOffsets;

			CleanupClosePushL(codeSegOffsets);

			TUint totalCodeSegListDescSize;

			RDebug::Print(_L("server->GetCodeSegmentsL( KCrashTid, codeSegs );\n"));

			server->GetCodeSegmentsL( KCrashTid, codeSegs, totalCodeSegListDescSize );

			formatter->iOffset = 0;

			writer->OpenL(_L("") ); //clear writer buffer

			RDebug::Print(_L("formatter->WriteCodeSegmentsL( KCrashTid, codeSegs, codeSegOffsets );\n"));

            formatter->WriteCodeSegmentsL( KCrashTid, codeSegs, codeSegOffsets );

			RDebug::Print(_L("itest(codeSegOffsets.Count() == KCodeSegsCount );\n"));

			itest(codeSegOffsets.Count() == KCodeSegsCount );

			for(TInt i = 0; i < KCodeSegsCount; i++)

            {

				RDebug::Printf( "itest( codeSegs[i] = %d );\n", codeSegOffsets[i] );

                itest( codeSegOffsets[i] == 0 );

            }

			RDebug::Printf( "itest(0 == formatter->iOffset);" );

            itest(0 == formatter->iOffset);

			RDebug::Printf( "CleanupStack::PopAndDestroy(&codeSegOffsets);" );

			CleanupStack::PopAndDestroy(&codeSegOffsets);

			RDebug::Printf( "CleanupStack::PopAndDestroy(&codeSegs);" );

            codeSegs.ResetAndDestroy();

            break;

        }

        case EWriteDataSegments:

        {

			RDebug::Print(_L("EWriteDataSegments starting...\n"));

            TRAP(err, formatter->ConfigureDataSourceL(server));

            itest(err == KErrNone);

            itest(server == formatter->iDataSource);

            TRAP(err, formatter->ConfigureDataSaveL(writer));

            itest(err == KErrNone);

            itest(writer == formatter->iDataSave);

            reference.CreateL(KDataSegsCount * (KDataSegSize + KCrashPid + KDataSegsCount*(KDataSegsCount+1)/2) ); 

            CleanupClosePushL(reference);

            RBuf8 buf;

            buf.CreateL((KDataSegSize + KCrashPid + KDataSegsCount));

            for(TInt i = 0; i < KDataSegSize + KCrashPid + KDataSegsCount; ++i)

                    buf.Append((TUint8*)&i, 1);

            for(TInt i = 0; i < KDataSegsCount; ++i)

            {

                reference.Append(buf.Ptr(), KDataSegSize + KCrashPid + i);

            }

            buf.Close();

			formatter->iOffset = 0;

            TInt offset = formatter->iOffset;

			RThreadPointerList *threadList = new(ELeave)RThreadPointerList ;

			formatter->iDataSource->GetThreadListL((TUint64)KCrashPid, *threadList);

			RCodeSegPointerList codeSegs;

			CleanupClosePushL(codeSegs);

			CSymbianElfFormatter::RSegmentList dataSegs;

			CleanupClosePushL(dataSegs);

			RArray<TUint> dataSegOffsets;

			CleanupClosePushL(dataSegOffsets);

			writer->OpenL(_L("") ); //clear writer buffer

            formatter->WriteDataSegmentsL( 

				KCrashTid, 

				KCrashPid, 

				*threadList, 

				codeSegs, 

				dataSegs, 

				dataSegOffsets );

			//RDebug::Print(_L("itest1\n"));

            //itest(offset + reference.Length() == formatter->iOffset);

			RDebug::Print(_L("itest2\n"));

            itest(offset != formatter->iOffset);

			//RDebug::Print(_L("itest3\n"));

            //itest(reference == writer->iData);

			// Note that the number of sements is not the same as KDataSegsCount, 

			//since we also create thread stack segments

			RDebug::Print(_L("itest4\n"));

            itest(reference != _L8(""));

			threadList->ResetAndDestroy();

			threadList->Close();

			delete threadList;

			CleanupStack::PopAndDestroy(&dataSegOffsets);

			CleanupStack::PopAndDestroy(&dataSegs);

			CleanupStack::PopAndDestroy(&codeSegs);

            CleanupStack::PopAndDestroy(); //reference

            break;

        }

        case EWriteThreadsInfo:

        {

			RDebug::Print(_L("EWriteThreadsInfo  starting...\n"));

            TRAP(err, formatter->ConfigureDataSourceL(server));

            itest(err == KErrNone);

            itest(server == formatter->iDataSource);

            TRAP(err, formatter->ConfigureDataSaveL(writer));

            itest(err == KErrNone);

            itest(writer == formatter->iDataSave);

            reference.CreateL( sizeof(Sym32_dhdr) + sizeof(Sym32_thrdinfod)*KCrashThreadsCount );

            CleanupClosePushL(reference);

            TPtrC8 ptr;

            Sym32_dhdr dhdr;

            ptr.Set(reinterpret_cast<TUint8*>(&dhdr), sizeof(Sym32_dhdr));

            TInt32 index = iStrInfoTbl->GetIndex(KThread);

            dhdr.d_name	= (index == KErrNotFound) ? ESYM_STR_UNDEF : index;

            dhdr.d_descrsz	= sizeof(Sym32_thrdinfod);

            dhdr.d_type	= ESYM_NOTE_THRD;

            dhdr.d_version = iStrInfoTbl->GetIndex(KSymbianElfCoreDumpVersion);

            dhdr.d_elemnum = KCrashThreadsCount;

            reference.Append(ptr);

			RThreadPointerList *threadList = new(ELeave) RThreadPointerList;

			formatter->iDataSource->GetThreadListL(KCrashPid, *threadList);

            Sym32_thrdinfod seg;

            ptr.Set(reinterpret_cast<TUint8*>(&seg), sizeof(Sym32_thrdinfod));

            for(TInt i = 0; i < KCrashThreadsCount; ++i)

				{

				seg.td_id = KCrashTid + i;

				seg.td_owning_process = KCrashPid;

				seg.td_priority = KCrashThreadPriority + i;

				seg.td_svc_sp = KCrashSvcStackPtr + i;

				seg.td_svc_stack = KCrashSvcStackAddr + i;

				seg.td_svc_stacksz = KCrashSvcStackSize + i;

				seg.td_usr_stack = KCrashUsrStackAddr + i;

				seg.td_usr_stacksz = KCrashUsrStackSize + i;

				TBuf8<KMaxProcessName> buf;

				buf.Copy(KCrashThreadName);

				if (buf.Length() > 0)

				{

					iStrInfoTbl->AddStringL(buf);

				}

				index = iStrInfoTbl->GetIndex(buf);

				seg.td_name = (index == KErrNotFound) ? ESYM_STR_UNDEF : index;

				reference.Append(ptr);

				}

            writer->OpenL(_L("") ); //clear writer buffer

			formatter->iOffset = 0;

            TInt offset = 0;

            formatter->WriteThreadInfoL(KCrashPid, *threadList);

			RDebug::Print(_L("itest1\n"));

            itest(offset + reference.Length() == formatter->iOffset);

			RDebug::Print(_L("itest2\n"));

            itest(offset != formatter->iOffset);

			//RDebug::Print(_L("itest3\n"));

            //itest(reference == writer->iData);

			RDebug::Print(_L("itest4\n"));

            itest(reference != _L8(""));

			threadList->ResetAndDestroy();

			threadList->Close();

			delete threadList;

            CleanupStack::PopAndDestroy(); //reference

            break;

        }

        case EWriteProcessInfo:

        {

			RDebug::Print(_L("EWriteProcessInfo starting...\n"));

            TRAP(err, formatter->ConfigureDataSourceL(server));

            itest(err == KErrNone);

            itest(server == formatter->iDataSource);

            TRAP(err, formatter->ConfigureDataSaveL(writer));

            itest(err == KErrNone);

            itest(writer == formatter->iDataSave);

            reference.CreateL( sizeof(Sym32_dhdr) + sizeof(Sym32_procinfod) );

            CleanupClosePushL(reference);

			RProcessPointerList *processList = new(ELeave)RProcessPointerList;

			formatter->iDataSource->GetProcessListL( *processList );

            TPtrC8 ptr;

            Sym32_dhdr dhdr;

            ptr.Set(reinterpret_cast<TUint8*>(&dhdr), sizeof(Sym32_dhdr));

            TInt32 index = iStrInfoTbl->GetIndex(KProcess);

            dhdr.d_name	= (index == KErrNotFound) ? ESYM_STR_UNDEF : index;

            dhdr.d_descrsz	= sizeof(Sym32_procinfod);

            dhdr.d_type	= ESYM_NOTE_PROC;

            dhdr.d_version = iStrInfoTbl->GetIndex(KSymbianElfCoreDumpVersion);

            dhdr.d_elemnum = 1;

            reference.Append(ptr);

            Sym32_procinfod seg;

            ptr.Set(reinterpret_cast<TUint8*>(&seg), sizeof(Sym32_procinfod));

            seg.pd_id = KCrashPid;

            TBuf8<KMaxProcessName> buf;

            buf.Copy(KCrashProcessName);

            if (buf.Length() > 0)

            {

                iStrInfoTbl->AddStringL(buf);

            }

            index = iStrInfoTbl->GetIndex(buf);

            seg.pd_name = (index == KErrNotFound) ? ESYM_STR_UNDEF : index;

            reference.Append(ptr);

            writer->OpenL(_L("") ); //clear writer buffer

			formatter->iOffset = 0;

            TInt offset = 0;

            formatter->WriteProcessInfoL(KCrashPid, *processList );

			RDebug::Print(_L("itest1\n"));

            itest(offset + reference.Length() == formatter->iOffset);

			RDebug::Print(_L("itest2\n"));

            itest(offset != formatter->iOffset);

			//RDebug::Print(_L("itest3\n"));

            //itest(reference == writer->iData);

			RDebug::Print(_L("itest4\n"));

            itest(reference != _L8(""));

			processList->ResetAndDestroy();

			processList->Close();

			delete processList;

            CleanupStack::PopAndDestroy(&reference); //reference

            break;

        }

        case EWriteExecutableInfo:

        {

			RDebug::Print(_L("EWriteExecutableInfo starting...\n"));

            TRAP(err, formatter->ConfigureDataSourceL(server));

            itest(err == KErrNone);

            itest(server == formatter->iDataSource);

            TRAP(err, formatter->ConfigureDataSaveL(writer));

            itest(err == KErrNone);

            itest(writer == formatter->iDataSave);

            reference.CreateL(sizeof(Sym32_dhdr) + KCodeSegsCount * sizeof(Sym32_execinfod) );

            CleanupClosePushL(reference);

            TPtrC8 ptr;

            Sym32_dhdr dhdr;

            ptr.Set(reinterpret_cast<TUint8*>(&dhdr), sizeof(Sym32_dhdr));

            TInt32 index = iStrInfoTbl->GetIndex(KExecutable);

            dhdr.d_name	= (index == KErrNotFound) ? ESYM_STR_UNDEF : index;

            dhdr.d_descrsz	= sizeof(Sym32_execinfod);

            dhdr.d_type	= ESYM_NOTE_EXEC;

            dhdr.d_version = iStrInfoTbl->GetIndex(KSymbianElfCoreDumpVersion);

            dhdr.d_elemnum = KCodeSegsCount;

            reference.Append(ptr);

            Sym32_execinfod seg;

            ptr.Set(reinterpret_cast<TUint8*>(&seg), sizeof(Sym32_execinfod));

            Sym32_execid id = {I64LOW(KCrashTime), KCrc32};