// 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:

//

#include "TVERSIT.H"

#include <vutil.h>

#include <charconv.h>

#include <e32test.h>

#include <coreappstest/testserver.h>

// Type definitions

#define UNUSED_VAR(a) a = a

// Currently no tests for multiple VCards in sequence in a stream

CConsoleBase* console;

CVersitTest* test=NULL;

TBool automatic=EFalse;

LOCAL_D CTestRegister* FileRegister;

#ifdef MANUAL

#define TheTest  (*console)

#define Next 	Printf

#else

static RTest TheTest(_L("TVersit"));

#endif

//

// CVersitTest

//

CVersitTest::CVersitTest()

	{}

CVersitTest::~CVersitTest()

	{

	delete iParser;

	delete iStore;

	}

void CVersitTest::StreamInL()

//Convert the iVersit into stream format, save it as "VersitIn"

//and internalize it as a CVersitParser

	{

	_LIT(KVersitInFileName, "VersitIn");

	RFs fsSession; 

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

	CleanupClosePushL(fsSession);

	TFileName inFile;

	FileRegister->GetTempPath(inFile);

	inFile.Append(KVersitInFileName);

	fsSession.MkDirAll(inFile);

	FileRegister->RegisterL(inFile);

	CFileStore* store = CDirectFileStore::ReplaceLC(fsSession, inFile, EFileWrite);

    	store->SetTypeL(KDirectFileStoreLayoutUid);

	RStoreWriteStream outstream;

	TStreamId id = outstream.CreateLC(*store);

	TInt length=iVersit.Length();

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

		outstream.WriteInt8L(iVersit[ii]);

	outstream.CommitL();

	CleanupStack::PopAndDestroy(); // outstream

	store->SetRootL(id);

	store->CommitL();

	CleanupStack::PopAndDestroy(store);

	store = CDirectFileStore::OpenLC(fsSession, inFile, EFileRead); //retrieve stream

	RStoreReadStream instream;

	instream.OpenLC(*store,store->Root());

	iParser->InternalizeL(instream);

	CleanupStack::PopAndDestroy(3); //store + stream + fsSession

	}

void CVersitTest::StreamOutL()

// externalize the CVersitParser into stream format, save the stream as "VersitOut"

// and output it to the console

	{

	_LIT(KVersitOutFileName, "VersitOut");

	RFs fsSession; // Save into stream

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

	TFileName outFile;

	FileRegister->GetTempPath(outFile);

	outFile.Append(KVersitOutFileName);

	FileRegister->RegisterL(outFile);

	fsSession.MkDirAll(outFile);

	CFileStore* store = CDirectFileStore::ReplaceLC(fsSession, outFile, EFileWrite);

    store->SetTypeL(KDirectFileStoreLayoutUid);

	RStoreWriteStream outstream;

	TStreamId id = outstream.CreateLC(*store);

	iParser->ExternalizeL(outstream);

	outstream.CommitL();

	CleanupStack::PopAndDestroy();

	store->SetRootL(id);

	store->CommitL();

	CleanupStack::PopAndDestroy();

	store = CDirectFileStore::OpenLC(fsSession, outFile, EFileRead); //retrieve stream

	RStoreReadStream instream;

	instream.OpenLC(*store,store->Root());

	TInt err=0;

	TChar nextChar=0;

	iVersit.Zero();

#ifdef UNICODE

	CCnvCharacterSetConverter* unicodeConverter=CCnvCharacterSetConverter::NewLC();

	CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=unicodeConverter->CreateArrayOfCharacterSetsAvailableL(fsSession);

	CleanupStack::PushL(arrayOfCharacterSetsAvailable);

	unicodeConverter->PrepareToConvertToOrFromL(0x100012b6, *arrayOfCharacterSetsAvailable, fsSession); // Code Page 1252

	unicodeConverter->SetReplacementForUnconvertibleUnicodeCharactersL(_L8("?"));

	CleanupStack::PopAndDestroy(); //arrayOfCharacterSetsAvailable

#endif	

	while (err==0)

		{

		if (nextChar!=CVersitParser::ELineFeed)

			{

			TRAP(err,nextChar=instream.ReadUint8L());

			if (err!=KErrEof)

				User::LeaveIfError(err);

			iVersit.Append(nextChar);

			}

		else

			{

#ifdef UNICODE

			HBufC16* output=HBufC16::NewLC(iVersit.Length());

			TInt state;

			TPtr16 temp = output->Des();

			TInt error = unicodeConverter->ConvertToUnicode(temp, iVersit, state);

			if (error!=KErrNone)

				User::Leave(error);

			TheTest.Printf(*output);

			CleanupStack::PopAndDestroy(); //output

#else

			TheTest.Printf(iVersit);

#endif

			if (!automatic)

				{

				TInt character=TheTest.Getch();

				if (character=='q') // character q quits

					break;

				}

			nextChar=0;

			iVersit.Zero();

			}

		}

#ifdef UNICODE

	CleanupStack::PopAndDestroy(); //unicodeConverter

#endif

	if (!automatic)

		{

		TheTest.Printf(_L("\n [press any key]\n"));

		TheTest.Getch(); // get and ignore character

		}

	CleanupStack::PopAndDestroy(2); //store +stream

	fsSession.Close();

	}

