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

// This file contains the Console Test Harness for testing the SMILTranslator .dll

// It carries this out by searching for all files of a certain type (as specified by 

// KWildName) that reside in a given set of directories (as specified by KInputPathList)

// It then passes each file through a Parser object, picks up the resultant Document

// object and passes this straight back to the composer object.  Output is a new XML

// file of the same name but different directory (same as initial directory but with 

// KTestFindStr replaced by KTestReplaceStr & KTestReplaceStr2) - these directories are  

// created automatically.  The application then reports any errors for each file before

// moving onto the next one.  These error reports are copied to the console screen (but 

// usually too fast to read); to the output window in developer studio; and to a flat

// file (named and located as specified in KErrorFileName)

// There are 3 types of test that may be run.  The Basic test merely

// translates all input files to output files.  The Performance test does the same thing

// multiple times (as specified by KPerformanceTestIterations), although the log file

// output will only relate to the last run.  Finally the Memory test utilises the Heap

// Allocation Failure tool to incrementally run and progressively fail at each and every

// attempt to allocate memory, it's finally run should complete successfully to prove

// that no memory leaks have occurred in spite of X hundreds of previously failed runs.

// Note that this finally test should be done with a much reduced number of files

// residing in the input directories.

// The application can test ASCII or Unicode input and output (4 combinations possible).

// To vary the input you must manually add ASCII or Unicode files to the input

// directories.

// The tests can be run automatically or interactively:

// For interactive tests, run with '-i as follows:

// SMILTRANSLATORTEST.EXE -i

// To run with out user interaction, please see the following examples:

// SMILTRANSLATORTEST.EXE -h                                                 # show command line help

// SMILTRANSLATORTEST.EXE                                                    # runs with default options

// SMILTRANSLATORTEST.EXE -file_type ascii -data_mode file -test_type basic  # same as above

// SMILTRANSLATORTEST.EXE -use_file_handles                                  # msgapi2 only

// SMILTRANSLATORTEST.EXE -use_full_paths                                    # msgapi2 only

// SMILTRANSLATORTEST.EXE -test_type performance -performance_iteratons 3    # performance test with 3 iterations

// 

//

/**

 @file

*/

//#define DEBUG_SMILTRANSLATORTEST_

#include <e32test.h>

#include <e32std.h>

#include <f32file.h>

#include <txtetext.h>

#include <gmxmlparser.h>

#include <gmxmlcomposer.h>

#include <bacline.h>

// Constants

_LIT(KErrorFileName,"c:\\msgtest\\SMIL_Test_Files\\ErrorLog.txt");

_LIT(KParseError,"    Parse File error = ");

_LIT(KComposeError,"    Compose File error = ");

_LIT(KOutputNewLine,"\r\n");

_LIT(KStartFile,"Starting test of file ");

_LIT(KTxtAsciiOrUnicode,"Unicode (F1), Ascii (F2) or Utf-8 (F3) output?");

_LIT(KTxtBufferOrFile,"\nTest file API (F1), test buffer API (F2)");

_LIT(KTxtChooseTest,"\nPress:\nF1 (or any other key) for Basic test\nF2 for Performance test\nF3 for Memory Allocation test");

_LIT(KSmilTranslatorTest,"Smil Translator");

_LIT(KInputPathList, "c:\\msgtest\\SMIL_Test_Files\\SMIL_Input\\Valid\\;c:\\msgtest\\SMIL_Test_Files\\MMS_Input\\Valid\\;c:\\msgtest\\SMIL_Test_Files\\SMIL_Input\\Invalid\\;c:\\msgtest\\SMIL_Test_Files\\MMS_Input\\Invalid\\;");

_LIT(KTestFindStr, "_Input\\");

_LIT(KTestReplaceStr, "_Output\\");

_LIT(KWildName, "*.txt");                         // read all file that match *.txt

_LIT(KOptionI, "-i");                             // unary: interactive mode

_LIT(KOptionH, "-h");

// note: traditional style args "--file-type" don't work with the CCommandLineArguments class

_LIT(KOptionFileType, "-file_type");               // binary: ascii, utf8, unicode

_LIT(KOptionDataMode, "-data_mode");               // binary: buffer, file

_LIT(KOptionTestType, "-test_type");               // binary: basic, performance, memory

_LIT(KOptionPerformanceIterations, "-performance_iterations"); // binary: <number of iterations>

_LIT(KOptionUseFileHandles, "-use_file_handles");   // unary: use file handles as input

