// Copyright (c) 2002-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 "Observ.H"

#include <e32test.h>

#include <vobserv.h>

#include <versit.h>

#include <vcal.h>

#include <vcard.h>

//class CAgnRptDef;

GLREF_D RTest TheTest;

class CTestVersitObserver : public CBase, public MVersitObserver, public MVersitPlugIn

	{

public:

	inline CTestVersitObserver(RFs& aFsSession) : iFs(aFsSession) {}

	void Test1L();

	void Test2L();

	void Test3L();

	void TestReccurrenceRulesL();

public:

//Pure virtual function from MVersitObserver

	void VersionSet(CVersitParser* aParser,const TDesC16& aVersion);

	void NewParser(CVersitParser* aParser);

//Pure virtual function from MVersitPlugIn

	TBool AddSpace();

	TBool DeleteAllSpaces();

	TBool NeedsBlankLine();

	void RemoveEscaping(TPtr16& aText);

	void AddEscaping(HBufC16*& aText);

	TBool WrapLine(RWriteStream& aStream,TInt& aCurrentLineLength,const TPtr8& aText);

	TBool EncodingType(Versit::TVersitEncoding& aEncoding,TBool aRequiresEncoding,Versit::TVersitEncoding aDefaultEncoding

																						,TUid aPropertyUid,TUint aPropertyCharset);

	const TDesC8& EncodingName(Versit::TVersitEncoding aEncoding);

private:

	enum TCountFlags

		{

		//Internalising

		ECountVersionSet=0x00000001,

		ECountNewParser=0x00000020,

		ECountAddSpace=0x00000400,

		ECountDeleteSpace=0x00008000,

		ECountNeedsBlank=0x00100000,

		ECountRemoveEscape=0x02000000,

		//Externalising

		ECountAddEscape=0x00000001,

		ECountWrapLine=0x00000100,

		ECountEncodeType=0x00010000,

		ECountEncodeName=0x01000000,

		};

private:

	RFs& iFs;

	CVersitParser* iExpectedParser;

	TBuf<16> iExpectedVersion;

	TBuf<16> iExpectedFirstValueRE;

	TBuf<16> iExpectedFirstValueAE;

	TBuf8<16> iExpectedFirstValueWL;

	TInt iExpectedFirstLineLength;

	TInt iExpectedDefaultEncoding;

	TUid iExpectedFirstUid;

	TInt iExpectedEncodingEN;

	TUint iCount;

	};

void CTestVersitObserver::VersionSet(CVersitParser* aParser,const TDesC16& aVersion)

	{

	if (iExpectedParser)

		TheTest(iExpectedParser==aParser);

	if (iExpectedVersion.Length()>0)

		TheTest(iExpectedVersion==aVersion);

	iCount+=ECountVersionSet;

	}

void CTestVersitObserver::NewParser(CVersitParser* aParser)

	{

	TheTest(iExpectedParser!=aParser);

	aParser->SetObserver(this);

	aParser->SetPlugIn(this);

	iCount+=ECountNewParser;

	}

TBool CTestVersitObserver::AddSpace()

	{

	iCount+=ECountAddSpace;

	return ETrue;

	}

TBool CTestVersitObserver::DeleteAllSpaces()

	{

	iCount+=ECountDeleteSpace;

	return ETrue;

	}

TBool CTestVersitObserver::NeedsBlankLine()

	{

	iCount+=ECountNeedsBlank;

	return ETrue;

	}

void CTestVersitObserver::RemoveEscaping(TPtr16& aText)

	{

	if (iExpectedFirstValueRE.Length()>0)

		{

		TheTest(iExpectedFirstValueRE==aText);

		iExpectedFirstValueRE.Zero();

		}

	iCount+=ECountRemoveEscape;

	}

void CTestVersitObserver::AddEscaping(HBufC16*& aText)

	{

	if (iExpectedFirstValueAE.Length()>0)

		{

		TheTest(iExpectedFirstValueAE==*aText);

		iExpectedFirstValueAE.Zero();

		}

	iCount+=ECountAddEscape;

	}

TBool CTestVersitObserver::WrapLine(RWriteStream& /*aStream*/,TInt& aCurrentLineLength,const TPtr8& aText)

	{

	if (iExpectedFirstValueWL.Length()>0)

		{

		TheTest(iExpectedFirstValueWL==aText);

		iExpectedFirstValueWL.Zero();

		}

	if (iExpectedFirstLineLength>0)

		{

		TheTest(iExpectedFirstLineLength==aCurrentLineLength);

		iExpectedFirstLineLength=0;

		}

	iCount+=ECountWrapLine;

	return EFalse;

	}