void CVersitTest::SaveFileVersitL(/*CVersitParser*/Versit::TVersitCharSet aDefaultCharSet)

// Save iParser into VersitFile	

	{

	if	(!iParser)

		return;

	RFs fsSession;

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

	fsSession.MkDirAll(_L("C:\\logs\\t_versit\\"));

	RFile file;

	// glenn hard code to test round trip

	iParser->SetDefaultCharSet(aDefaultCharSet);

	if (file.Replace(fsSession,_L("C:\\logs\\t_versit\\VersitFile"),EFileWrite)==KErrNone)

		iParser->ExternalizeL(file);

	file.Close();

	fsSession.Close();

	}

void CVersitTest::CheckIsValidLabelL()

	{

	TInt pos;

	if(CVersitParser::IsValidLabel(_L("abcdefghijklmnopqrstuvwxyz"), pos))

		TheTest.Printf(_L("\n test passed\n"));

	else

		TheTest.Printf(_L("\n test failed, pos = %d\n"), pos);

	if(CVersitParser::IsValidLabel(_L("abcd:"), pos))

		TheTest.Printf(_L("\n test failed, pos = %d\n"), pos);

	else

		TheTest.Printf(_L("\n test passed\n"));

	if(CVersitParser::IsValidLabel(_L("ab[c]d"), pos))

		TheTest.Printf(_L("\n test failed, pos = %d\n"), pos);

	else

		TheTest.Printf(_L("\n test passed\n"));

	if(CVersitParser::IsValidLabel(_L("abc]d"), pos))

		TheTest.Printf(_L("\n test failed, pos = %d\n"), pos);

	else

		TheTest.Printf(_L("\n test passed\n"));

	if(CVersitParser::IsValidLabel(_L(",abcd"), pos))

		TheTest.Printf(_L("\n test failed, pos = %d\n"), pos);

	else

		TheTest.Printf(_L("\n test passed\n"));

	}

//

// CVCalTest

//

void CVCalTest::LoadFileVersitL()

// Read VCalendar.vcs into iVersit	

	{

	if (iParser == NULL)

		iParser = CParserVCal::NewL();

	RFs fsSession;

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

	RFile file;

	if (file.Open(fsSession,_L("C:\\VCalendar.vcs"),EFileRead)==KErrNone)

		{		

		TInt start=0;

		iParser->InternalizeL(file,start);

		}

	file.Close();

	fsSession.Close();

	}

void CVCalTest::BuildVersitL()

	{

	iParser = CParserVCal::NewL();

	iParser->SetDefaultCharSet(Versit::EISO88597CharSet);

	CParserPropertyValue* value = CParserPropertyValueHBufC::NewL(_L("TEST!!!"));

	CParserProperty* property = CParserProperty::NewL(*value, KVersitTokenDESCRIPTION, NULL);

	iParser->AddPropertyL(property); //takes ownership

	CParserVCalEntity* entity = CParserVCalEntity::NewL();

	entity->SetEntityNameL(KVersitVarTokenVTODO);

	CParserPropertyValue* value1 = CParserPropertyValueHBufC::NewL(_L("TEST!!!"));

	CParserProperty* property1 = CParserProperty::NewL(*value1, KVersitTokenDESCRIPTION, NULL);

	entity->AddPropertyL(property1);

	iParser->AddEntityL(entity);

	CArrayPtr<CVersitParser>* entities = iParser->EntityL(KVersitVarTokenVTODO,EFalse);	

	if (entities == NULL)

		User::Leave(KErrNotFound);

	CArrayPtr<CParserProperty>* properties = (*entities)[0]->PropertyL(/*KVersitVarTokenDESCRIPTION*/KVersitTokenDESCRIPTION, TUid::Uid(KVersitPropertyHBufCUid), EFalse);

	if (properties == NULL)

		User::Leave(KErrNotFound);

	delete entities;

	delete properties;

	}

//

// CVCardTest

//

void CVCardTest::LoadFileVersitL()

// Read VCard.vcf into iVersit	

	{

	if (iParser == NULL)

		iParser = CParserVCard::NewL();

	RFs fsSession;

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

	RFile file;

	if (file.Open(fsSession,_L("C:\\VCard.vcf"),EFileRead)==KErrNone)

		{		

		TInt start=0;

		iParser->InternalizeL(file,start);

		}

	file.Close();

	fsSession.Close();

	}