_LIT(KOptionUseFullPaths, "-use_full_paths");       // unary: use full paths as input

_LIT(KTxtChooseFileInput, "Choose input file type: Using file path (F1), Using file handle (F2)?");

// Globals 

LOCAL_D CTrapCleanup* theCleanup;

LOCAL_D CActiveScheduler* scheduler;

LOCAL_D RTest test(KSmilTranslatorTest);

LOCAL_D	RFs fileSystem;

class CTestConfig;

LOCAL_D CTestConfig* testConfig;

//

// TestConfig

class CTestConfig : public CBase

	{

public:

	typedef enum {EBasic, EPerformance, EMemory} TTestType;

	typedef enum {EFileData, EBufferData} TXMLDataMode;

	static CTestConfig* NewLC();

	~CTestConfig() {}	

	TInt ProcessCommandLineL();

	void InteractiveMode();

	// accessors

	TBool NeedsHelp() const {return iNeedsHelp; }

	TBool IsInteractive() const {return iIsInteractive; }

	TXMLFileType FileType() const {return iFileType; } 

	TXMLDataMode DataMode() const {return iDataMode; }

	TTestType TestType() const {return iTestType; }

	TInt PerformanceTestIterations() const {return iPerformanceTestIterations; }

	// display

	void DisplayHelp();

	void UseageErr();

	void Dump();

	TBool UseFileHandles() const {return iUseFileHandles; }

private:

	void ConstructL();

	TBool UnaryArgPresent(CCommandLineArguments* aArgs,TInt aArgCount, const TDesC& aOption);

	TInt ExtractBinaryArg(CCommandLineArguments* aArgs,TInt aArgCount, const TDesC& aOption,TBuf<32>& aBuf);

	TBool FileTypeFromStr(const TBuf<32>& aFileType);

	TBool DataModeFromStr(const TBuf<32>& aDataMode);

	TBool TestTypeFromStr(const TBuf<32>& aTestType);

private:

	TBool iNeedsHelp;

	TBool iIsInteractive;

	TXMLFileType iFileType;

	TTestType iTestType;

	TXMLDataMode iDataMode;

	TInt iPerformanceTestIterations;

	TBool iUseFileHandles;

	};

void CTestConfig::ConstructL()

	{

	iNeedsHelp=EFalse;

	iIsInteractive=EFalse;

	iFileType=EAscii;

	iTestType=EBasic; 

	iDataMode=EFileData;

	iPerformanceTestIterations=100; 

	iUseFileHandles = EFalse;

	}

