// 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 <e32std.h>

#include <e32test.h>

#include <versit.h>

#include <vcal.h>

#include <vcard.h>

#include <coreappstest/testserver.h>

_LIT(KTestName,"Versit OOM Tests");

LOCAL_D RFs fs;

LOCAL_D RTest test(KTestName);

_LIT8(KVCalendarAllMandatoryProperties,	

"BEGIN:VCALENDAR\r\n" 

"VERSION:1.0\r\n"

"BEGIN:VEVENT\r\n"

"CATEGORIES:APPOINTMENT;MEETING\r\n"

"SUMMARY:Meeting with SyncML team\r\n"

"DESCRIPTION:Check mandatory vCalendar compliance\r\n"

"DTSTART:20010316T170000Z\r\n"

"DTEND:20010316T180000Z\r\n"

"STATUS:NEEDS ACTION\r\n"

"X-EPOCAGENDAENTRYTYPE:APPOINTMENT\r\n"

//"AALARM:\r\n"

"AALARM:20010607T084500\r\n"

"AALARM;TYPE=X-EPOCSOUND:20000110T084500Z;;0;Chimes\r\n"

"END:VEVENT\r\n"

"BEGIN:VTODO\r\n"

"DESCRIPTION:To-do item\r\n"

"PRIORITY:1\r\n"

"DUE:20010316T000000Z\r\n"

"COMPLETED:20010314T000000Z\r\n"

//"RRULE:\r\n" Standard leave

"RRULE:D1 #0\r\n"

"RRULE:MD1 10+ #0\r\n"

"RRULE:MP1 2+ MO #0\r\n"

"RRULE:MP12 2+ MO #0\r\n"

"RRULE:W1 MO #0\r\n"

"RRULE:YM1 1 #0\r\n"

"RRULE:W2 SU TU TH SA 19991130T000000\r\n"

"RRULE:M1 19990821T000000\r\n" //invalid format from 9110

"CLASS:PUBLIC\r\n"

//"PRIORITY:\r\n" KErrNotFound

"PRIORITY:9\r\n"

"DCREATED:20000113T000000Z\r\n"

"LAST-MODIFIED:20000113T122400Z\r\n"

"UID:28\r\n"

"PRODID:-//Microsoft Corporation//Outlook 9.0 MIMEDIR//EN\r\n"

"TRANSP:1\r\n"

"END:VTODO\r\n"

"END:VCALENDAR\r\n");

_LIT8(KVCardAllMandatoryProperties,

"BEGIN:VCARD\r\n"

"VERSION:2.1\r\n"

"REV:20010608T125751Z\r\n"

"TEL;CAR:\r\n"

"TEL;HOME;VOICE:\r\n"

"TEL;WORK;VOICE:\r\n"

"N:Contact;Starfish;;\r\n"

"NOTE:\r\n"

"TEL;PAGER:\r\n"

//"BDAY:\r\n" standard leave

"ADR;WORK:;;;;;;\r\n"

"ADR;HOME:;;;;;;\r\n"

"URL:\r\n"

"TEL;CELL:\r\n"

"TEL;FAX;HOME:\r\n"

"ORG:\r\n"

"EMAIL;INTERNET:\r\n"

"TEL;FAX;WORK:\r\n"

"END:VCARD\r\n");

_LIT(KVCalImportFileName,"c:\\oomvcal.vcs");

_LIT(KVCalExportFileName,"c:\\oomvcal2.vcs");

_LIT(KVCardImportFileName,"c:\\oomvcard.vcf");

_LIT(KVCardExportFileName,"c:\\oomvcard2.vcf");

/** Defines an interface for Versit OOM tests */

class MVersitOOMTest 

	{

public:

	virtual void DoTestL() = 0;

	};

/** versit alarm creation OOM test */

class CVersitAlarmCreateTest: public CBase, public MVersitOOMTest

	{

public:

	static CVersitAlarmCreateTest* NewLC();

	~CVersitAlarmCreateTest();

public: //From MVersitOOMTest

	void DoTestL();

private:

	CVersitAlarmCreateTest();

	};

/** vCalendar import OOM test */

class CVersitVCalImportTest : public CBase, public MVersitOOMTest

	{

public:

	static CVersitVCalImportTest* NewLC();

	~CVersitVCalImportTest();

public: //From MVersitOOMTest

	void DoTestL();

private:

	void CheckingImportResultL(CParserVCal& aVCalParser);

	CVersitVCalImportTest();

	};

