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

#include "TDefaultCharset.h"

// System includes
#include <versit.h>
#include <f32file.h>
#include <e32test.h>

// Literal constants
_LIT(KTestName, "TDefaultCharSet");

_LIT(KTestInputFile, "Z:\\TestFiles\\DefaultCharSetInput.vcf");
_LIT(KTestOutputFile, "C:\\DefaultCharSetOutput.vcf");
_LIT8(KShiftJis, "Shift_JIS");

// Globals
static RFs					TheFsSession;
static RTest				TheTest(KTestName);

static void FileCleanup(TAny * aFileMan)
	{
	CFileMan* FileMan = (CFileMan*)aFileMan;
	FileMan->Delete(_L("C:\\DefaultCharSetOutput.vcf"));
	}

static void DoTestsL()
	{
	CFileMan* FileMan = CFileMan::NewL(TheFsSession);
	CleanupStack::PushL(FileMan);
	CleanupStack::PushL(TCleanupItem(FileCleanup, FileMan));
	CVersitCardTest* test = CVersitCardTest::NewLC();
	test->StartTestsL();
	CleanupStack::PopAndDestroy(3, FileMan); // filecleanup, test
	}

/**
@SYMTestCaseID PIM-TDEFAULTCHARSET-0001
*/
GLDEF_C TInt E32Main()
	{
	
	TTime startTime;
	startTime.UniversalTime();
	
	__UHEAP_MARK;
	CTrapCleanup* TheCleanup = CTrapCleanup::New();
	if	(!TheCleanup)
		return KErrNoMemory;

	if	(TheFsSession.Connect() < KErrNone)
		return KErrGeneral;

	TheTest.Start(_L("@SYMTestCaseID PIM-TDEFAULTCHARSET-0001 TDefaultCharSet"));
	TRAPD(error, DoTestsL());
	TheTest(error == KErrNone);
	TheTest.End();
	TheTest.Close();
	TheFsSession.Close();

	delete TheCleanup;
	__UHEAP_MARKEND;
	
	TTime finishTime;
	finishTime.UniversalTime();
	TReal elapsed = (TReal)finishTime.MicroSecondsFrom(startTime).Int64();
	TheTest.Printf(_L("Elapsed time: %.4f\n"), elapsed/1000000);
	
	return KErrNone;
	}

//
// ------> CVersitCardTest (source)
//

//********************************************************************************************
CVersitCardTest* CVersitCardTest::NewLC()
	{
	CVersitCardTest* self = new(ELeave) CVersitCardTest;
	CleanupStack::PushL(self);
	return self;
	}

//********************************************************************************************
void CVersitCardTest::StartTestsL()
	{
	/*	
	This test is created to ensure that the new TVersitParserFlags enumeration 
	EUseDefaultCharSetForAllProperties works correctly and it gives the expected behaviour. 
	
	1.	Create parser and set default language from US-ASCII->SHIFT-JIS
	2.	Set EUseDefaultCharSetForAllProperties flag
	3.	Internalize a card with default SHIFT-JIS fields with no explicit charsets
	4.	Externalise the same contact (should put shift-jis charset explicitly into vcf)
	5.	Check to ensure that the exported vcf contains explict charset of SHIFT-JIS
		NOTE:: cannot check with internalize due to stripping of charset in AnalysesEncodingCharset()
	
	*/
	
	
	TheTest.Start(_L("Set up Parser"));
	
	CParserVCard* cardParser = CParserVCard::NewL();
	CleanupStack::PushL(cardParser);
		
	cardParser->SetDefaultCharSet(Versit::EShiftJISCharSet);					//1
	cardParser->SetFlags(CVersitParser::EUseDefaultCharSetForAllProperties);	//2
	
	TheTest.Next(_L("Start Internalization of Card"));
	TRAPD(err, InternalizeCardL(KTestInputFile, *cardParser));					//3
	TheTest(err==KErrNone);
	
	TheTest.Next(_L("Externalize the Card"));
	TRAP(err, ExternalizeCardL(KTestOutputFile, *cardParser));					//4
	TheTest(err==KErrNone);
	
	
	TheTest.Next(_L("Check that resulting card is correct"));
	TRAP(err, TheTest(CheckResultL(KTestOutputFile)));							//5
	TheTest(err==KErrNone);
	
	TheTest.End();	
	
	CleanupStack::PopAndDestroy(cardParser);	
	}
//********************************************************************************************

void CVersitCardTest::InternalizeCardL(const TDesC& aFile, CParserVCard& aParser) const
//
//	Internalize the specified file
//
	{
	TInt pos = 0;
	RFile file;
	User::LeaveIfError(file.Open(TheFsSession, aFile, EFileRead));
	CleanupClosePushL(file);

	// Read from the file
	static_cast<CVersitParser&>(aParser).InternalizeL(file, pos);

	CleanupStack::PopAndDestroy(); // file
	}
//********************************************************************************************

void CVersitCardTest::ExternalizeCardL(const TDesC& aFile, CParserVCard& aParser) const
//
//	Externalize the specified file
//
	{
	RFile file;
	User::LeaveIfError(file.Replace(TheFsSession, aFile, EFileWrite));
	CleanupClosePushL(file);

	// Write from the file
	static_cast<CVersitParser&>(aParser).ExternalizeL(file);

	CleanupStack::PopAndDestroy(); // file
	}
//********************************************************************************************

TBool CVersitCardTest::CheckResultL(const TDesC& aFile) const
	{
	TBool result=EFalse;
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	
	RFile myFile;
	CleanupClosePushL(myFile);

	TInt err = myFile.Open(fs, aFile, EFileRead|EFileShareReadersOnly);
	if (err != KErrNone)
		User::Leave(err);	
		
	TBuf8<256> buffer;
	myFile.Read(buffer, 256);
	
	//	check to ensure that shift-jis is explicitly set.
	if(KErrNotFound != buffer.Find(KShiftJis))
		result=ETrue;
	else
		result=EFalse;

	CleanupStack::PopAndDestroy(2);	//	myFile, fs
	return result;
	}