CTestConfig* CTestConfig::NewLC()

	{

	CTestConfig* self=new(ELeave)CTestConfig();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

TBool CTestConfig::FileTypeFromStr(const TBuf<32>& aFileType)

	{

	TBool found=ETrue;

	if(aFileType.Compare(_L("ascii"))==0)

		{

		iFileType=EAscii;

		}

	else if(aFileType.Compare(_L("utf8"))==0)

		{

		iFileType=EUtf8;

		}

	else if (aFileType.Compare(_L("unicode"))==0)

		{

		iFileType=EUnicode;

		}

	else

		{

		found=EFalse;

		}

	return found;

	}

TBool CTestConfig::DataModeFromStr(const TBuf<32>& aDataMode)

	{

	TBool found=ETrue;

	if(aDataMode.Compare(_L("buffer"))==0)

		{

		iDataMode=EBufferData;	

		}

	else if(aDataMode.Compare(_L("file"))==0)

		{

		iDataMode=EFileData;

		}

	else 

		{

		found=EFalse;

		}

	return found;

	}

TBool CTestConfig::TestTypeFromStr(const TBuf<32>& aTestType)

	{

	TBool found=ETrue;

	if (aTestType.Compare(_L("basic"))==0) 

		{

		iTestType=EBasic;

		}

	else if (aTestType.Compare(_L("performance"))==0)

		{

		iTestType=EPerformance;

		}

	else if (aTestType.Compare(_L("memory"))==0)

		{

		iTestType=EMemory;

		}

	else 

		{

		found=EFalse;

		}

	return found;

	}

void CTestConfig::DisplayHelp()

	{

	test.Printf(KOptionH);

	test.Printf(_L("\thelp\r\n"));

	test.Printf(KOptionI);

	test.Printf(_L("\tinteractive mode\r\n"));

	test.Printf(KOptionFileType);

    test.Printf(_L("\tascii|utf8|unicode\r\n"));

	test.Printf(KOptionDataMode);

	test.Printf(_L("\tbuffer-data|file-data\r\n"));

	test.Printf(KOptionTestType);

	test.Printf(_L("\tbasic|performance|memory\r\n"));

	test.Printf(KOptionPerformanceIterations);

	test.Printf(_L(" N\tthe number of iterations to perform\r\n"));

	test.Printf(KOptionUseFileHandles);

	test.Printf(_L("\tuse file handles for the test\r\n"));

	test.Printf(KOptionUseFullPaths);

	test.Printf(_L("\tuse file paths for the test\r\n"));

	}

void CTestConfig::UseageErr()

	{

		test.Printf(_L("\r\nUseage Err:\r\n"));

		DisplayHelp();

	}

void CTestConfig::Dump() 

	{	

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

	RDebug::Print(_L("SMILTRANSLATORTEST Config Settings:\r\n"));

	RDebug::Print(_L("===================================\r\n"));

	RDebug::Print(_L("iNeedsHelp                 = %d\r\n"),iNeedsHelp);

	RDebug::Print(_L("iIsInteractive             = %d\r\n"),iIsInteractive);

	RDebug::Print(_L("iFiletype                  = %d\r\n"),iFileType);

	RDebug::Print(_L("iTestType                  = %d\r\n"),iTestType);

	RDebug::Print(_L("iDataMode                  = %d\r\n"),iDataMode);  

	RDebug::Print(_L("iPerformanceTestIterations = %d\r\n"),iPerformanceTestIterations);

	RDebug::Print(_L("iUseFileHanldes            = %d\r\n"),iUseFileHandles);

	}

TBool CTestConfig::UnaryArgPresent(CCommandLineArguments *aArgs, TInt aArgCount, const TDesC& aOption)

	{

	TInt i = 1;

	while ((i<aArgCount)&&aArgs->Arg(i).Compare(aOption))

		{

		++i;

		}

	return i<aArgCount;

	}

TInt CTestConfig::ExtractBinaryArg(CCommandLineArguments *aArgs, TInt aArgCount, const TDesC& aOption,TBuf<32>& aBuf)

	{

		TInt err=KErrNotFound;

		TInt i=0; 

		while ((i<aArgCount)&&aArgs->Arg(i).Compare(aOption)) 

			{

			++i;

			}

		if (i<aArgCount) 

			{

			if (++i<aArgCount) 

				{

				err=KErrNone;

				aBuf=aArgs->Arg(i);

				}

			else

				{

				err=KErrArgument;

				}

			}

		return err;

	}

void CTestConfig::InteractiveMode()

	{

	TKeyCode choice;

	test.Printf(KTxtAsciiOrUnicode);

	choice=test.Getch();

	if(choice==EKeyHelp)

		{

		iFileType=EAscii;

		}

	else if(choice==EKeyDial)

		{

		iFileType=EUtf8;

		}

	else

		{

		iFileType=EUnicode;

		}

	test.Printf(KTxtBufferOrFile);

	choice=test.Getch();

	if(choice==EKeyHelp)

		{

		iDataMode=EBufferData;

		}

	else

		{

		iDataMode=EFileData;

		}

	// Get user's input on whether to use file paths or file handles for the input files

	test.Printf(KOutputNewLine());

	test.Printf(KTxtChooseFileInput());

	choice=test.Getch();

	iUseFileHandles=EFalse;

	if(choice==EKeyHelp)          // F2

		{

		iUseFileHandles = ETrue;

		}

	test.Printf(KTxtChooseTest);

	choice=test.Getch();

	if(choice==EKeyHelp)        // F2

		{

		iTestType=EPerformance;

		}

	else if (choice==EKeyDial)  // F3

		{

		iTestType=EMemory;

		}

	else                          // any key

		{

		iTestType=EBasic;  

		}

	}

TInt CTestConfig::ProcessCommandLineL()

	{

	// Handle command line arguments

	CCommandLineArguments* args=CCommandLineArguments::NewLC();

	TInt argCount=args->Count();

	// Search for: "-h"/help parameter

	if (UnaryArgPresent(args,argCount,KOptionH))

		{

			iNeedsHelp = ETrue;

			CleanupStack::Pop(args);

			delete args;

			return KErrNone;

		}

	// Search for: "-i"/interactive parameter

	if(UnaryArgPresent(args,argCount,KOptionI)) 

		{

		if (argCount==2)

			{

			iIsInteractive=ETrue;

			}

		else

			{

			UseageErr();

			}

		} 

	// Search for: "-usefilehandles" parameter

	if(UnaryArgPresent(args,argCount,KOptionUseFileHandles)) 

		{

		iUseFileHandles=ETrue;		

		}

	// Search for: "-usefullpaths" parameter

	if(UnaryArgPresent(args,argCount,KOptionUseFullPaths))

		{

		iUseFileHandles=EFalse;

		}

	// Search for: --file-type, --data-mode, --test-type

	TBuf<32> buf;

	TInt err;

	if (((err=ExtractBinaryArg(args,argCount,KOptionFileType,buf))==KErrNone)&&(!FileTypeFromStr(buf))||

		  err==KErrArgument)

		{

		UseageErr();

		CleanupStack::PopAndDestroy(args);

		return KErrArgument;

		}

	if (((err=ExtractBinaryArg(args,argCount,KOptionDataMode,buf))==KErrNone)&&(!DataModeFromStr(buf))||

		  err==KErrArgument)

		{

		UseageErr();			

		CleanupStack::PopAndDestroy(args);

		return KErrArgument;

		}

    if (((err=ExtractBinaryArg(args,argCount,KOptionTestType,buf))==KErrNone)&&(!TestTypeFromStr(buf))||

		 err==KErrArgument)

		{

		UseageErr();

		CleanupStack::PopAndDestroy(args);

		return KErrArgument;

		}

    if (((err=ExtractBinaryArg(args,argCount,KOptionPerformanceIterations,buf))==KErrNone))

		{

		TLex16 lexer(buf.Ptr());

		TInt iterations;

		lexer.Val(iterations);

		iPerformanceTestIterations = iterations;

		}

	else if (err==KErrArgument)

		{

		UseageErr();

		CleanupStack::PopAndDestroy(args);

		return KErrArgument;

		}

	CleanupStack::PopAndDestroy(args);

	return KErrNone;

	}

//

class CTestDataSupplier : public CBase, public MMDXMLParserDataProvider

	{

public:

	static CTestDataSupplier* NewL(RFs &aRFs, const TDesC& aFileName);

	~CTestDataSupplier();

	// From MMDXMLParserDataProvided

	void GetData(TPtrC8 &aPtr, TRequestStatus &aStatus);

	void Disconnect();

private:

	void ConstructL(RFs &aRFs, const TDesC& aFileName);

private:

	HBufC8* iCurrentChunk;

	RFile iFile;

	TInt iChunkSize;	// Start at 1, then increment for subsequent chunk

	};

CTestDataSupplier* CTestDataSupplier::NewL(RFs &aRFs, const TDesC& aFileName)

	{

	CTestDataSupplier* self = new (ELeave) CTestDataSupplier();

	CleanupStack::PushL(self);

	self->ConstructL(aRFs, aFileName);

	CleanupStack::Pop(self);

	return self;

	}

CTestDataSupplier::~CTestDataSupplier()

	{

	iFile.Close();

	delete iCurrentChunk;

	}

// From MMDXMLParserDataProvided

// TODO: Should GetData be a leaving function? Allows more flexibility to implementations of this funtion?

void CTestDataSupplier::GetData(TPtrC8 &aPtr, TRequestStatus &aStatus)

	{

	// Read the data into the descriptor

	delete iCurrentChunk;

	iCurrentChunk = NULL;

	iCurrentChunk = HBufC8::NewL(iChunkSize);

	TPtr8 chunk = iCurrentChunk->Des();

	iFile.Read(chunk, iChunkSize); // Ignore the error code, assume end of file if we haven't read any data.

	TDataProviderResults result;

	if (iCurrentChunk->Length() != 0)

		{

		aPtr.Set(*iCurrentChunk);

		result = KMoreData;

		}

	else

		{

		// Assume that if we haven't got any data then we're at the end of the stream.

		result = KDataStreamEnd;

		}

//	iChunkSize++;

	TRequestStatus *s = &aStatus;

	User::RequestComplete(s, (TInt)result);

	return;

	}

void CTestDataSupplier::Disconnect()

	{

	// Don't need to do anything here.

	}

void CTestDataSupplier::ConstructL(RFs &aRFs, const TDesC& aFileName)

	{

	iChunkSize = 1;

	// Open the file that will supply the data

	User::LeaveIfError(iFile.Open(aRFs, aFileName, EFileRead));

	}

//

// CSmilTranslatorTestUtils declaration

//

class CSmilTranslatorTestUtils : public CActive, public MMDXMLParserObserver, public MMDXMLComposerObserver

	{

public:

	static CSmilTranslatorTestUtils* NewLC();

	~CSmilTranslatorTestUtils();