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

// Test harness for WAP Access Point Settings Parser.

// The test harness simply creates new messages from binary data files

// and calls the WAP Access Point Settings Parser to parse them.

// 

//

#include <e32uid.h>

#include <e32test.h>

#include <e32cons.h>

#include <s32file.h>

#include <e32base.h>

// Comms stuff

#include <msvids.h>

#include <msvuids.h>

#include <msvruids.h>

#include <msvstd.h>

#include <msventry.h>

#include <mtsr.h>

#include <txtfmlyr.h>

#include <txtrich.h>

#include <imcvtext.h>

// General parser stuff:

#include <bsp.h>

#include <regpsdll.h>	// Parser registration.

#include <biouids.h>	// Defines for use in Bio messaging

#include <bitsids.h>		// Uids for use in Test Harnesses

#include "biotestutils.h"

#include <biodb.h>		//  CBIODatabase.

#include "tmsvbioinfo.h"

// WAP stuff:

#include <etelpckt.h>

#include <etelmm.h>

#include <wapp.h>

#include <wappdef.h>

#include "wapperr.h"

#include "T_Wapp.h"

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

_LIT(KEBookmarkExtension,	".eBM");

_LIT(KEBookmarkItemBegin,	"BEGIN:eBOOKMARK");

_LIT(KEBookmarkItemEnd,		"END:eBOOKMARK");

const TInt KNumberOfBookmarkFields = 3;

//#define __HEAPFAILURE__    // set the compiler flag to include test code for heap failure

//

// CExampleScheduler: Implementation //

//

void CTestScheduler::Error(TInt aError) const

    {

    CActiveScheduler::Stop();

    test.Printf(_L("\nLeave signalled, reason=%d\n"),aError);

    }

// end CExampleScheduler::Error

//

//		CTestWapp: IMPLEMENTATION		//

//

//

//		Factory methods					//

//

CTestWapp::CTestWapp(RFs& aFs)

:CActive(KTestWappPriority),

iFs(aFs),

iWAPModemID(KWappModemInitValue)  // Initialise to KErrNotFound

    {

    }

// end CTestWapp::CTestWapp

CTestWapp::~CTestWapp()

    {

    Cancel();

	delete iCurrentSettingsName;

//	delete iBioDatabase;

	delete iMessageBody;

	delete iMsvSelection;

    if (iWappParser)

		{

		delete iWappParser;

		}

	delete iBioTestUtils;

   }

// end CTestWapp::~CTestWapp