/** vCalendar export OOM test */

class CVersitVCalExportTest : public CBase, public MVersitOOMTest

	{

public:

	static CVersitVCalExportTest* NewLC();

	~CVersitVCalExportTest();

public: //From MVersitOOMTest

	void DoTestL();

private:

	CVersitVCalExportTest();

	};

/** vCard import OOM test */

class CVersitVCardImportTest : public CBase, public MVersitOOMTest

	{

public:

	static CVersitVCardImportTest* NewLC();

	~CVersitVCardImportTest();

public: //From MVersitOOMTest

	void DoTestL();

private:

	CVersitVCardImportTest();

	};

/** vCard export OOM test */

class CVersitVCardExportTest : public CBase, public MVersitOOMTest

	{

public:

	static CVersitVCardExportTest* NewLC();

	~CVersitVCardExportTest();

public: //From MVersitOOMTest

	void DoTestL();

private:

	CVersitVCardExportTest();

	};

// Cleanup callback for versit entities.

GLREF_C void ResetAndDestroyArrayOfEntities(TAny* aObject)

	{

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

	if (array)

		array->ResetAndDestroy();

	delete array;

	}

CVersitAlarmCreateTest* CVersitAlarmCreateTest::NewLC()

	{

	CVersitAlarmCreateTest* self = new(ELeave) CVersitAlarmCreateTest;

	CleanupStack::PushL(self);

	return self;	

	}

void CVersitAlarmCreateTest::DoTestL()

	{

	TDateTime date(2001,ENovember,1,0,15,0,0);

	TVersitDateTime* runtime = new(ELeave) TVersitDateTime(date, TVersitDateTime::EIsMachineLocal);

	CleanupStack::PushL(runtime);

	CVersitAlarm* alarm = CVersitAlarm::NewL(runtime,0,0,_L("Fanfare"),KNullDesC);

	CleanupStack::Pop(runtime);

	delete alarm;

	}

CVersitAlarmCreateTest::~CVersitAlarmCreateTest()

	{

	}

CVersitAlarmCreateTest::CVersitAlarmCreateTest()

	{

	}

CVersitVCalImportTest* CVersitVCalImportTest::NewLC()

	{

	CVersitVCalImportTest* self = new(ELeave) CVersitVCalImportTest;

	CleanupStack::PushL(self);

	return self;

	}

void CVersitVCalImportTest::DoTestL()

	{

	CParserVCal* parser = CParserVCal::NewL();

	CleanupStack::PushL(parser);

	RFile infile;

	User::LeaveIfError(infile.Open(fs,KVCalImportFileName,EFileRead));

	CleanupClosePushL(infile);

	RFileReadStream readStream(infile);

	CleanupClosePushL(readStream);

	parser->InternalizeL(readStream);

	CheckingImportResultL(*parser);

	CleanupStack::PopAndDestroy(3);

	}

void CVersitVCalImportTest::CheckingImportResultL(CParserVCal& aVCalParser)

	{

	//Test get entities and properties without taking ownership

	CArrayPtr<CVersitParser>* entities = aVCalParser.EntityL(KVersitVarTokenVTODO,EFalse);	

	test(entities != NULL);

	CleanupStack::PushL(entities);

	CArrayPtr<CParserProperty>* properties = (*entities)[0]->PropertyL(KVersitTokenRRULE, TUid::Uid(KVCalPropertyRecurrenceUid), EFalse);

	test(properties != NULL);

	delete properties;

	CleanupStack::PopAndDestroy(entities);

	//Test get entities and properties with taking ownership

	entities = aVCalParser.EntityL(KVersitVarTokenVEVENT,ETrue);

	test(entities != NULL);

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfEntities, entities));

	properties = (*entities)[0]->PropertyL(KVersitTokenCATEGORIES, TUid::Uid(KVersitPropertyCDesCArrayUid), ETrue);

	test(properties != NULL);

	properties->ResetAndDestroy();

	delete properties;

	CleanupStack::PopAndDestroy(entities);

	}

CVersitVCalImportTest::CVersitVCalImportTest()

	{

	}

CVersitVCalImportTest::~CVersitVCalImportTest()

	{

	}

CVersitVCalExportTest* CVersitVCalExportTest::NewLC()

	{

	CVersitVCalExportTest* self = new(ELeave) CVersitVCalExportTest;

	CleanupStack::PushL(self);

	return self;

	}

