// Copyright (c) 1997-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:
// CHtmlToCrtConverter test code
// (1)convert path
// (2)convert single file synchronously/asynchronously
// (3)synchronous/asynchronous oom test
// the resulting richtext is written to the clipboard
// 
//

#include <e32std.h>
#include <e32test.h>
#include <f32file.h>
#include <e32math.h>

#include <confndr.h>
#include <conlist.h>
#include <concnf.h>
#include "CHtmlToCrtConverter.h"
#include "CHtmlToCrtConvActive.h"


_LIT(KTestName,"CHtmlToCrtConverter");
_LIT(KTest1,"@SYMTestCaseID PIM-CONVERTERTEST-0001 CHtmlToCrtConverter test");

LOCAL_D RTest test(KTestName);

//================================================================================
//asynchronousL
//tests asynchronous conversion
//================================================================================
void asynchronousL(TDesC& aSourceFile, TDesC& aTargetFile)
	{
	CConversionObserver* observer=CConversionObserver::NewLC();
	CTestScheduler* scheduler = new(ELeave) CTestScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);
	CActiveConv* active = CActiveConv::NewL(aSourceFile, aTargetFile, observer);
	CleanupStack::PushL(active);
	active->StartConversionL();
	TInt error = scheduler->GetError();
	User::LeaveIfError(error);

	CleanupStack::PopAndDestroy(active);
	CleanupStack::PopAndDestroy(scheduler);
	CleanupStack::PopAndDestroy(observer);

	_LIT(KString,"%S");
	test.Printf(KString,&(aSourceFile));
	test.Printf(_L(" - asynchronous conversion\n"));
	}
//================================================================================
//oomAsynchronousL
//================================================================================
void oomAsynchronousL(TDesC& aSourceFile, TDesC& aTargetFile)
	{
	test.Printf(_L("starting OOM test\n"));

	//reserve space on cleanup stack
	for(TInt i=0; i<1000; i++)
		{
		CleanupStack::PushL(&i);
		}
	CleanupStack::Pop(1000);

	TInt ret=KErrNoMemory;
	TInt failAt=0;
	while (ret!=KErrNone)
		{
		failAt++;
		__UHEAP_SETFAIL(RHeap::EDeterministic,failAt);
		__UHEAP_MARK;
		TRAP(ret, asynchronousL(aSourceFile, aTargetFile));
		if (ret!=KErrNone)
			{
			__UHEAP_MARKEND;
			}
		__UHEAP_RESET;
		test(ret==KErrNoMemory||ret==KErrNone);
		test.Printf(_L("."));
		}

	test.Printf(_L("asynchronous OOM test complete\n"));
	}
//================================================================================
//synchronousL
//tests synchronous conversion
//================================================================================
void synchronousL(TDesC& aSourceFile, TDesC& aTargetFile)
	{	
	//get converter
	CCnaConverterList* convList=CCnaConverterList::NewLC();
	const TUid KUidCHtmlToCrtConverter = {0x1000a90e};
	CConverterBase* conv = convList->NewConverterL(KUidCHtmlToCrtConverter);
	CleanupStack::PushL(conv);
	if(conv)
		{
		//do conversion
		conv->ConvertL(aSourceFile, aTargetFile);
		}
	CleanupStack::PopAndDestroy(conv);
	convList->Release();
	CleanupStack::PopAndDestroy(convList);
	}
//================================================================================
//oomSynchronousL
//================================================================================
void oomSynchronousL(TDesC& aSourceFile, TDesC& aTargetFile)
	{
	test.Printf(_L("starting OOM test\n"));

	//reserve space on cleanup stack
	for(TInt i=0; i<1000; i++)
		{
		CleanupStack::PushL(&i);
		}
	CleanupStack::Pop(1000);

	TInt ret=KErrNoMemory;
	TInt failAt=0;
	while (ret!=KErrNone)
		{
		failAt++;
		__UHEAP_SETFAIL(RHeap::EDeterministic,failAt);
		__UHEAP_MARK;
		TRAP(ret, synchronousL(aSourceFile, aTargetFile));
		if (ret!=KErrNone)
			{
			__UHEAP_MARKEND;
			}
		__UHEAP_RESET;
		test(ret==KErrNoMemory||ret==KErrNone);
		test.Printf(_L("."));
		}

	test.Printf(_L("\nsynchronous OOM test complete\n"));
	}
