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

//

// System includes

#include <e32std.h>

#include <e32base.h>

#include <e32test.h>

#include <s32mem.h>

// User includes

#include <versit.h>

#include <vcal.h>

#include <vcard.h>

#include "Observ.H"

#include "base64extension.h"

#include <coreappstest/testserver.h>

// Globals

RTest TheTest(_L("Versit Escaping Test"));

_LIT(KSimpleFileName,"C:\\SimpleO.VCF");

_LIT(KOutEscFileName,"C:\\Output-Escaped.vcf");

_LIT(KOutputFileName,"C:\\Output-QP.vcf");

_LIT(KVCardFileShiftJIS,"c:\\charsetSJIS.vcf");

_LIT(KVCardFileJIS,"c:\\charsetJIS.vcf ");

_LIT(KBase64FileName,"C:\\Output-Base64.vcf");

_LIT(KOutputQPFileName,"C:\\Export-QP-Vcard.vcf");

_LIT(KQPFileName,"C:\\QP-Vcard.vcf");

_LIT(KOutputQPHashFileName,"C:\\Export-QP-Hash.vcf");

_LIT(KQPHashFileName, "C:\\QP-Hash.vcf");

_LIT(KHugeVCardFileName,"z:\\testvcards\\various\\HugeVCard.vcf");

_LIT(KExportHugeVCardFileName,"C:\\OutputHugeVCard.vcf");

class CTests;

// Typedefs

typedef void (*TVersitStreamFunction)(CVersitParser& aParser);

typedef void (*TOOMCallback)(CTests& aSelf);

//#define TBUGFIX_INCLUDE_OOM //Comment this OOM test out as it's time spending so not good for overnight build tests

/**

@file 

@SYMTestCaseID PIM-TBUGFIX-Versit_Escaping_Test-0001

@SYMTestCaseDesc Importing and exporting of VCards and VCals of different formats.

@SYMTestStatus Implemented

@SYMTestPriority 3

@SYMTestActions Imports pre-existing VCard and VCal files, exports them and than compares their output with a pre-existing VCard or VCal file containing the expected output.

@SYMTestExpectedResults KErrNone, all outputed VCards and VCals are identical with expected output.

@SYMTestType CT

@SYMPREQ 234

*/

class TParserSetUp

	{

public:

	enum TSyncMLTest {eSyncMLTest};

public:

	inline TParserSetUp(TUint aType): iType(aType), iCharset(Versit::EUSAsciiCharSet), iEncoding(Versit::ENoEncoding),

		iAutoDetect(EFalse), iInternaliseFlags(0), iTimeFlags(0) {}

	inline TParserSetUp(TUint aType,Versit::TVersitCharSet aCharSet,Versit::TVersitEncoding aEncoding)

		: iType(aType), iCharset(aCharSet), iEncoding(aEncoding), iAutoDetect(EFalse), iInternaliseFlags(0), iTimeFlags(0) {}

	inline TParserSetUp(TUint aType,TBool aAutoDetect): iType(aType), iCharset(Versit::EUSAsciiCharSet), iEncoding(Versit::ENoEncoding),

		iAutoDetect(aAutoDetect), iInternaliseFlags(0), iTimeFlags(0) {}

	inline TParserSetUp(TSyncMLTest);

public:

	TUint iType;

	Versit::TVersitCharSet iCharset;

	Versit::TVersitEncoding iEncoding;

	TBool iAutoDetect;

	TUint iInternaliseFlags;

	TUint iTimeFlags;

	};