void CVCardTest::BuildVersitL()

	{

	iParser = CParserVCard::NewL();

	iParser->SetDefaultCharSet(Versit::EISO88597CharSet);

	RFs fsSession;

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

	CParserPropertyValue* value = CParserPropertyValueHBufC::NewL(_L("TEST!!!"));	

	CParserProperty* property = CParserGroupedProperty::NewL(*value, KVersitTokenFN, NULL, NULL);

	iParser->AddPropertyL(property); //takes ownership

	CArrayPtr<CParserProperty>* properties = iParser->PropertyL(KVersitTokenFN, TUid::Uid(KVersitPropertyHBufCUid), EFalse);

	if (property == NULL)

		User::Leave(KErrNotFound);

	delete properties;

	fsSession.Close();

	}

//

// Globals

//

void Help()

	{

	TheTest.Printf(_L("\n\n\nFiles must be placed in:"));

	TheTest.Printf(_L("\nC: for marm"));

	TheTest.Printf(_L("\n\\epoc32\\wins\\c for wins"));

	TheTest.Printf(_L("\n\nc:\\VersitIn file contains stream-internalized sample parse"));

	TheTest.Printf(_L("\nc:\\VersitOut file contains most recently stream-externalized parse"));

	TheTest.Printf(_L("\nc:\\VersitFile contains most recently file-externalized parse"));

	TheTest.Printf(_L("\nRename any sample file to be tested as suggested and choose options 1 and 2"));

	TheTest.Printf(_L("\nPress any key to scroll line by line through an externalized model"));

	TheTest.Printf(_L("\n'q' returns to menu"));

	TheTest.Printf(_L("\n(Press any key)\n\n"));

	TheTest.Getch();

	}

TInt Menu()

	{

	TheTest.Printf(_L("\n\n\nTest:"));

	TheTest.Printf(_L("\n\n1. Internalize c:\\vcalendar.vcs"));

	TheTest.Printf(_L("\n2. Internalize c:\\vcard.vcf"));

	TheTest.Printf(_L("\n3. Internalize full vcal test"));

	TheTest.Printf(_L("\n4. Internalize full vcard test"));

	TheTest.Printf(_L("\n5. Build up vcal dynamically"));

	TheTest.Printf(_L("\n6. Build up vcard dynamically"));

	TheTest.Printf(_L("\n7. Externalize current object"));

	TheTest.Printf(_L("\n8. Externalize object to c:\\VersitFile"));

	TheTest.Printf(_L("\n9. Externalize object to c:\\VersitFile using ISO-X charset"));

	TheTest.Printf(_L("\n0. Test IsValidlabel() method"));

	TheTest.Printf(_L("\na. Timed full vCard internalize x 100"));

	TheTest.Printf(_L("\nb. Internalize c:\\vcard.vcf (QP encoding, UTF8 charset)"));

	TheTest.Printf(_L("\nc. Internalize c:\\vcard.vcf (QP encoding, UTF7 charset)"));

	TheTest.Printf(_L("\nd. Internalize c:\\vcard.vcf (QP encoding, ISO x charsets)"));

	//

	//Change 26/01/2001

	//#001

	//Insert Start : Character sets for Chinese are added.

	TheTest.Printf(_L("\ne. Internalize c:\\vcard.vcf     (QP encoding, GBK charsets)"));

	TheTest.Printf(_L("\nf. Internalize c:\\vcard.vcf     (QP encoding, GB2312 charsets)"));

	TheTest.Printf(_L("\ng. Internalize c:\\vcard.vcf     (QP encoding, Big5 charsets)"));

	TheTest.Printf(_L("\ni. Internalize c:\\vcalendar.vcs (QP encoding, GBK charsets)"));

	TheTest.Printf(_L("\nj. Internalize c:\\vcalendar.vcs (QP encoding, GB2312 charsets)"));

	TheTest.Printf(_L("\nk. Internalize c:\\vcalendar.vcs (QP encoding, Big5 charsets)"));

	TheTest.Printf(_L("\nl. Internalize c:\\vcalendar.vcs (QP encoding, UTF8 charset)"));

	TheTest.Printf(_L("\nm. Internalize c:\\vcalendar.vcs (QP encoding, UTF7 charset)"));

	TheTest.Printf(_L("\nn. Externalize object to c:\\VersitFile (QP encoding Base64, GBK charset)"));

	TheTest.Printf(_L("\no. Externalize object to c:\\VersitFile (QP encoding Base64, GB2312 charset)"));

	TheTest.Printf(_L("\np. Externalize object to c:\\VersitFile (QP encoding Base64, Big5 charset)"));

	TheTest.Printf(_L("\nr. Externalize object to c:\\VersitFile (QP UTF-8 charset)"));

	TheTest.Printf(_L("\ns. Externalize object to c:\\VersitFile (QP UTF-7 charset)"));

	TheTest.Printf(_L("\nt. Externalize object to c:\\VersitFile (SHIFT_JIS charset)"));

	TheTest.Printf(_L("\nu. Internalize object from c:\\vCard.vcf (SHIFT_JIS charset)"));

	//Insert End

	//

	TheTest.Printf(_L("\nh. Help"));

	TheTest.Printf(_L("\nq. Quit\n\n"));

	return (TheTest.Getch());

	}

