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

// Auto test VCal import functionality

// 

//

#include <e32test.h>

#include <s32file.h>

#include <txtrich.h>

#include <e32math.h>

#include <caldataexchange.h>

#include <caldataformat.h>

#include <calentryview.h>

#include <caliterator.h>

#include <calentry.h>

#include <coreappstest/testserver.h>

#include "caltestlib.h"

LOCAL_D RTest test(_L("T_VCAL3"));

_LIT(KTestCalendarFile, "c:t_vcal3");

_LIT(KTestVCalFile, "t_vcal3.vcs");

const TInt numNames = 5;

const TInt numParams = 2;

const TInt numValues = 7;

TBuf8<40> names[numNames];

TBuf8<40> params[numParams];

TBuf8<40> values[numValues];

TBuf8<1> charstring;

class CTestApp : public CBase

	{

public:

	static CTestApp* NewL();

	~CTestApp();

	void RunTestsL();

private:

	void ConstructL();

	void PrintValue(RFile& outfile, TInt64& seed);

	void PrintParam(RFile& outfile, TInt64& seed);

	void PrintName(RFile& outfile, TInt64& seed);

private:

	CCalTestLibrary* iCalTestLib;

	CCalDataExchange* iCalDataExchange;

	};

CTestApp* CTestApp::NewL()

	{

	CTestApp* self = new(ELeave) CTestApp;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTestApp::ConstructL()

	{

	iCalTestLib = CCalTestLibrary::NewL();

	iCalTestLib->ReplaceFileL(KTestCalendarFile);

	iCalTestLib->OpenFileL(KTestCalendarFile);

	iCalDataExchange = CCalDataExchange::NewL(iCalTestLib->GetSession());

	}

CTestApp::~CTestApp()

	{

	TRAP_IGNORE(iCalTestLib->DeleteFileL(KTestCalendarFile, ETrue));

	delete iCalDataExchange;

	delete iCalTestLib;

	}

void CTestApp::PrintValue(RFile& outfile, TInt64& seed)

	{

	TInt valueIndex = static_cast<TInt>(Math::FRand(seed) * numValues * 1.1);

	if(valueIndex < numValues)

		{

		outfile.Write(values[valueIndex]);

		}

	else

		{

		if(static_cast<TInt>(Math::FRand(seed) + 0.5))

			{

			TInt repeats = static_cast<TInt>(Math::FRand(seed) * 50);

			for(TInt p = 0; p < repeats; p++)

				{

				charstring.Fill(static_cast<TInt>(Math::FRand(seed) * 255), 1);

				}

			outfile.Write(charstring);

			}

		}

	}

void CTestApp::PrintParam(RFile& outfile, TInt64& seed)

	{

	TInt paramIndex = static_cast<TInt>(Math::FRand(seed) * numParams * 1.1);

	if(paramIndex < numParams)

		{

		outfile.Write(_L8(";"));

		outfile.Write(params[paramIndex]);

		outfile.Write(_L8("="));

		PrintValue(outfile, seed);

		}

	else

		{

		TInt repeats = static_cast<TInt>(Math::FRand(seed) * 50);

		for(TInt p = 0; p < repeats; p++)

			{

			charstring.Fill(static_cast<TInt>(Math::FRand(seed) * 255), 1);

			}

		outfile.Write(charstring);

		}

	}

void CTestApp::PrintName(RFile& outfile, TInt64& seed)

	{

	TInt nameIndex = static_cast<TInt>(Math::FRand(seed) * numNames * 1.1);

	if(nameIndex < numNames)

		{

		outfile.Write(names[nameIndex]);

		//write param

		if(static_cast<TInt>(Math::FRand(seed) + 0.4))

			PrintParam(outfile, seed);

		outfile.Write(_L8(":"));

		//write value

		if(static_cast<TInt>(Math::FRand(seed) + 0.8))

			PrintValue(outfile, seed);

		if(static_cast<TInt>(Math::FRand(seed) + 0.8))

			outfile.Write(_L8("\r\n"));

		}

	else

		{

		TInt repeats = static_cast<TInt>(Math::FRand(seed) * 10);

		for(TInt p = 0; p < repeats; p++)

			{

			charstring.Fill(static_cast<TInt>(Math::FRand(seed) * 255), 1);

			}

		outfile.Write(charstring);

		}				

		if(static_cast<TInt>(Math::FRand(seed) + 0.8))

			outfile.Write(_L8("\r\n"));

	}

void CTestApp::RunTestsL()

	{	

	TTime time;

	time.UniversalTime();

	TInt64 seed = time.Int64();

	names[0] = _L8("BEGIN");

	names[1] = _L8("END");

	names[2] = _L8("\r\n");

	names[3] = _L8("DTSTART:");

	names[4] = _L8("DESCRIPTION:");

	params[0] = _L8("ENCODING");

	params[1] = _L8("LANGUAGE");

	values[0] = _L8("VCALENDAR");

	values[1] = _L8("VEVENT");

	values[2] = _L8("VTODO");

	values[3] = _L8("BASE64");

	values[4] = _L8("QUOTED-PRINTABLE");

	values[5] = _L8("8-bit");

	values[6] = _L8("fr-CA");

	for(TInt i = 0; i < 100; i++)

		{

		iCalTestLib->CleanDatabaseL();

		// Create the random vcal file "vcal.vcs" full of "non-entries"

		RFile outfile;

		iCalTestLib->TestRegister().CreateTempFileLC(outfile, KTestVCalFile);

		test.Printf(_L("Creating random vcal.vcs\r\n"));

		TInt repeats = static_cast<TInt>((Math::FRand(seed) * 10) + 2);

		for(TInt j = 0; j < repeats; j++)

			{

			if(static_cast<TInt>(Math::FRand(seed) + 0.6))

				{

				outfile.Write(_L8("BEGIN:VCALENDAR"));

				outfile.Write(_L8("\r\n"));

				}

  			if(static_cast<TInt>(Math::FRand(seed) + 0.6))

				{

				outfile.Write(_L8("BEGIN:VEVENT"));

				outfile.Write(_L8("\r\n"));

				}

  			TInt entryrepeats = static_cast<TInt>(Math::FRand(seed) * 80);

			for(TInt k = 0; k < entryrepeats; k++)

				{

				PrintName(outfile, seed);

				}

  			if(static_cast<TInt>(Math::FRand(seed) + 0.6))

				{

				outfile.Write(_L8("END:VEVENT"));

				outfile.Write(_L8("\r\n"));

				}

  			if(static_cast<TInt>(Math::FRand(seed) + 0.6))

				{

				outfile.Write(_L8("END:VCALENDAR"));

				outfile.Write(_L8("\r\n"));

				}

			}

		CleanupStack::PopAndDestroy(&outfile);

		test.Next(_L("Importing All entries"));

		RFile infile;

		iCalTestLib->TestRegister().OpenTempFileLC(infile, KTestVCalFile);

		RFileReadStream readStream(infile);

		CleanupClosePushL(readStream);

		// Create array for new entries

		RPointerArray<CCalEntry> entryArray;

		CleanupResetAndDestroyPushL(entryArray);

		TRAPD(err, iCalDataExchange->ImportL(KUidVCalendar, readStream, entryArray));

		test(err == KErrNotFound || err == KErrNone); // test the import left appropriatly - not found if no matching BEGIN-END

		CleanupStack::PopAndDestroy(&entryArray);

		CleanupStack::PopAndDestroy(&readStream);

		CleanupStack::PopAndDestroy(&infile);

		}

	iCalTestLib->FileSession().Delete(KTestVCalFile);

	}

static void DoMainL()

	{

	CTestApp* testApp = CTestApp::NewL();

	CleanupStack::PushL(testApp);

	testApp->RunTestsL();

	CleanupStack::PopAndDestroy(testApp);

	}

/**

@SYMTestCaseID     PIM-T-VCAL3-0001

*/

TInt E32Main()

	{	

	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-T-VCAL3-0001 T_VCAL3"));

	test.Title();

	CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;

	CActiveScheduler::Install(scheduler);

	CTrapCleanup* theCleanup = CTrapCleanup::New();

	TRAPD(ret,DoMainL());	

	test(ret==KErrNone);

	delete theCleanup;	

	delete scheduler;

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return(KErrNone);

	}