CVersitVCalExportTest::~CVersitVCalExportTest()

	{

	}

void CVersitVCalExportTest::DoTestL()

	{

	CParserVCal* parser = CParserVCal::NewL();

	CleanupStack::PushL(parser);

	CParserVCalEntity* entity =  CParserVCalEntity::NewL();	

	CleanupStack::PushL(entity);

	entity->SetEntityNameL(KVersitVarTokenVEVENT);

	TInt KUidValue=0;

	CParserPropertyValueInt* intValue= new(ELeave) CParserPropertyValueInt(KUidValue);

	CleanupStack::PushL(intValue);

	CParserProperty* UIDprop = CParserProperty::NewL(*intValue, KVersitTokenUID, NULL);  

	CleanupStack::Pop(intValue);	

	entity->AddPropertyL(UIDprop);

	_LIT(KVCalDescription,"Small devices come in many shapes and sizes");

	CParserPropertyValueHBufC* hbufValue = CParserPropertyValueHBufC::NewL(KVCalDescription);

	CleanupStack::PushL(hbufValue);

	CParserProperty* DESCRIPTIONprop = CParserProperty::NewL(*hbufValue, KVersitTokenDESCRIPTION, NULL);

	CleanupStack::Pop(hbufValue);

	entity->AddPropertyL(DESCRIPTIONprop);

	CleanupStack::Pop(entity);

	parser->AddEntityL(entity);

	RFile outfile;

	User::LeaveIfError(outfile.Replace(fs,KVCardExportFileName,EFileWrite));

	CleanupClosePushL(outfile);

	RFileWriteStream writeStream(outfile);

	CleanupClosePushL(writeStream);

	parser->ExternalizeL(writeStream);

	CleanupStack::PopAndDestroy(3);

	}

CVersitVCalExportTest::CVersitVCalExportTest()

	{

	}

CVersitVCardImportTest* CVersitVCardImportTest::NewLC()

	{

	CVersitVCardImportTest* self = new(ELeave) CVersitVCardImportTest;

	CleanupStack::PushL(self);

	return self;

	}

void CVersitVCardImportTest::DoTestL()

	{

	CParserVCard* parser = CParserVCard::NewL();

	CleanupStack::PushL(parser);

	RFile infile;

	User::LeaveIfError(infile.Open(fs,KVCardImportFileName,EFileRead));

	CleanupClosePushL(infile);

	RFileReadStream readStream(infile);

	CleanupClosePushL(readStream);

	parser->InternalizeL(readStream);

	CleanupStack::PopAndDestroy(3);

	}

CVersitVCardImportTest::CVersitVCardImportTest()

	{

	}

CVersitVCardImportTest::~CVersitVCardImportTest()

	{

	}

CVersitVCardExportTest* CVersitVCardExportTest::NewLC()

	{

	CVersitVCardExportTest* self = new(ELeave) CVersitVCardExportTest;

	CleanupStack::PushL(self);

	return self;

	}

CVersitVCardExportTest::~CVersitVCardExportTest()

	{

	}

void CVersitVCardExportTest::DoTestL()

	{

	CParserVCard* parser = CParserVCard::NewL();

	CleanupStack::PushL(parser);

	TTime lastModified;

	lastModified.UniversalTime();

	TVersitDateTime* dateTime=new(ELeave)TVersitDateTime(lastModified.DateTime(),TVersitDateTime::EIsMachineLocal);

	CleanupStack::PushL(dateTime);

	CParserPropertyValueDateTime* valueDateTime=new(ELeave) CParserPropertyValueDateTime(dateTime);

	CleanupStack::Pop(dateTime);	

	CleanupStack::PushL(valueDateTime);

	CParserGroupedProperty* property=CParserGroupedProperty::NewL(*valueDateTime,KVersitTokenREV,NULL,NULL);

	CleanupStack::Pop(valueDateTime);

	parser->AddPropertyL(property);

	RFile outfile;

	User::LeaveIfError(outfile.Replace(fs,KVCalExportFileName,EFileWrite));

	CleanupClosePushL(outfile);

	RFileWriteStream writeStream(outfile);

	CleanupClosePushL(writeStream);

	parser->ExternalizeL(writeStream);

	CleanupStack::PopAndDestroy(3);

	}

CVersitVCardExportTest::CVersitVCardExportTest()

	{

	}