CTestWapp* CTestWapp::NewL(RFs& aFs)

    {

    CTestWapp* self = new (ELeave) CTestWapp(aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();  // self

	return self;

	}

// end CTestWapp::NewL

void CTestWapp::ConstructL()

    {

	iBioTestUtils = CBioTestUtils::NewL(test, ETuGoClientSide);

	//Initialise our member variables

	iParsedFieldsNum = 0;   //No parsed fields so far 

	iTestSuccesses=0;

	iTestFailures = 0;

	iMessagesCreated=0;

	iTestCounter = 0;		// Current Test Number start at 0

	// Chose from one of following:- 

	//iTestMode = ETWappConcise;       

	//iTestMode =  ETWappDetailed; 

	iTestMode = ETWappVerbose;

    CActiveScheduler::Add(this);

	iBioTestUtils->WriteComment(_L("Created WAPP Test Harness"));

	test.Console()->ClearScreen(); // get rid of menu

    }

// end CTestWapp::ConstructL

//

// Active object stuff //

//

void CTestWapp::RunL()

    {

	DoRunL();

	}

TInt CTestWapp::RunError(TInt aError)

	{

	iBioTestUtils->TestHarnessFailed(aError);

	CActiveScheduler::Stop();

	return KErrNone;

	}

void CTestWapp::DoRunL()

	{	

	TInt result=iStatus.Int();

    if (result != KErrNone )

        {

        test.Console()->ClearScreen();

        test.Console()->SetPos(0,0);

        DisplayErrorReasonL(result);		// Stops active scheduler if the error is unknown.

		iState = EWappDisplay;

        }

	TPtrC tempPtr;

	HBufC* tempBuffer;

    switch (iState)

        {

        case EWappClearCommDB:

			// Create the Comms DB

			DeleteCommDbTableL();  // Trash all the CommDb entries

			iState = EWappCreateNewMessages;

			QueueOperationAsync(KErrNone);

			break;

		case EWappCreateNewMessages:

			iState = EWappCreateParser;

			tempPtr.Set(KWappTestTxtFileDir);

			tempBuffer= tempPtr.AllocL();

			CleanupStack::PushL(tempBuffer);

			OutputFormattedTextL(_L("Creating messages from files in directory %S"),tempBuffer);

			TRAPD(error, iMsvSelection = iBioTestUtils->GenerateMessagesL(KWappTestTxtFileDir, ETrue) );

			if (error !=KErrNone)

				{

				OutputFormattedTextL(_L("Error %d occurred when creating messages"),error);

				User::Leave(error);

				}

			iMessagesCreated= iMsvSelection->Count();

			if (iTestMode != ETWappConcise)

				OutputFormattedTextL(_L("Created %d WAPP messages "),iMessagesCreated );

			if (iMessagesCreated ==0)     // No WAPP messages 

				User::Leave(KErrNotFound);// Ensure we don't try to parse with no messages

			QueueOperationAsync(KErrNone);

			CleanupStack::Pop(); //tempBuffer;

			delete tempBuffer;

			tempBuffer = NULL;

			break;

		case EWappCreateParser:

			// Create parser and add ourselves to Active Scheduler

			iState = EWappProcessUnparsed;

			iBioTestUtils->TestStart(iTestCounter+1); // Origin at Zero

			CreateParserL();  // Sets iEntry to new ID, & creates parser 

			if (iTestMode ==ETWappVerbose)

				OutputFormattedTextL(_L("Running tests on message %d with Entry Id %d"), iTestCounter+1, iEntryId);

			QueueOperationAsync(KErrNone);

			break;		

		case EWappProcessUnparsed:

			//Try processing the unparsed message - should fail - catch the error

			iState =EWappParse;

			if (iTestMode !=ETWappConcise)

				OutputFormattedTextL(_L("Process unparsed message"));

			ProcessUnparsedMessageL();  // Note that this should fail

            SetActive();

			break;

		case EWappParse:

			//Extract the body of the unparsed message and pass it to WAPP for parsing

			iState =EWappParseAgain;

			ExtractBodyPartsL();// extracts body text from current message.

			if (iTestMode != ETWappConcise)

				OutputFormattedTextL(_L("Parse"));

			ParseMessageL();

            SetActive();            

            break;		

		case EWappParseAgain:

			// Parse the parsed message again. Shouldn't generate an error. 

			// Should skip the full parsing op

			iState = EWappProcess;

			if (iTestMode != ETWappConcise)

				OutputFormattedTextL(_L("Re-parse"));

			ParseMessageL();

			SetActive();

			break;

		case EWappProcess:

			//Process the parsed fields in the stream store attachment to the message

			iState = EWappProcessAgain;

			if (iTestMode !=ETWappConcise)

				OutputFormattedTextL(_L("Process"));

			ProcessMessageL();

            SetActive();

			break;

		case EWappProcessAgain:

			//Process the parsed fields again - shouldn't create any errors

			iState = EWappDisplay;

			if (iTestMode != ETWappConcise)

				OutputFormattedTextL(_L("Re-Process"));

			ProcessMessageL();

			SetActive();

			break;

		case EWappDisplay:

			//Display the details of the parsed fields and CommDb as required.

			UnloadParser();

			if (iTestMode != ETWappConcise)

				RecordEntryDataL();

			iBioTestUtils->TestFinish(iTestCounter+1); // origin at zero.

			iTestCounter++;						// NB last time here, also shifts our zero for Test Summary!

			if (iTestCounter <iMessagesCreated) // Still files to process into messages

				iState = EWappCreateParser;		// so loop through the operations again.

			else

				iState = EWappComplete;	 

			if (result ==KErrNone)

				iTestSuccesses++;

			else

				iTestFailures++;

			RequestComplete(iStatus,KErrNone);

            SetActive();

			break;

		case EWappComplete:

			//Complete the tests

			test.Console()->ClearScreen();

			test.Console()->SetPos(0,0);

			//DisplayTestSummaryL(); Bit confusing at the moment

			if (result ==KErrNone)

				iBioTestUtils->TestHarnessCompleted();

			else

				iBioTestUtils->TestHarnessFailed(result);

			if (iWappParser)

				iWappParser->Cancel();

			CActiveScheduler::Stop();

			break;	

        default:

            break;

        }

    }

// end CTestWapp::RunL

void CTestWapp::DoCancel()

    {

    }

// end CTestWapp::DoCancel

void CTestWapp::QueueOperationAsync(TInt aErr)

    {

	// Set our status flag, prior to placing ourselves on the Active Scheduler.

    TRequestStatus*  pS = &iStatus;

	iStatus = KRequestPending;

    User::RequestComplete(pS, aErr);

	SetActive();

    }

// End of CTestWapp::QueueOperationAsync

void CTestWapp::RequestComplete(TRequestStatus& aStatus,TInt aCompletion)

	{

	TRequestStatus* statusPtr=&aStatus;

	User::RequestComplete(statusPtr,aCompletion);

	}

// end CTestWapp::RequestComplete

//

// Class functions		//	Not a good name, but ne'er mind.

//

//

//		StartL	-  The function controlling state engine 

//

void CTestWapp::StartL()

    {

//	TRAPD(err, iBioTestUtils->RunAuto() ? RunAutoTest() : ShowMenuL()); 

//	if (err)

//		iBioTestUtils->TestHarnessFailed(err);

//	else

		{

		Cancel();			// Halt any AO stuff

		iState=EWappClearCommDB; // set initial state

		InitialiseTesterL();  // Initialise variables and get AO going.

		}

	}

// end CTestWapp::StartL

void CTestWapp::RunAutoTest()

	{

	test.Next(_L("CTestWapp::Start()\n"));

	iTestMode = ETWappConcise;;

	}

void CTestWapp::ShowMenuL()

	{

	iBioTestUtils->ResetMenu();

	iBioTestUtils->AppendToMenuL(_L("Verbose Test  -   Logs parsed fields and CommDb tables"));

	iBioTestUtils->AppendToMenuL(_L("Detailed Test  -   Logs parsed fields only"));

	iBioTestUtils->AppendToMenuL(_L("Succinct Test -   Logs pass and fails"));

	TInt result = iBioTestUtils->DisplayMenu(_L("Schedule Sending Test"));

	switch (result)

		{

		case 1:

			iTestMode = ETWappVerbose;

			break;

		case 2:

			iTestMode = ETWappDetailed;

			break;

		case 3:

		default:

			iTestMode = ETWappConcise;

			break;

		}

	}

void CTestWapp::InitialiseTesterL()

	{

	// Get the NB if we don't need this two step process, use SetSmsServiceL().

	//iBioTestUtils->SetSmsServiceIdL();

	TRAPD(error, iBioTestUtils->SetBIOServiceIdL());

	if (error == KErrNotFound)

		{

		iBioTestUtils->CreateServicesL();

		}

	else

		{

		User::LeaveIfError(error);

		}

	// Empty the Inbox

	iBioTestUtils->EmptyInboxMessagesL();

	if (iTestMode == ETWappVerbose)

		iBioTestUtils->WriteComment(_L("Removed all messages from Global Inbox\n"));

	QueueOperationAsync(KErrNone);

	}

void CTestWapp::DeleteCommDbTableL()

	{

	// This is a very destructive function - it nukes all the CommDB tables in which 

	// WAPP makes entries.  Ensures that we are starting with an empty database.

	// WAPPs ability to overwrite existing entries is tested by having files with the same NAME

	// Characteristic. 

	TInt ret=KErrNone;

	TInt WAPEntries;

	TInt WAPIpEntries;

	TInt WAPSmsEntries;

	TInt ISPOutEntries;

	TInt IAPOutEntries;

	TInt GPRSEntries;

	CMDBSession* iDBSession = CMDBSession::NewL(CMDBSession::LatestVersion());

	TInt err = 0;

	CMDBRecordSet<CCDWAPAccessPointRecord> wapRecordSet(KCDTIdWAPAccessPointRecord);	//Open WAP AccessPoint table

	TRAP(err,wapRecordSet.LoadL(*iDBSession));

	if(err == KErrNone)

		{

		WAPEntries = wapRecordSet.iRecords.Count();

		if(WAPEntries > 0) 

			{

			TRAPD(err, wapRecordSet.DeleteL(*iDBSession));	

			}			

		WAPEntries = wapRecordSet.iRecords.Count();	

		}

	CMDBRecordSet<CCDWAPIPBearerRecord> wapIpBearerRecordSet(KCDTIdWAPIPBearerRecord);	//Open WAP IP Bearer table

	TRAP(err,wapIpBearerRecordSet.LoadL(*iDBSession));

	if(err == KErrNone)

		{

		WAPIpEntries = wapIpBearerRecordSet.iRecords.Count();

		if(WAPIpEntries > 0) 

			{

			TRAPD(err, wapIpBearerRecordSet.DeleteL(*iDBSession));	

			}

		WAPIpEntries = wapIpBearerRecordSet.iRecords.Count();

		}

	CMDBRecordSet<CCDWAPSMSBearerRecord> wapSmsBearerRecordSet(KCDTIdWAPSMSBearerRecord);	//Open WAP SMS Bearer table

	TRAP(err,wapSmsBearerRecordSet.LoadL(*iDBSession));

	if(err == KErrNone)

		{

		WAPSmsEntries = wapSmsBearerRecordSet.iRecords.Count();

		if(WAPSmsEntries > 0) 

			{

			TRAPD(err, wapSmsBearerRecordSet.DeleteL(*iDBSession));	

			}			

		WAPSmsEntries = wapSmsBearerRecordSet.iRecords.Count();

		}

	CMDBRecordSet<CCDIAPRecord> iapRecordSet(KCDTIdIAPRecord);	//Open Dial Out IAP table

	TRAP(err,iapRecordSet.LoadL(*iDBSession));

	if(err == KErrNone)

		{

		IAPOutEntries = iapRecordSet.iRecords.Count();

		if(IAPOutEntries > 0) 

			{

			TRAPD(err, iapRecordSet.DeleteL(*iDBSession));	

			}

		IAPOutEntries = iapRecordSet.iRecords.Count();

		}

	CMDBRecordSet<CCDDialOutISPRecord> dialOutIspRecordSet(KCDTIdDialOutISPRecord);	//Open Dial Out ISP table

	TRAP(err,dialOutIspRecordSet.LoadL(*iDBSession));

	if(err == KErrNone)

		{

		ISPOutEntries = dialOutIspRecordSet.iRecords.Count();

		if(ISPOutEntries > 0) 

			{

			TRAPD(err, dialOutIspRecordSet.DeleteL(*iDBSession));	

			}

		ISPOutEntries = dialOutIspRecordSet.iRecords.Count();

		}

	//CMDBRecordSet<CCDWCDMAPacketServiceRecord> gprsRecordSet;	//Open Gprs table

	CMDBRecordSet<CCDOutgoingGprsRecord> gprsRecordSet(KCDTIdOutgoingGprsRecord);

	TRAP(err,gprsRecordSet.LoadL(*iDBSession));

	if(err == KErrNone)

		{

		GPRSEntries = gprsRecordSet.iRecords.Count();

		if(GPRSEntries > 0) 

			{

			TRAPD(err, gprsRecordSet.DeleteL(*iDBSession));	

			}

		GPRSEntries = gprsRecordSet.iRecords.Count();

		}

	if (iTestMode == ETWappVerbose)

		{

		OutputFormattedTextL(_L("COMMDAT entries deleted:"));

		OutputTextListL(_L("WAP Table "), WAPEntries);

		OutputTextListL(_L("WAP IP Bearer"), WAPIpEntries);

		OutputTextListL(_L("WAP SMS Bearer "), WAPSmsEntries);

		OutputTextListL(_L("Dial Out IAP "), IAPOutEntries);

		OutputTextListL(_L("Dial Out ISP"), ISPOutEntries);

		OutputTextListL(_L("Outgoing GPRS"), GPRSEntries);

		}

	delete iDBSession;	

	iDBSession = NULL;

	}

void CTestWapp::CreateParserL()

	{

	// Point our iEntry to the relevant message entry and create the parser using this Id

	test.Printf(_L("\nCreating a WAPP parser...\n"));

	iEntryId = (*iMsvSelection)[iTestCounter];

	if (iWappParser)

		{

		delete iWappParser;

		iWappParser = NULL;

		}

#if defined (__HEAPFAILURE__)

	TInt error = KErrNone;

	TBool finished = EFalse;

	TInt failCount = 0;

	while(!finished)

		{

		__UHEAP_FAILNEXT(failCount++);

		// 

		TRAP(error,iWappParser = iBioTestUtils->CreateParserL(iEntryId) );

		if (error == KErrNone)

			{

			__UHEAP_RESET;

			finished = ETrue;

			__UHEAP_RESET;

			}