class CTests : public CBase

	{

public:

	enum TParserType

		{

		ETvCard,

		ETvCal,

		ETuseBaseParser=0x08,

		//Masks

		ETparserType=ETuseBaseParser-1,

		};

public:

	static CTests* NewL();

	static TBool CheckRun();

	~CTests();

	void ConstructL();

	void AllTestsL();

	static void TestL(CTests& aSelf);

	static void LeaveTestsL(CTests& aSelf);

	static void TestJapanL(CTests& aSelf);

	static void SyncMLTestsL(CTests& aSelf);

	static void Test0L(CTests& aSelf);

	static void Test1L(CTests& aSelf);

	static void Test2L(CTests& aSelf);

	static void Test3L(CTests& aSelf);

	static void Test4L(CTests& aSelf);

	static void Test5L(CTests& aSelf);

	static void Test6L(CTests& aSelf);

	static void Test7L(CTests& aSelf);

	static void Test8L(CTests& aSelf);

	static void Test9L(CTests& aSelf);

	static void Test10L(CTests& aSelf);

	static void Test11L(CTests& aSelf);

	static void Test12L(CTests& aSelf);

	static void TestHugeVCardL(CTests& aSelf);

	static void TestNullDateL(CTests& aSelf);

	static void TestAlarmRepeatCountL(CTests& aSelf);

	static void TestHashSignEncodingL(CTests& aSelf);

	static void TestBase64ExtensionL(CTests& aSelf);

private:

	void ReportErrorL(TInt aErr,const TDesC&aFileName);

	void CreateFileName(TParserType aType,TFileName& aName,TChar aPrefix,const TDesC& aFile,TInt aPath=1);

	void ExistingFileName(TParserType aType,TFileName& aName,TChar aPrefix,const TDesC& aFile,TInt aPath=1);

	void SetTimeFlags(CVersitParser& aParser,TUint aTimeFlags);

	void IntAndExtL(const TFileName& aInputFile,const TFileName& aOutputFile,const TParserSetUp& aSetUp);

	void TestFileL(TUint aType,const TDesC& aTestName,const TDesC& aFile,Versit::TVersitCharSet aCharset=Versit::EUSAsciiCharSet

																				,Versit::TVersitEncoding aEncoding=Versit::ENoEncoding, TBool aCompareFile = ETrue);

	void TestFileL(const TDesC& aTestName,const TDesC& aFile,const TParserSetUp& aSetUp,TBool aCompareFile = ETrue);

	CVersitParser* CreateParserLC(TParserType aType,const TDesC& aTestName);

	void DoLeaveTestL(TParserType aType,TInt aLeaveCode,const TDesC& aTestName,const TDesC& aFile);

	void DoOomTestL(TParserType aType,TInt aFailAfter,const TDesC& aTestName,const TDesC& aFile);

	void DoJapanTestL(const TDesC& aTestName,TInt aTest,TParserType aType=ETvCard);

	void DoSyncMLTestL(TTimeIntervalSeconds aUTCOffset,const TDesC& aTestName,const TDesC& aFile);

	void ExternaliseFileL(CVersitParser& aParser,const TDesC& aFileName);

	void CreateAndExternaliseVCardL(const TDesC8& aVCardText,const TDesC& aFileName,Versit::TVersitEncoding aEncoding=Versit::ENoEncoding);

	void InternaliseFileL(CVersitParser& aParser,const TDesC& aFileName,TBool aUseBaseParser=EFalse);

	void InternalizeFileL(CVersitParser& aParser,RFile& aInputFile);

	void CompareFilesL(const TDesC& aOutputFile,const TDesC& aCompareFile,const TDesC& aInputFile=KNullDesC);

	void LineWrappingTestL(const TDesC& aFullFileName);

private:

	enum {eSecondsPerHour=3600};

private:

	RFs iFsSession;

	TBool iSessionConnected;

	CFileMan* iFm;

	CTestRegister* iTempFiles;

	CTestVersitExtension* iBase64Extension;

	};

void doOOMTest(CTests& aTest, TOOMCallback aCallback, TInt aFailStart);

GLREF_C void ResetAndDestroyArrayOfParams(TAny* aObject)

	{

	CArrayPtr<CParserParam>* array=REINTERPRET_CAST(CArrayPtr<CParserParam>*,aObject);

	if (array)

		array->ResetAndDestroy();

	delete array;

	}

GLREF_C void ResetAndDestroyArrayOfProperties(TAny* aObject)

	{

	CArrayPtr<CParserProperty>* array=REINTERPRET_CAST(CArrayPtr<CParserProperty>*,aObject);

	if (array)

		array->ResetAndDestroy();

	delete array;

	}

inline TParserSetUp::TParserSetUp(TSyncMLTest): iType(CTests::ETvCal), iCharset(Versit::EUSAsciiCharSet), iEncoding(Versit::ENoEncoding),

	iAutoDetect(EFalse), iInternaliseFlags(CVersitParser::EImportSyncML), iTimeFlags(TVersitDateTime::EExportLeaveAsLocalTime) {}

