// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// f32test\fsstress\t_rmain.cpp

// 

//

#if !defined(__F32FILE_H__)

#include <f32file.h>

#endif

#if !defined(__E32TEST_H__)

#define	__E32TEST_EXTENSION__

#include <e32test.h>

#endif

#if !defined(__E32HAL_H__)

#include <e32hal.h>

#endif

#if !defined(__E32MATH_H__)

#include <e32math.h>

#endif

#if !defined(__F32DBG_H__)

#include <f32dbg.h>

#endif

#include "t_std.h"

GLDEF_D	RFs TheFs;

GLDEF_D TFileName gSessionPath;

GLDEF_D TInt gAllocFailOff=KAllocFailureOff;

GLDEF_D TInt gAllocFailOn=KAllocFailureOff;

GLDEF_D TInt64 gSeed=51703;

const TInt KHeapSize=0x2000;

GLDEF_C void TurnAllocFailureOff()

//

// Switch off all allocFailure

//

	{

	test.Printf(_L("Disable Alloc Failure\n"));

	TheFs.SetAllocFailure(gAllocFailOff);

	gAllocFailOn=KAllocFailureOff;

	}

GLDEF_C void TurnAllocFailureOn()

//

// Switch off all allocFailure

//

	{

	test.Printf(_L("Enable Alloc Failure\n"));

	gAllocFailOn=KAllocFailureOn; 

	TheFs.SetAllocFailure(gAllocFailOn);

	}

GLDEF_C void Format(TInt aDrive)

//

// Format current drive

//

	{

	test.Next(_L("Format"));

	TBuf<4> driveBuf=_L("?:\\");

	driveBuf[0]=(TText)(aDrive+'A');

	RFormat format;

	TInt count;

	TInt r=format.Open(TheFs,driveBuf,EHighDensity,count);

	test_KErrNone(r);

	while(count)

		{

		TInt r=format.Next(count);

		test_KErrNone(r);

		}

	format.Close();

	}

LOCAL_C void PushLotsL()

//

// Expand the cleanup stack

//

	{

	TInt i;

	for(i=0;i<1000;i++)

		CleanupStack::PushL((CBase*)NULL);

	CleanupStack::Pop(1000);

	}

LOCAL_C void DoTests(TInt aDrive)

//

// Do testing on aDrive

//

	{

	gSessionPath=_L("?:\\F32-TST\\");

	TChar driveLetter;

	TInt r=TheFs.DriveToChar(aDrive,driveLetter);

	test_KErrNone(r);

	gSessionPath[0]=(TText)driveLetter;

	r=TheFs.SetSessionPath(gSessionPath);

	test_KErrNone(r);

	r=TheFs.MkDirAll(gSessionPath);

	test_Value(r, r == KErrNone || r==KErrAlreadyExists);

	TheFs.ResourceCountMarkStart();

	switch(aDrive)

		{

#if defined (__MARM__)

	case EDriveC:

		TRAP(r,CallTestsYL(aDrive));

		break;

	case EDriveD:

		TRAP(r,CallTestsXL(aDrive));

		break;

#else

	case EDriveX:

		TRAP(r,CallTestsXL(aDrive));

		break;

	case EDriveY:

		TRAP(r,CallTestsYL(aDrive));

		break;

#endif

	case EDriveQ:

		TRAP(r,CallTestsQL(aDrive));

		break;

	default:

		TRAP(r,CallTestsDefaultL(aDrive));	

		break;

		}

	if (r==KErrNone)

		TheFs.ResourceCountMarkEnd();

	else

		{

		test.Printf(_L("Error: Leave %d\n"),r);

		test.Getch();

		}

	}

LOCAL_C TInt TestXDrive(TAny * /*anArg*/)

//

//	MARM CF card drive testing (WINS emulates CF card on X)

//

	{

	CTrapCleanup* cleanup;

	cleanup=CTrapCleanup::New();

	testx.Title();

	TInt r=TheFs.Connect();

	testx(r==KErrNone);

//	TheFs.SetAllocFailure(gAllocFailOn);

#if defined (__WINS__)

//	Run tests on WINS drive X:	

	testx.Start(_L("Starting tests on drive X:"));

	DoTests(EDriveX);

#elif defined (__MARM__)

//	Run tests on MARM drive D:

	testx.Start(_L("Starting tests on drive D:"));

	DoTests(EDriveD);

#endif

//	TheFs.SetAllocFailure(gAllocFailOff);

	delete cleanup;

	testx.End();

	return KErrNone;

	}