TInt DoTestL(TInt aChoice)

	{

	TInt error=KErrNone;

	switch(aChoice)

		{

		case 'h':

		case 'H':

			Help();

			break;

		case '1':

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\nVCalendar.vcs must be in c: in order to internalize it\n"));

			test=new(ELeave)CVCalTest;

			CleanupStack::PushL(test);

			TRAP(error,test->LoadFileVersitL());

			break;

		case '2':

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\nVCard.vcf must be in c: in order to internalize it\n"));

			test=new(ELeave)CVCardTest;

			CleanupStack::PushL(test);

			TRAP(error,test->LoadFileVersitL());

			break;

		case '3':

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\nCreate a sample vCal in file VersitIn and internalize it\n"));

			test=new(ELeave)CVCalTest;

			CleanupStack::PushL(test);

			test->GetSampleVersitL();

			TRAP(error,test->StreamInL()); // run tests

			break;

		case '4':

			{

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\nCreate a sample vCard in file VersitIn and internalize it\n"));

			test = new(ELeave) CVCardTest;

			CleanupStack::PushL(test);

			test->GetSampleVersitL();

			TRAP(error,test->StreamInL()); // run tests

			break;

			}

		case '5':

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\nBuild up vcal dynamically\n"));

			test=new(ELeave)CVCalTest;

			CleanupStack::PushL(test);

			test->BuildVersitL();

			break;

		case '6':

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\nBuild up vcard dynamically\n"));

			test=new(ELeave)CVCardTest;

			CleanupStack::PushL(test);

			test->BuildVersitL();

			TheTest.Next(_L("\nExternalize object\n"));

			if (test)

				TRAP(error,test->StreamOutL()); // run tests

			break;

		case '7':

			TheTest.Next(_L("\nExternalize object\n"));

			if (test)

				TRAP(error,test->StreamOutL()); // run tests

			break;

		case '8':

			TheTest.Next(_L("\n Externalize object to VersitFile\n"));

			if (test)

				TRAP(error,test->SaveFileVersitL()); // run tests

			break;

		case '9':

			TheTest.Next(_L("\n Externalize object to VersitFile using ISO-X charset\n"));

			if (test)

				TRAP(error,test->SaveFileVersitL(Versit::EISO88592CharSet)); // run tests

			break;

		case '0':

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\n Test IsValidLabel()\n"));

			test=new(ELeave)CVCalTest;

			CleanupStack::PushL(test);

			test->CheckIsValidLabelL(); // run tests

			break;

		case 'a':

		case 'A':

			{

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\n VCard test internalize x 100\n"));

			test = new(ELeave) CVCardTest;

			CleanupStack::PushL(test);

			TTime start;

			start.UniversalTime();

			TTime finish;

			TInt i;

			for(i = 0; i < 100 && error ==KErrNone; i++)

				{

				test->GetSampleVersitL();

				TRAP(error, test->StreamInL()); // run tests

				delete test->iParser;	// delete parser after each test or it gets HUGE and we run out of memory

				test->iParser=NULL;

				}

			finish.UniversalTime();

			TheTest.Printf(_L("\nTook %d microseconds for %i tests\n"), finish.MicroSecondsFrom(start).Int64(), i);

			break;

			}

		case 'b':

		case 'B':

			{

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, UTF8 charset)\n"));

			test = new(ELeave) CVCardTest;

			CleanupStack::PushL(test);

			test->iParser = CParserVCard::NewL();

 			test->iParser->SetDefaultCharSet(Versit::EUTF8CharSet);

			TRAP(error,test->LoadFileVersitL());

			break;

			}

		case 'c':

		case 'C':

			{

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, UTF7 charset)\n"));

			test = new(ELeave) CVCardTest;

			CleanupStack::PushL(test);

			test->iParser = CParserVCard::NewL();

 			test->iParser->SetDefaultCharSet(Versit::EUTF7CharSet);

			TRAP(error,test->LoadFileVersitL());

			break;

			}

		case 'd':

		case 'D':

			{

			if (test)

				CleanupStack::PopAndDestroy(test);

			TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, ISO X charset)\n"));

			test = new(ELeave) CVCardTest;

			CleanupStack::PushL(test);