TBool CTestVersitObserver::EncodingType(Versit::TVersitEncoding& /*aEncoding*/,TBool /*aRequiresEncoding*/

												,Versit::TVersitEncoding aDefaultEncoding,TUid aPropertyUid,TUint /*aPropertyCharset*/)

	{

	TheTest(iExpectedDefaultEncoding==aDefaultEncoding);

	if (iExpectedFirstUid.iUid!=0)

		{

		TheTest(iExpectedFirstUid==aPropertyUid);

		iExpectedFirstUid.iUid=0;

		}

	iCount+=ECountEncodeType;

	return EFalse;

	}

const TDesC8& CTestVersitObserver::EncodingName(Versit::TVersitEncoding aEncoding)

	{

	TheTest(iExpectedEncodingEN==aEncoding);

	iCount+=ECountEncodeName;

	return KNullDesC8;

	}

void CTestVersitObserver::Test1L()

	{

	RFile file;

	_LIT(KFileI,"Z:\\TestFiles\\IVCal.VCS");

	_LIT(KFileP,"C:\\TestFiles\\PVCal.VCS");

	_LIT(KVersion,"1.0");

	_LIT8(KVersion8,"1.0");

	_LIT(KFirstValue,"VCALENDAR");

	CParserVCal* parser=CParserVCal::NewL();

	CleanupStack::PushL(parser);

	parser->SetObserver(this);

	parser->SetPlugIn(this);

	TInt start=0;

	iCount=0;

	iExpectedParser=parser;

	iExpectedVersion=KVersion;

	iExpectedFirstValueRE=KFirstValue;

	User::LeaveIfError(file.Open(iFs, KFileI, EFileRead));

	CleanupClosePushL(file);

	parser->CVersitParser::InternalizeL(file,start);

	TheTest(iCount==ECountVersionSet+2*ECountNewParser+19*ECountRemoveEscape);

	CleanupStack::Pop(&file);

	file.Close();

	iCount=0;

	iExpectedDefaultEncoding=Versit::ENoEncoding;

	iExpectedFirstValueAE=KVersion;

	iExpectedFirstValueWL=KVersion8;

	iExpectedFirstLineLength=8;

	iExpectedFirstUid.iUid=KVersitPropertyHBufCUid;

	User::LeaveIfError(file.Replace(iFs, KFileP, EFileWrite));

	CleanupClosePushL(file);

	parser->CVersitParser::ExternalizeL(file);

	TheTest(iCount==2*ECountAddEscape+5*ECountWrapLine+13*ECountEncodeType);

	CleanupStack::PopAndDestroy(2,parser);

	}

void CTestVersitObserver::Test2L()

	{

	RFile file;

	_LIT(KFileI,"Z:\\TestFiles\\vCard.VCF");

	_LIT(KFileP,"C:\\TestFiles\\PvCard.VCF");

	_LIT(KVersion,"2.1");

	_LIT8(KVersion8,"2.1");

	_LIT(KFirstValue,"VCARD");

	CParserVCard* parser=CParserVCard::NewL();

	CleanupStack::PushL(parser);

	parser->SetObserver(this);

	parser->SetPlugIn(this);

	TInt start=0;

	iCount=0;

	iExpectedParser=parser;

	iExpectedVersion=KVersion;

	iExpectedFirstValueRE=KFirstValue;

	User::LeaveIfError(file.Open(iFs, KFileI, EFileRead));

	CleanupClosePushL(file);

	parser->CVersitParser::InternalizeL(file,start);

	TheTest(iCount==ECountVersionSet+ECountAddSpace+5*ECountDeleteSpace+8*ECountRemoveEscape);

	CleanupStack::Pop(&file);

	file.Close();

	iCount=0;

	iExpectedDefaultEncoding=Versit::ENoEncoding;

	iExpectedFirstValueAE=KVersion;

	iExpectedFirstValueWL=KVersion8;

	iExpectedFirstLineLength=8;

	iExpectedFirstUid.iUid=KVersitPropertyHBufCUid;

	User::LeaveIfError(file.Replace(iFs, KFileP, EFileWrite));

	CleanupClosePushL(file);

	parser->CVersitParser::ExternalizeL(file);

	TheTest(iCount==5*ECountAddEscape+5*ECountWrapLine+6*ECountEncodeType);

	CleanupStack::PopAndDestroy(2,parser);

	}