LOCAL_C TInt TestYDrive(TAny * /*anArg*/)

//

//	MARM RAM drive testing (WINS emulates FAT filesystem on Y)  		

//

	{

	CTrapCleanup* cleanup;

	cleanup=CTrapCleanup::New();

	testy.Title();

	TInt r=TheFs.Connect();

	testy(r==KErrNone);

//	TheFs.SetAllocFailure(gAllocFailOn);

#if defined (__WINS__)

//	Run tests on WINS drive Y:

	testy.Start(_L("Starting tests on drive Y:"));

	DoTests(EDriveY);

#elif defined (__MARM__)

//	Run tests on MARM drive C:

	testy.Start(_L("Starting tests on drive C:"));

	DoTests(EDriveC);

#endif

//	TheFs.SetAllocFailure(gAllocFailOff);	

	delete cleanup;

	testy.End();

	return KErrNone;

	}

LOCAL_C TInt TestRemoteDrive(TAny * /*anArg*/)

//

// Run tests on remote drive Q:

//

	{	

	CTrapCleanup* cleanup;

	cleanup=CTrapCleanup::New();

	testq.Title();

	testq.Start(_L("Starting async tests..."));

	TInt r=TheFs.Connect();

	testq(r==KErrNone);

//	TheFs.SetAllocFailure(gAllocFailOn);

	testq.Next(_L("Mount Remote Drive simulator on Q:"));

	r=TheFs.AddFileSystem(_L("T_REMFSY"));

	testq.Next(_L("Add remote file system"));

	testq.Printf(_L("AddFileSystem returned %d\n"),r);

//	testq(r==KErrNone || r==KErrAlreadyExists);

	r=TheFs.MountFileSystem(_L("T_REMFSY"),EDriveQ);

	testq.Next(_L("Mount remote file system"));

	testq.Printf(_L("MountFileSystem returned %d\n"),r);

	testq(r==KErrNone || r==KErrCorrupt || r==KErrNotReady || r==KErrAlreadyExists);

	if (r==KErrCorrupt || r==KErrNotReady)

		Format(EDriveQ);

	DoTests(EDriveQ);

//	TheFs.SetAllocFailure(gAllocFailOff);

	delete cleanup;

	testq.End();

	return KErrNone;

	}

GLDEF_C TInt E32Main()

//

// Test with drive nearly full

//

    {

	CTrapCleanup* cleanup;

	cleanup=CTrapCleanup::New();

	TRAPD(r,PushLotsL());

 	__UHEAP_MARK;

	test.Title();

	test.Start(_L("Starting tests..."));

	r=TheFs.Connect();

	test_KErrNone(r);

//	TheFs.SetAllocFailure(gAllocFailOn);

//	Default drive testing

	DoTests(KDefaultDrive);	

//	Remote drive testing

	RThread clientThreadQ;

	r=clientThreadQ.Create(_L("TestRemoteDrive"), TestRemoteDrive, KDefaultStackSize,KHeapSize,KHeapSize,NULL);	

	test_KErrNone(r);	

	TRequestStatus statq;

	clientThreadQ.Logon(statq);

	test.Next(_L("Resume clientThreadQ"));	

	clientThreadQ.Resume();

//	MARM CF card drive testing (WINS emulates CF card on X)

	RThread clientThreadX;

	r=clientThreadX.Create(_L("TestXDrive"), TestXDrive, KDefaultStackSize,KHeapSize,KHeapSize,NULL);	

	test_KErrNone(r);	

	TRequestStatus statx;

	clientThreadX.Logon(statx);

	test.Next(_L("Resume clientThreadX"));	

	clientThreadX.Resume();

//	MARM RAM drive testing (WINS emulates FAT filesystem on Y)  	

	RThread clientThreadY;

	r=clientThreadY.Create(_L("TestYDrive"), TestYDrive, KDefaultStackSize,KHeapSize,KHeapSize,NULL);	

	test_KErrNone(r);	

	TRequestStatus staty;

	clientThreadY.Logon(staty);

	test.Next(_L("Resume clientThreadY"));	

	clientThreadY.Resume();

	User::WaitForRequest(statx);

	User::WaitForRequest(staty);

	User::WaitForRequest(statq);

	clientThreadQ.Close();

	clientThreadX.Close();

	clientThreadY.Close();

//	TheFs.SetAllocFailure(gAllocFailOff);

	TheFs.Close();

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	delete cleanup;

	return(KErrNone);

    }