/**

*/

//#include <e32std.h>

#include <e32base.h>

#include <f32file.h>

#define TEST_SUSTAIN

TTime startTime;

TInt IdleCallBack(TAny* aParam)

	{

	static TInt count=0;

	count++;

    //Only do this on first run

	if (count==1)

		{

        startTime.HomeTime();

		//Quick file system test

		RFs fs;

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

		CleanupClosePushL(fs);

		_LIT(KFileName,"c:\\tsymc\\tsymc.txt");

		_LIT(KFileNameToCreate,"c:\\tsymc\\created.txt");

		_LIT8(KWriteThat,"Write is working too!\n");

		RFile file;

		TInt err=file.Open(fs,KFileName,EFileRead|EFileWrite);

		if (!err)

			{

			TInt size=0;

			TInt sizeErr=file.Size(size);

			if (!sizeErr)

				{

				HBufC8* content=HBufC8::NewLC(size);

				TPtr8 ptr=content->Des();

				TInt readErr=file.Read(ptr,size);

				CleanupStack::PopAndDestroy(1,content);

				//file.Close();

				}

			//Test write

			TInt writeErr=file.Write(KWriteThat);

			file.Close();

			}

		//Test file creation

		TInt createErr=file.Create(fs,KFileNameToCreate,EFileWrite);

		if (!createErr)

			{

			TInt writeErr=file.Write(KWriteThat);

			file.Close();

			}

		CleanupStack::PopAndDestroy(1,&fs);

		}

    //Check our exit condition

    TTime time;

    time.HomeTime();

    TTimeIntervalSeconds seconds;

    User::LeaveIfError(time.SecondsFrom(startTime,seconds));

    //Just run for a few seconds

    if (seconds.Int()>5)

    {

        //Stop it there

        CActiveScheduler::Stop();

        return EFalse;

    }

	//Keep playing

	return ETrue;

	}

class CBaseTest: public CBase

	{

	};

GLDEF_C void MainL()

	{

   //Testing CBase object

	CBase* other=new(ELeave) CBase();

	CleanupStack::PushL(other);

	CBase* base=new(ELeave) CBase();

	CleanupStack::PushL(base);

	CleanupStack::PopAndDestroy(2,other);

	//delete base;

	//Testing cleanup stack

	TRAPD(err,

	base=new(ELeave) CBase();

	CleanupStack::PushL(base);

	User::Leave(KErrCancel);

	);

	ASSERT(err==KErrCancel);

	//Testing alloc failure

   //See TProcess

	TRAP(err,

	TUint8* shouldFail=new(ELeave) TUint8[1024*1024*10];

	delete[] shouldFail;

	);

   //

	ASSERT(err==KErrNoMemory);

   //Testing alloc failure without leave

   TUint8* tooLarge=new TUint8[1024*1024*10];

   ASSERT(tooLarge==NULL);

   delete[] tooLarge;

   //Testing simple alloc of T class

   TUint8* tinyAlloc=new TUint8;

   ASSERT(tinyAlloc!=NULL);

   delete tinyAlloc;

   //TODO:

   //RHashSet<TUint32> hash;

   //Testing AOs

   //Install an active scheduler

   CActiveScheduler* activeScheduler = new(ELeave) CActiveScheduler;

   CActiveScheduler::Install(activeScheduler);

   CleanupStack::PushL(activeScheduler);

   CIdle* idle = CIdle::NewL(CActive::EPriorityIdle);

   CleanupStack::PushL(idle);

   idle->Start(TCallBack(IdleCallBack,NULL));

   CActiveScheduler::Start();

   CleanupStack::PopAndDestroy(idle);

   CActiveScheduler::Install(NULL);

   CleanupStack::PopAndDestroy(activeScheduler);

	//Testing unbalanced cleanup stack

	//base=new(ELeave) CBase();

	//CleanupStack::PushL(base);

	}

GLDEF_C TInt E32Main()

	{

	//What do we do then

	//SetReturnedHandle

	__UHEAP_MARK;

	//CBase* base=new(ELeave) CBase();

	CBase* base=new CBase();

	delete base;

	CBaseTest* baseTest=new CBaseTest();

	delete baseTest;

	HBufC* buf=HBufC::New(10);

	delete buf;

	CArrayFix<TInt>* active=new CArrayFixFlat<TInt>(10);

	delete active;

	TUint8* test=new TUint8[1024*9];

	delete[] test;

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if (!cleanupStack)

		{

		return KErrNoMemory;

		}

	TInt err=KErrNone;

	TRAP(err,MainL());

	delete cleanupStack;

	__UHEAP_MARKEND;

	return err;

	}