CTests* CTests::NewL()

	{

	CTests* self=new(ELeave) CTests;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

TBool CTests::CheckRun()

	{

	TInt key=TheTest.Getch();

	if (key==EKeySpace)

		return ETrue;

	_LIT(KNot,"Not running this test\r\n");

	TheTest.Printf(KNot);

	return EFalse;

	}

void CTests::ConstructL()

	{

	User::LeaveIfError(iFsSession.Connect());

	iSessionConnected=ETrue;

	iFm = CFileMan::NewL(iFsSession);

	iTempFiles = CTestRegister::NewLC();

	CleanupStack::Pop(iTempFiles);

	iFsSession.MkDir(_L("C:\\TestvCards\\"));

	iFsSession.MkDir(_L("C:\\TestFiles\\"));

	iFsSession.MkDir(_L("C:\\K3Data\\"));

	}

CTests::~CTests()

	{

	delete(iTempFiles);

	if(iFm)

		{

		iFm->RmDir(_L("C:\\TestvCards\\"));

		iFm->RmDir(_L("C:\\TestFiles\\"));

		iFm->RmDir(_L("C:\\K3Data\\"));

		delete iFm;

		}

	if (iSessionConnected)

		{

		iFsSession.Close();

		}

	delete iBase64Extension;

	}

void CTests::ReportErrorL(TInt aErr,const TDesC& aFileName)

	{

	if (aErr==KErrNotFound)

		{

		_LIT(KMissingFile,"\r\n** FILE NOT FOUND: %S\r\n\r\n");

		TheTest.Printf(KMissingFile,&aFileName);

		}

	else if (aErr==KErrPathNotFound)

		{	//You will get this error if you have not exported the test data files.

		_LIT(KMissingPath,"\r\n** PATH NOT FOUND: %S\r\n\r\n");

		TheTest.Printf(KMissingPath,&aFileName);

		}

	else

		{

		_LIT(KError,"Error %d opening file %S\r\n");

		TheTest.Printf(KError,aErr,&aFileName);

		}

	__DEBUGGER();

	User::Leave(aErr);

	}

void CTests::ExternaliseFileL(CVersitParser& aParser,const TDesC& aFileName)

	{

	RFile file;

	User::LeaveIfError(file.Replace(iFsSession, aFileName, EFileWrite));

	CleanupClosePushL(file);

	aParser.ExternalizeL(file);

	CleanupStack::PopAndDestroy(&file);

	}

void CTests::CreateAndExternaliseVCardL(const TDesC8& aVCardText,const TDesC& aFileName,Versit::TVersitEncoding aEncoding/*=ENoEncoding*/)

	{

	CParserVCard* vCardParser=CParserVCard::NewL();

	CleanupStack::PushL(vCardParser);

	RDesReadStream stream(aVCardText);

	vCardParser->InternalizeL(stream);

	vCardParser->SetDefaultEncoding(aEncoding);

	ExternaliseFileL(*vCardParser,aFileName);

	CleanupStack::PopAndDestroy(vCardParser);

	}

void CTests::InternaliseFileL(CVersitParser& aParser,const TDesC& aFileName,TBool aUseBaseParser/*=EFalse*/)

	{

	RFile file;

	TInt err=file.Open(iFsSession, aFileName, EFileRead);

	if (err!=KErrNone)

		ReportErrorL(err,aFileName);

	CleanupClosePushL(file);

	TInt start = 0;

	if (iBase64Extension)

		{

		aParser.SetPlugIn(iBase64Extension);

		}

	if (aUseBaseParser)

		InternalizeFileL(aParser,file);

	else

		aParser.InternalizeL(file, start);

	CleanupStack::PopAndDestroy(&file);

	}

void CTests::InternalizeFileL(CVersitParser& aParser,RFile& aInputFile)

	{

	TInt size;

	if (aInputFile.Size(size)==KErrNone)

		{

		RFileReadStream stream(aInputFile);

		TRAPD(err,aParser.CVersitParser::InternalizeL(stream));

		STATIC_CAST(RFileBuf*,stream.Source())->Reset();

		stream.Close();

		User::LeaveIfError(err);

		}

	}

LOCAL_C TBool CompareLines(const TDesC8& aLine1, const TDesC8& aLine2)

	{

	_LIT8(KDayl,"DAYL");

	_LIT8(KTzPlus,"TZ:+");

	_LIT8(KTzMinus,"TZ:-");

	TBool ret=!aLine1.Compare(aLine2);

	if (!ret)

		{

		TBufC8<4> first4char(aLine1.Left(4));

		if(!first4char.Compare(KDayl())||!first4char.Compare(KTzPlus())||!first4char.Compare(KTzMinus()))

			{

			return ETrue;

			}

		}

	return ret;

	}

void CTests::CompareFilesL(const TDesC& aOutputFile,const TDesC& aCompareFile,const TDesC& aInputFile)

	{

	RFile file1,file2;

	TInt err=file1.Open(iFsSession, aOutputFile, EFileRead);

	if (err!=KErrNone)

		ReportErrorL(err,aOutputFile);

	CleanupClosePushL(file1);

	err=file2.Open(iFsSession, aCompareFile, EFileRead);

	if (err==KErrNotFound)//in this case, the input file and output file should be identical

		{

		err=file2.Open(iFsSession, aInputFile, EFileRead);

		if (err!=KErrNone)

			ReportErrorL(err,aInputFile);

		}

	if (err!=KErrNone)

		ReportErrorL(err,aCompareFile);

	CleanupClosePushL(file2);

	RFileReadStream stream1(file1);

	RFileReadStream stream2(file2);

	CleanupClosePushL(stream1);

	CleanupClosePushL(stream2);

	TBuf8<0x80> bufO,bufC;

	//__ASSERT(err==KErrNone);

	TInt line=1;

	do {

		TRAP(err,stream1.ReadL(bufO,TChar(0xa)));

		if (err==KErrNone || err==KErrEof)

			TRAP(err,stream2.ReadL(bufC,TChar(0xa)));

		if (err!=KErrNone && err!=KErrEof)

			User::Leave(err);

		TheTest(CompareLines(bufO, bufC));

		++line;

		} while (err!=KErrEof);

	CleanupStack::PopAndDestroy(4,&file1);

	}

void CTests::CreateFileName(TParserType aType,TFileName& aName,TChar aPrefix,const TDesC& aFile,TInt aPath/*=1*/)

	{

	_LIT(KPrefix1,"C:\\TestFiles\\");

	_LIT(KPrefix2,"C:\\K3Data\\");

	_LIT(KvCard,".VCF");

	_LIT(KvCal,".VCS");

	if (aPath==1)

		aName=KPrefix1;

	else

		aName=KPrefix2;

	if (aPrefix!=' ')

		aName.Append(aPrefix);

	aName.Append(aFile);

	if (aType==ETvCal)

		aName.Append(KvCal);

	else

		aName.Append(KvCard);

	}

void CTests::ExistingFileName(TParserType aType,TFileName& aName,TChar aPrefix,const TDesC& aFile,TInt aPath/*=1*/)

	{

	_LIT(KePrefix1,"Z:\\TestFiles\\");

	_LIT(KePrefix2,"Z:\\K3Data\\");

	_LIT(KvCard,".VCF");

	_LIT(KvCal,".VCS");

	if (aPath==1)

		aName=KePrefix1;

	else

		aName=KePrefix2;

	if (aPrefix!=' ')

		aName.Append(aPrefix);

	aName.Append(aFile);

	if (aType==ETvCal)

		aName.Append(KvCal);

	else

		aName.Append(KvCard);

	}

void CTests::SetTimeFlags(CVersitParser& aParser,TUint aTimeFlags)

	{

	CArrayPtr<CParserProperty>* propertiesArray=aParser.ArrayOfProperties(EFalse);

	TInt count;

	TInt ii;

	if (propertiesArray)

		{

		CParserTimePropertyValue* timeValue;

		CParserPropertyValue* value;

		count=propertiesArray->Count();

		TVersitDateTime::TVersitDateTimeFlags timeFlags=REINTERPRET_CAST(TVersitDateTime::TVersitDateTimeFlags&,aTimeFlags);

		TUid uid;

		uid.iUid = KVersitTimePropertyUid;

		for (ii=0; ii<count; ii++)

			{

			value=(*propertiesArray)[ii]->Value();

			if (value && value->SupportsInterface(uid))

				{

				timeValue=STATIC_CAST(CParserTimePropertyValue*,value);

				switch (timeValue->Uid().iUid)

					{

				case KVCalPropertyAlarmUid:

					{

					CVersitAlarm* alarm=STATIC_CAST(CParserPropertyValueAlarm*,timeValue)->Value();

					if (alarm && alarm->iRunTime)

						{

						alarm->iRunTime->ClearFlag(TVersitDateTime::EExportTimeZoneDesignator);

						alarm->iRunTime->SetFlag(timeFlags);

						}

					}

					break;

				case KVersitPropertyDaylightUid:

					{

					CVersitDaylight* daylight=STATIC_CAST(CParserPropertyValueDaylight*,timeValue)->Value();

					if (daylight)

						{

						if (daylight->iStartTime)

							{

							daylight->iStartTime->ClearFlag(TVersitDateTime::EExportTimeZoneDesignator);

							daylight->iStartTime->SetFlag(timeFlags);

							}

						if (daylight->iEndTime)

							{

							daylight->iEndTime->ClearFlag(TVersitDateTime::EExportTimeZoneDesignator);

							daylight->iEndTime->SetFlag(timeFlags);

							}

						}

					}

					break;

				case KVersitPropertyDateTimeUid:

					{

					TVersitDateTime* dateTime=STATIC_CAST(CParserPropertyValueDateTime*,timeValue)->Value();

					if (dateTime)

						{

						dateTime->ClearFlag(TVersitDateTime::EExportTimeZoneDesignator);

						dateTime->SetFlag(timeFlags);

						}

					}

					break;

				case KVersitPropertyDateUid:

					{

					TVersitDateTime* dateTime=STATIC_CAST(CParserPropertyValueDate*,timeValue)->Value();

					if (dateTime)

						{

						dateTime->ClearFlag(TVersitDateTime::EExportTimeZoneDesignator);

						dateTime->SetFlag(timeFlags);

						}

					}

					break;

				case KVersitPropertyMultiDateTimeUid:

					{

					CArrayPtr<TVersitDateTime>* values=STATIC_CAST(CParserPropertyValueMultiDateTime*,timeValue)->Value();

					if (values)

						{

						TInt count=values->Count();

						for (TInt ii=0;ii<count; ii++)

							{

							(*values)[ii]->ClearFlag(TVersitDateTime::EExportTimeZoneDesignator);

							(*values)[ii]->SetFlag(timeFlags);

							}

						}

					}

					break;

				case KVCalPropertyRecurrenceUid:

					{

					CVersitRecurrence* recurrence=STATIC_CAST(CParserPropertyValueRecurrence*,timeValue)->Value();

					if (recurrence && recurrence->iEndDate)

						{

						recurrence->iEndDate->ClearFlag(TVersitDateTime::EExportTimeZoneDesignator);

						recurrence->iEndDate->SetFlag(timeFlags);

						}

					}

					break;

					}

				}

			}

		}

	CArrayPtr<CVersitParser>* entityArray=aParser.ArrayOfEntities(EFalse);

	if (entityArray)

		{

		count=entityArray->Count();

		for (ii=0; ii<count; ii++)

			SetTimeFlags(*(*entityArray)[ii],aTimeFlags);

		}

	}

void CTests::IntAndExtL(const TFileName& aInputFile,const TFileName& aOutputFile,const TParserSetUp& aSetUp)

	{

	CVersitParser* vParser;

	if ((aSetUp.iType&ETparserType)==ETvCal)

		{

		vParser=CParserVCal::NewL();

		if (aSetUp.iInternaliseFlags)

			vParser->SetFlags(aSetUp.iInternaliseFlags);

		}

	else

		vParser=CParserVCard::NewL();

	vParser->SetAutoDetect(aSetUp.iAutoDetect);

	CleanupStack::PushL(vParser);

	InternaliseFileL(*vParser,aInputFile,aSetUp.iType&ETuseBaseParser);

	vParser->SetDefaultCharSet(aSetUp.iCharset);

	vParser->SetDefaultEncoding(aSetUp.iEncoding);

	if (aSetUp.iTimeFlags)

		SetTimeFlags(*vParser,aSetUp.iTimeFlags);

	ExternaliseFileL(*vParser,aOutputFile);

	CleanupStack::PopAndDestroy(vParser);