// Copyright (c) 1996-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\manager\t_oom.cpp

 // 

 //

 #include <hal.h>

 #include <f32file.h>

 #include <e32test.h>

 #include "../server/t_server.h"

 GLDEF_D RTest test(_L("T_OOM"));

 LOCAL_C void FormatFat()

 //

 // Call all RFormat methods

 //

 	{

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

 	RFormat format;

 	TFileName sessionPath;

 	TInt r=TheFs.SessionPath(sessionPath);

 	test(r==KErrNone);

 	TInt count;

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

 	test(r==KErrNone);

 //	test(count==100);

 //	TRequestStatus status;

 //	TPckgBuf<TInt> step;

 //	do 	{

 //		format.Next(step,status);

 //		User::WaitForRequest(status);

 //		test(status==KErrNone);

 //	} while (step()<count);

 //	test(step()==count);

 	const TInt total(count);

 	while (count && r == KErrNone)

 		{

 		test((r = format.Next(count)) == KErrNone);

 		test.Printf(_L("\r%d/%d"), count, total);

 		}

 	test.Printf(_L("\n"));

 	format.Close();

 	}

 LOCAL_C void Test1()

 //

 // Test openning a large file

 //

 	{

 	test.Next(_L("Create a file GOBBLE.DAT"));

 	TUint size=0x340000; // 3.25MB

 	test.Printf(_L("FileSize = 0x%x\n"),size);

 	RFile file;

 	TInt r=file.Replace(TheFs,_L("\\F32-TST\\GOBBLE.DAT"),EFileRead);

 	test(r==KErrNone);

 	r=file.SetSize(size);

 	test(r==KErrNone || r==KErrDiskFull);

 	if (r==KErrDiskFull)

 		{

 		TFileName sessionPath;

 		r=TheFs.SessionPath(sessionPath);

 		test(r==KErrNone);

 		test.Printf(_L("Error %S diskfull\n"),&sessionPath);

 // Reintroduce when we can detect that the test is being run manually

 //		test.Getch();

 		}

 	file.Close();

 	}

 /** if internal RAM drive has a defined limit, test cannot be exceeded */

 LOCAL_C void TestRAMDriveLimit()

 	{

 	test.Start(_L("TestRAMDriveLimit"));

 	TInt r;										// error code

 	for (TInt d = EDriveA; d <= EDriveZ; ++d)

 		{

 		TDriveInfo di;

 		test((r = TheFs.Drive(di, d)) == KErrNone);

 		TInt maxRam;

 		if (di.iType == EMediaRam && HAL::Get(HAL::EMaxRAMDriveSize, maxRam) == KErrNone)

 			{

 #ifdef __WINS__									// c: not EMediaRam on WINS

 			if (d != EDriveY)

 				continue;

 #endif

 			test.Printf(_L("Testing RAM drive limit %08x on drive %x\n"), maxRam, d);

 			// create lots of files and check KErrDiskFull after right number

 			const TInt KFileSize = 16 * 1024;

 			_LIT(KDrvTmp, "?:\\");				// set session path to limited drive

 			TBuf<3> bfDrv(KDrvTmp);

 			TChar ch;

 			test(RFs::DriveToChar(d, ch) == KErrNone);

 			bfDrv[0] = static_cast<TText>(ch);

 			test.Printf(_L("Setting session path to \"%S\".\n"), &bfDrv);

 			test(TheFs.SetSessionPath(bfDrv) == KErrNone);

 			FormatFat();						// remove all current files from drive

 			TBuf<3 + 2> bfDir;					// subdir to avoid root KErrDirFull

 			bfDir.Append(bfDrv);

 			_LIT(KTstDir, "t\\");

 			bfDir.Append(KTstDir);

 			test.Printf(_L("creating directory \"%S\".\n"), &bfDir);

 			r = TheFs.MkDir(bfDir);

 			test(r == KErrNone);

 			TBuf<3 + 3 + 8 + 1 + 3> bfFlNm(bfDir);

 			TInt ctr = 0;						// create files until KErrDiskFull

 			do

 				{

 				bfFlNm.SetLength(bfDir.Length());

 				bfFlNm.AppendFormat(_L("%08x.dat"), ctr);

 				test.Printf(

 					_L("\rcreating %S @ %08x (total %08x)"),

 					&bfFlNm, KFileSize, ctr * KFileSize);

 				RFile f;

 				r = f.Create(TheFs, bfFlNm, EFileShareExclusive | EFileStream | EFileWrite);

 				test(r == KErrNone || r == KErrDiskFull);

 				if (r == KErrNone)

 					{

 					r = f.SetSize(KFileSize);

 					test(r == KErrNone || r == KErrDiskFull);

 					}

 				f.Close();

 				++ctr;

 				} while (r != KErrDiskFull);

 			test.Printf(_L("\n"));

 			// new file takes KFileSize, any possibly metadata cluster

 			TVolumeInfo vi;

 			test(TheFs.Volume(vi, d) == KErrNone);

 			test(vi.iSize < maxRam);			// vi.iSize does not include FAT

 			test(vi.iFree < 2 * KFileSize);

 			FormatFat();

 			// create single file and set to > maxRam

 			RFile fS;

 			_LIT(bfFlNmS, "00000000.dat");

 			test(fS.Create(TheFs, bfFlNmS, EFileShareExclusive | EFileStream | EFileWrite) == KErrNone);

 			test(fS.SetSize(maxRam) == KErrDiskFull);

 			fS.Close();

 			}

 		}	// for (TInt d = EDriveA; d <= EDriveZ; ++d)

 	test.End();

 	}

 GLDEF_C void CallTestsL()

 //

 // Call all tests

 //

 	{

 	test.Title();

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

 	TDriveInfo driveInfo;

 	TInt r=TheFs.Drive(driveInfo);

 	test(r==KErrNone);

 	if (driveInfo.iType==EMediaNotPresent)

 		{

 		test.Printf(_L("ERROR: MEDIA NOT PRESENT\n"));

 // Reintroduce when we can detect that the test is being run manually

 //		test.Getch();

 		return;

 		}

 	TFileName sessionPath;

 	r=TheFs.SessionPath(sessionPath);

 	test(r==KErrNone);

 	r=TheFs.MkDirAll(sessionPath);

 	test(r==KErrCorrupt || r==KErrAlreadyExists || r==KErrNone);

 	if (r==KErrCorrupt)

 		FormatFat();

 	if (r==KErrAlreadyExists)

 		{

 		test.Next(_L("Remove test directory"));

 		CFileMan* fman=CFileMan::NewL(TheFs);

 		TInt ret=fman->RmDir(sessionPath);

 		test(ret==KErrNone);

 		delete fman;

 		}

 	if (r!=KErrNone)

 		{

 		r=TheFs.MkDirAll(sessionPath);

 		test(r==KErrNone);

 		}

 	Test1();

 	TestRAMDriveLimit();

 	test.End();

 	test.Close();

 	}