//================================================================================
//getPathL
//================================================================================
TBool getPathL(TDes& aPath, RFs& aFs)
	{
	// Generate the folder spec to search in
	TFileName searchSpec;
	TChar driveLetter = 'C';
	searchSpec.Append(driveLetter);
	searchSpec.Append(aPath);

	CDir* entryList = NULL;
	TFindFile finder(aFs);
	TInt ret = finder.FindWildByPath(searchSpec, NULL, entryList);
	if(ret<KErrNone)
		{
		//try z drive
		driveLetter = 'Z';
		searchSpec.Zero();
		searchSpec.Append(driveLetter);
		searchSpec.Append(aPath);
		delete entryList;
		entryList = NULL;

		ret = finder.FindWildByPath(searchSpec, NULL, entryList);
		if	(ret < KErrNone)
			{
			//path not found
			delete entryList;
			test.Printf(_L("files not found\n"));
			return EFalse;
			}
		}

	delete entryList;
	//set path
	aPath.Copy(searchSpec);
	return ETrue;
	}
//================================================================================
//convertPathL
//================================================================================
void convertPathL(TDesC& aPath, TDesC& aPathName, RFs& aFs, TDesC& aTargetFile)
	{
	aFs.MkDirAll(aPathName);

	CDir* entryList = NULL;
	TInt error = aFs.GetDir(aPath,KEntryAttMatchMask,ESortByName,entryList);
	User::LeaveIfError(error);

	TInt numberOfFiles = entryList->Count();
	for (TInt i=0; i<numberOfFiles; i++)
		{
		//get the source file
		HBufC* temp=HBufC::NewLC(((*entryList)[i].iName).Length());
		TPtr sourceFileName(temp->Des());
		sourceFileName.Copy((*entryList)[i].iName);

		HBufC* temp2=HBufC::NewLC(((*entryList)[i].iName).Length()+aPathName.Length());
		TPtr sourceFile(temp2->Des());
		sourceFile = aPathName;
		sourceFile.Append(sourceFileName);
		//do the conversion
		synchronousL(sourceFile, aTargetFile);
		//output result
		_LIT(KString,"%S");
		test.Printf(KString,&(sourceFileName));
		test.Printf(_L("\n"));
		CleanupStack::PopAndDestroy(2);//temp, temp2
		}

	delete entryList;
	test.Printf(_L("\n%d files converted\n"),numberOfFiles);
	}
//================================================================================
//================================================================================
	
/**
@SYMTestCaseID PIM-CONVERTERTEST-0001
*/	
void doMainL()
	{
	test.Start(KTest1);

	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	TBufC<11> targetFile(_L("target file"));

//========================================================
//path
	TBuf<17> path(_L(":\\testHtml\\*.*"));
//single file
	TBuf<25> sourceFile;
	_LIT(KFileName, "test1.txt");
//========================================================
	if(getPathL(path, fs))
		{
		//CONVERT PATH
		TBuf<17> pathName(path);
		pathName.SetLength(pathName.Length()-3);

		convertPathL(path, pathName, fs, targetFile);

		//CONVERT SINGLE FILE

		sourceFile.Copy(pathName);
		sourceFile.Append(KFileName);

		synchronousL(sourceFile, targetFile);
//		asynchronousL(sourceFile, targetFile);

		//OOM TESTS
//		oomSynchronousL(sourceFile, targetFile);
//		oomAsynchronousL(sourceFile, targetFile);
		}
//========================================================

	CleanupStack::PopAndDestroy(); // fs
	
	REComSession::FinalClose(); //needed, otherwise you will get a memory leak
	
	test.End();
	test.Close();
	}

GLDEF_C TInt E32Main()
	{
	__UHEAP_MARK;

	CTrapCleanup* theCleanup=CTrapCleanup::New();
	TRAPD(ret,doMainL());
	test(ret==KErrNone);
	delete theCleanup;

	__UHEAP_MARKEND;
	return(KErrNone);
	}