void runOOMTestL(MVersitOOMTest& aTest)

	{

	TInt ret=KErrNoMemory;

	TInt failAt=0;

	while (ret!=KErrNone)

		{

		failAt++;

		TBuf<200>indicator;

		indicator.Format(_L("Memory fail at \t%d\x0d\x0a"),failAt);

		if(failAt%100==0)

			test.Printf(indicator);

		__UHEAP_SETFAIL(RHeap::EDeterministic,failAt);

		__UHEAP_MARK;			

		TRAP(ret, aTest.DoTestL());

		__UHEAP_MARKEND;

		__UHEAP_RESET;

		if (ret!=KErrNoMemory&&ret!=KErrNone)

			{

			test.Printf(_L("Non standard error: %d\n"),ret);

			test.Getch();

			}

		test(ret==KErrNoMemory||ret==KErrNone);

		}

	}

LOCAL_C void ExpandCleanupStackL()

	{

	// reserve some space on the cleanup stack:

	{for (TInt ii=0;ii<1000;++ii)

		CleanupStack::PushL(&ii);}

	CleanupStack::Pop(1000);

	}

void createTestFilesL()

	{

	RFile file;

	TInt err=file.Replace(fs,KVCalImportFileName, EFileWrite+EFileShareAny+EFileStreamText);

	User::LeaveIfError(err);

	file.Write(KVCalendarAllMandatoryProperties);

	file.Close();

	err=file.Replace(fs,KVCardImportFileName, EFileWrite+EFileShareAny+EFileStreamText);

	User::LeaveIfError(err);

	file.Write(KVCardAllMandatoryProperties);

	file.Close();

	}

/**

@SYMTestCaseID PIM-TOOM-0001

*/	

void runOOMTestsL()

	{

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

	CleanupClosePushL(fs);	

	CTestRegister* TempFiles = CTestRegister::NewLC();

	TempFiles->RegisterL(KVCalImportFileName);

	TempFiles->RegisterL(KVCalExportFileName);

	TempFiles->RegisterL(KVCardImportFileName);

	TempFiles->RegisterL(KVCardExportFileName);

	test.Start(_L("@SYMTestCaseID PIM-TOOM-0001 Test One"));

	createTestFilesL();

	ExpandCleanupStackL();

	_LIT(KTestvCalImport,"vCal Import Test\n");

	test.Printf(KTestvCalImport);

	CVersitVCalImportTest* oomtest1 = CVersitVCalImportTest::NewLC();

	runOOMTestL(*oomtest1);

	CleanupStack::PopAndDestroy(oomtest1);

	_LIT(KTestvCardImport,"vCard Import Test\n");

	test.Printf(KTestvCardImport);

	CVersitVCardImportTest* oomtest2 = CVersitVCardImportTest::NewLC();

	runOOMTestL(*oomtest2);

	CleanupStack::PopAndDestroy(oomtest2);

	_LIT(KTestvCalExport,"vCal Export Test\n");

	test.Printf(KTestvCalExport);

	CVersitVCalExportTest* oomtest3 = CVersitVCalExportTest::NewLC();

	runOOMTestL(*oomtest3);

	CleanupStack::PopAndDestroy(oomtest3);

	_LIT(KTestvCardExport,"vCard Export Test\n");

	test.Printf(KTestvCardExport);

	CVersitVCardExportTest* oomtest4 = CVersitVCardExportTest::NewLC();

	runOOMTestL(*oomtest4);

	CleanupStack::PopAndDestroy(oomtest4);

	_LIT(KTestVersitAlarm,"Versit Alarm OOM Test\n");

	test.Printf(KTestVersitAlarm);

	CVersitAlarmCreateTest* oomtest5 = CVersitAlarmCreateTest::NewLC();

	runOOMTestL(*oomtest5);

	CleanupStack::PopAndDestroy(oomtest5);

	test.End();

	test.Close();

	CleanupStack::PopAndDestroy(2); // TempFiles, fs

	}

GLDEF_C TInt E32Main()

	{	

	TTime startTime;

	startTime.UniversalTime();

	__UHEAP_MARK;

	CTrapCleanup* theCleanup=CTrapCleanup::New();

	TRAPD(ret,runOOMTestsL());

	test(ret==KErrNone);

	delete theCleanup;	

	__UHEAP_MARKEND;

	TTime finishTime;

	finishTime.UniversalTime();

	TReal elapsed = (TReal)finishTime.MicroSecondsFrom(startTime).Int64();

	test.Printf(_L("Elapsed time: %.4f\n"), elapsed/1000000);

	return(KErrNone);

	}