void CTestVersitObserver::Test3L()

	{

	RFile file;

	_LIT(KFileI,"Z:\\TestFiles\\Base64.VCF");

	_LIT(KFileP,"C:\\TestFiles\\PBase64.VCF");

	_LIT(KFileP1,"C:\\TestFiles\\PBase64a.VCF");

	_LIT(KVersion,"2.1");

	_LIT8(KVersion8,"2.1");

	_LIT(KFirstValue,"VCARD");

	CParserVCard* parser=CParserVCard::NewL();

	CleanupStack::PushL(parser);

	parser->SetObserver(this);

	parser->SetPlugIn(this);

	TInt start=0;

	iCount=0;

	iExpectedParser=parser;

	iExpectedVersion=KVersion;

	iExpectedFirstValueRE=KFirstValue;

	User::LeaveIfError(file.Open(iFs, KFileI, EFileRead));

	CleanupClosePushL(file);

	parser->CVersitParser::InternalizeL(file,start);

	TheTest(iCount==ECountVersionSet+ECountNeedsBlank+5*ECountRemoveEscape);

	CleanupStack::Pop(&file);

	file.Close();

	iCount=0;

	iExpectedDefaultEncoding=Versit::ENoEncoding;

	iExpectedFirstValueAE=KVersion;

	iExpectedFirstValueWL=KVersion8;

	iExpectedFirstLineLength=8;

	iExpectedFirstUid.iUid=KVersitPropertyHBufCUid;

	iExpectedEncodingEN=Versit::EQuotedPrintableEncoding;

	User::LeaveIfError(file.Replace(iFs, KFileP, EFileWrite));

	CleanupClosePushL(file);

	parser->CVersitParser::ExternalizeL(file);

	TheTest(iCount==3*ECountAddEscape+2*ECountWrapLine+3*ECountEncodeType+ECountEncodeName);

	CleanupStack::Pop(&file);

	file.Close();

	iCount=0;

	iExpectedDefaultEncoding=Versit::EBase64Encoding;

	iExpectedFirstValueAE=KVersion;

	iExpectedEncodingEN=Versit::EBase64Encoding;

	User::LeaveIfError(file.Replace(iFs, KFileP1, EFileWrite));

	CleanupClosePushL(file);

	parser->SetDefaultEncoding(Versit::EBase64Encoding);

	parser->CVersitParser::ExternalizeL(file);

	TheTest(iCount==3*ECountAddEscape+3*ECountEncodeType+3*ECountEncodeName);

	CleanupStack::PopAndDestroy(2,parser);

	}

//test for Reccurrence rule in VCal (VCS)

void CTestVersitObserver::TestReccurrenceRulesL()

	{

	RFile file;

	_LIT(KFileI,"Z:\\TestFiles\\IRDailyVCal.VCS");

	CParserVCal* parser=CParserVCal::NewL();

	CleanupStack::PushL(parser);

	User::LeaveIfError(file.Open(iFs, KFileI, EFileRead));

	CleanupClosePushL(file);

	TInt start=0;

	parser->CVersitParser::InternalizeL(file,start);

	CleanupStack::Pop(&file);

	file.Close();

	CArrayPtr<CVersitParser>* entities= parser->ArrayOfEntities(EFalse);

	CArrayPtr<CParserProperty>* properties = (*entities)[0]->PropertyL(KVersitTokenRRULE, TUid::Uid(KVCalPropertyRecurrenceUid), EFalse); // don't take ownership

	CleanupStack::PushL(properties);

	CParserPropertyValueRecurrence* propertyrecurval = (CParserPropertyValueRecurrence*)((*properties)[0]->Value());	

	TheTest(2 == (propertyrecurval->Value())->iDuration);

	CleanupStack::PopAndDestroy(properties);

	CleanupStack::PopAndDestroy(parser);

	}

GLDEF_C void TestPlugInL(RFs& aFsSession)

	{

	_LIT(KTest,"PlugIn Test");

	TheTest.Start(KTest);

	CTestVersitObserver* test=new(ELeave) CTestVersitObserver(aFsSession);

	CleanupStack::PushL(test);

	_LIT(KTest1,"Simple VCal Test");

	TheTest.Next(KTest1);

	test->Test1L();

	_LIT(KTest2,"VCard Test");

	TheTest.Next(KTest2);

	test->Test2L();

	_LIT(KTest3,"Base64 Test");

	TheTest.Next(KTest3);

	test->Test3L();

	//Testing reccurrence rules of VCal (.vcs)

	_LIT(KTestRRule,"Testing Reccurrence Rules...");

	TheTest.Next(KTestRRule);

	test->TestReccurrenceRulesL();

	CleanupStack::PopAndDestroy(test);

	TheTest.End();

	}