// Copyright (c) 2002-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:

 //

 //! @file f32test\concur\t_csfsoak.cpp

 #include <f32file.h>

 #include <e32test.h>

 #include <e32math.h>

 #include <f32dbg.h>

 #include "t_server.h"

 #include "t_chlffs.h"

 #include "t_tdebug.h"

 #include "t_cfssoak.h"

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

 GLDEF_D	RFs TheFs;

 GLREF_D TPtrC gArgV[];

 GLREF_D TInt  gArgC;

 LOCAL_D TFullName gFsName;

 LOCAL_D TFullName gFsName1;

 LOCAL_D TFullName gFsName2;

 LOCAL_D TFullName gOldFsName;

 LOCAL_D TFullName gNewFsName;

 LOCAL_D TBool     gNoMedia = ETrue;

 _LIT(KFsFile,   "CFAFSDLY");

 _LIT(KFsName,   "DelayFS");

 LOCAL_D const TInt32 KSecond = 1000000;

 LOCAL_D TChar gRemFsChr = 0;

 LOCAL_D TInt  gRemFsDrv = 0;

 LOCAL_D TChar gDrvChFill = 0;

 LOCAL_D TInt  gNumRead = 0;

 LOCAL_D TInt  gNumFill = 0;

 LOCAL_D TInt  gNumRem  = 0;

 GLDEF_D TExtension gPrimaryExtensions[KMaxDrives];

 inline void TraceError(const char* aFile, TInt aLine, const TDesC& aStr, TInt aRsp)

 //

 // 'Helper' routine to output the file and line of an error as well as a string

 // and a response value.

 //

     {

     TBuf<256> fbuf;

     TPtrC8    fptr((const TUint8*)aFile);

     fbuf.Copy(fptr);

     RDebug::Print(_L("%S:%d  %S: r = %d"), &fbuf, aLine, &aStr, aRsp);

     }

 #define TESTSTR(r,s,cond) if (!(cond)) { TraceError(__FILE__, __LINE__, (s), (r)); test(0); }

 #define TESTLIT(r,s,cond) { _LIT(KStr,s); TESTSTR(r,KStr,cond); }

 #define TESTRES(r,cond)   TESTLIT(r,"ERROR",cond)

 LOCAL_C TChar MountTestFileSystem(TInt aDrive)

 ///

 /// Mount a new CTestFileSystem on the drive under test.

 /// @param aDrive Drive number (EDriveC etc.) to be used.

 ///

 	{

 	TInt r;

 	// Check attributes

 	TBuf<64> b;

 	TChar c;

 	r=TheFs.DriveToChar(aDrive,c);

 	TESTLIT(r, "TheFs.DriveToChar", r==KErrNone);

 	b.Format(_L("Mount test file system on %c:"),(TUint)c);

 	test.Next(b);

 	r=TheFs.AddFileSystem(KFsFile);

 	TESTLIT(r, "TheFs.AddFileSystem", r==KErrNone || r==KErrAlreadyExists);

 	r=TheFs.FileSystemName(gOldFsName,aDrive);

 	TESTLIT(r, "TheFs.FileSystemName", r==KErrNone || r==KErrNotFound);

 	TDriveInfo drv;

 	r = TheFs.Drive(drv, gRemFsDrv);

 	TESTLIT(r, "Drive()", r == KErrNone);

 	gNoMedia = (drv.iType == EMediaUnknown || drv.iType == EMediaNotPresent);

 	if (gOldFsName.Length() > 0)

 		{

 		r = TheFs.ExtensionName(gPrimaryExtensions[aDrive].iName, aDrive, 0);

 		if (r == KErrNone)

 			gPrimaryExtensions[aDrive].iExists = ETrue;

 		TTest::Printf(_L("Dismount %C: %S"), (TUint)c, &gOldFsName);

 		r=TheFs.DismountFileSystem(gOldFsName,aDrive);

 		TESTLIT(r, "DismountFileSystem", r==KErrNone);

 		}

 	if (gPrimaryExtensions[aDrive].iExists == EFalse)

 		r=TheFs.MountFileSystem(KFsName,aDrive);

 	else

 		r=TheFs.MountFileSystem(KFsName,gPrimaryExtensions[aDrive].iName,aDrive);

 	TESTLIT(r, "TheFs.MountFileSystem", r==KErrNone);

 	r=TheFs.FileSystemName(gNewFsName,aDrive);

 	TESTLIT(r, "TheFs.FileSystemName", r==KErrNone);

 	r = gNewFsName.CompareF(KFsName);

 	TESTLIT(r, "gNewFsName.Compare", r==0);

 	return c;

 	}

 LOCAL_C void UnmountFileSystem(TInt aDrive)

 ///

 /// Dismount the filesystem and remount the original one.

 /// @param aDrive Drive number (EDriveC etc.) to be unmounted.

 ///

 	{

 	TChar c;

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

 	TESTLIT(r, "TheFs.DriveToChar", r==KErrNone);

 	r=TheFs.DismountFileSystem(gNewFsName,aDrive);

 	TESTLIT(r, "TheFs.DismountFileSystem", r==KErrNone);

 	if (gNoMedia)

 		{

 		TTest::Printf(_L("No media on %C: so don't remount it"), (TUint)c);

 		}

 	else if (gOldFsName.Length() > 0)

 		{

 		TTest::Printf(_L("Mount    %C: %S"), (TUint)c, &gOldFsName);

 		if (gPrimaryExtensions[aDrive].iExists == EFalse)

 			r=TheFs.MountFileSystem(gOldFsName,aDrive);

 		else

 			r=TheFs.MountFileSystem(gOldFsName,gPrimaryExtensions[aDrive].iName,aDrive);

 		TESTLIT(r, "MountFileSystem", r==KErrNone);

 		}

 	}

 LOCAL_C TInt testReadOnly(TAny* /*aData*/)

 ///

 /// Task to test read-only operations.

 ///

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	TSoakReadOnly rdonly;

 	TInt64 seed = 178543;

 	TInt r = KErrNone;

 	rdonly.ExcludeDrive(gRemFsDrv);

 	while (r == KErrNone)

 		{

 		r = rdonly.ScanDrives(ETrue, Math::Rand(seed) % 90 + 10);

 		TTest::PrintLock();

 		TTest::Printf();

 		TTest::Printf(_L("Read-only test results:\n"));

 		TSoakStats::Print();

 		rdonly.iDrives.Print(_L("Drives:"));

 		rdonly.iDirs.Print(_L("Dirs:"));

 		rdonly.iFiles.Print(_L("Files:"));

 		rdonly.iReads.Print(_L("Reads:"));

 		TTest::Printf();

 		TTest::PrintUnlock();

 		gNumRead++;

 		}

 	delete cleanup;

 	TTest::Fail(HERE, r, _L("ScanDrives error"));

 	return r;

 	}

 LOCAL_C TInt testFillEmpty(TAny* /*aData*/)

 ///

 /// Task to repeatedly fill and clean a drive.

 ///

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	TVolumeInfo info;

 	TFullName   gFsName;

 	TChar  drvch = 0;

 	TInt   drive = 0;

 	TInt64 free = 0;

 	RFs    fs;

 	TInt   r = fs.Connect();

 	if (r != KErrNone)

 		TTest::Fail(HERE, r, _L("can't connect to fileserver\n"));

 	if (gDrvChFill)

 		{

 		// User specified the drive, so use that explicitly

 		drvch = gDrvChFill;

 		}

 	else

 		{

 		// User didn't specify the drive, so scan through them looking for

 		// likely candidates.  Don't use ROM or RAM drives, or LFFS ones, or

 		// our own 'slow' file system.  Out of what's left, look for the one

 		// with the least (but non-zero) free space.

 		for (drive = EDriveA; drive <= EDriveZ; drive++)

 			{

 			if (drive != gRemFsDrv)

 				{

 				TDriveInfo d;

 				TInt r;

 				r = fs.Drive(d, drive);

 				if (r == KErrNone && d.iDriveAtt != 0 &&

 					!(d.iDriveAtt & KDriveAttRom) &&

 					d.iMediaAtt != EMediaRam &&

 					!IsFileSystemLFFS(fs, drive))

 					{

 					r = fs.Volume(info, drive);

 					if (r == KErrNone)

 						{

 						if (free <= 0 || info.iFree < free)

 							{

 							r = fs.DriveToChar(drive, drvch);

 							if (r != KErrNone)

 								TTest::Fail(HERE, r, _L("DriveToChar(%d)"), drive);

 							free = info.iFree;

 							}

 						}

 					else

 						{

 						// not interested in drives which produce errors, they

 						// probably don't really exist.

 						}

 					}

 				else

 					{

 					// Drive doesn't exist, is a ROM drive or an LFFS drive, don't

 					// use it.

 					}

 				}

 			}

 		}

 	// If no drive found, can't do fill test so fail.

 	if (drvch == 0)

 		{

 		TTest::Fail(HERE, _L("No drive found for fill test!"));

 		}

 	r = fs.CharToDrive(drvch, drive);

 	if (r != KErrNone)

 		TTest::Fail(HERE, r, _L("CharToDrive(%C:)\n"), (TUint)drvch);

 	r = fs.FileSystemName(gFsName, drive);

 	if (r != KErrNone)

 		TTest::Fail(HERE, r, _L("FileSystemName(%C:)\n"), (TUint)drvch);

 	r = fs.Volume(info, drive);

 	if (r != KErrNone)

 		TTest::Fail(HERE, r, _L("Volume(%C:)\n"), (TUint)drvch);

 	fs.Close();

 	TTest::Printf(_L("Using %C: (%S) with %d KB free for fill/clean cycle test\n"),

 		          (TUint)drvch, &gFsName, I64LOW(info.iFree / 1024));

 	TSoakFill fill;

 	r = fill.SetDrive(drvch);

 	if (r != KErrNone)

 		TTest::Fail(HERE, r, _L("Unable to setup drive %C"), (TUint)drvch);

 	r = fill.CleanDrive();

 	if (r != KErrNone && r != KErrNotFound && r != KErrPathNotFound)

 		TTest::Fail(HERE, r, _L("Error cleaning drive %C"), (TUint)drvch);

 	// Loop to do the actual test

 	while (r == KErrNone)

 		{

 		r = fill.FillDrive();

 		if (r != KErrNone && r != KErrDiskFull)

 			TTest::Fail(HERE, r, _L("Error filling drive %C"), (TUint)drvch);

 		TTest::PrintLock();

 		TTest::Printf(_L("%C: filled\n"), (TUint)drvch);

 		TTest::PrintUnlock();

 		r = fill.CleanDrive();

 		if (r == KErrPathNotFound)

 			r = KErrNone;

 		if (r != KErrNone)

 			TTest::Fail(HERE, r, _L("cleaning drive %C"), (TUint)drvch);

 		TTest::PrintLock();

 		TTest::Printf(_L("%C: cleaned\n"), (TUint)drvch);

 		TTest::PrintUnlock();

 		gNumFill++;

 		}

 	delete cleanup;

 	TTest::Fail(HERE, r, _L("Fill/clean error"));

 	return r;

 	}

 LOCAL_C TInt testRemote(TAny* /*aData*/)

 ///

 /// Task to exercise the remote (special) filesystem.

 ///

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	TSoakRemote rem(gRemFsChr);

 	TInt r = KErrNone;

 	for (TBool sync = EFalse; r == KErrNone; sync = !sync)

 		{

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

 			{

 			rem.Remount(sync);

 			r = rem.TestSession();

 			if (r != KErrNone)

 				TTest::Fail(HERE, r, _L("TestSession failed"));

 			r = rem.TestSubSession();

 			if (r != KErrNone)

 				TTest::Fail(HERE, r, _L("TestSubSession failed"));

 			r = rem.TestMount();

 			if (r != KErrNone)

 				TTest::Fail(HERE, r, _L("Mount/dismount failed"));

 			User::After(100*1000000);

 			gNumRem++;

 			}

 		}

 	delete cleanup;

 	TTest::Fail(HERE, r, _L("Test (remote) filesystem error"));

 	return r;

 	}

 GLDEF_C void CallTestsL()

 ///

 /// Do all tests.

 ///

 	{

 	// first thing, initialise local test class to make sure it gets done.

 	TInt r = TTest::Init();

 	test(r == KErrNone);

     const TInt KMaxArgs = 4;

     TPtrC argv[KMaxArgs];

     TInt  argc = TTest::ParseCommandArguments(argv, KMaxArgs);

 	gRemFsChr = 'M'; // probably a 'safe' drive

 	gDrvChFill = 0;

 	if (argc > 1)

 		gRemFsChr = User::UpperCase(argv[1][0]);

 	if (argc > 2)

 		gDrvChFill = User::UpperCase(argv[2][0]);

 	r = TheFs.CharToDrive(gRemFsChr, gRemFsDrv);

 	if (r != KErrNone || gRemFsDrv == EDriveZ)

 		{

 		test.Printf(_L("Test cannnot run on drive %C:\n"), (TUint)gRemFsChr);

 		return;

 		}

 	// If we can do it, check whether the drives are LFFS and are OK

 // !!! Disable platform security tests until we get the new APIs

 /*	if (User::Capability() & KCapabilityRoot)

 		{

 		if (gDrvChFill != 0 && gDrvChFill != gRemFsChr)

 			CheckMountLFFS(TheFs, gDrvChFill);

 		}

 */

 	MountTestFileSystem(gRemFsDrv);

 	r = TTest::Create(0, testReadOnly, _L("T_ReadOnly"));

 	test(r == KErrNone);

 	r = TTest::Create(1, testFillEmpty, _L("T_FillEmpty"));

 	test(r == KErrNone);

 	r = TTest::Create(2, testRemote, _L("T_Remote"));

 	test(r == KErrNone);

 	TRequestStatus kStat;

 	test.Console()->Read(kStat);

 	TInt displaycount = 0;

 	while ((r = TTest::Run(ETrue, 1*KSecond)) == KErrNone) // run until any thread exits

 		{

 		if (++displaycount >= 60 || kStat == KErrNone)

 			{

 			test.Printf(_L("Fill %-6d Rem %-6d Read %d\n"), gNumFill, gNumRem, gNumRead);

 			displaycount = 0;

 			}

 		if (kStat == KErrNone)

 			{

 			test.Printf(_L("Aborted by user!\n"));

 			break;

 			}

 		}

 	test(r == KErrNone);

 	// Kill all outstanding threads.

 	TTest::KillAll(KErrAbort);

 	UnmountFileSystem(gRemFsDrv);

 	}

 GLDEF_C TInt E32Main()

 //

 // Main entry point

 //

     {

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

 		{

 		gPrimaryExtensions[i].iExists = EFalse;

 		}

     TInt r;

     CTrapCleanup* cleanup;

     cleanup=CTrapCleanup::New();

     __UHEAP_MARK;

     test.Title();

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

     r=TheFs.Connect();

     test(r==KErrNone);

     // TheFs.SetAllocFailure(gAllocFailOn);

     TTime timerC;

     timerC.HomeTime();

 	// Do the test

     TRAP(r,CallTestsL());

     // reset the debug register

     TheFs.SetDebugRegister(0);

     TTime endTimeC;

     endTimeC.HomeTime();

     TTimeIntervalSeconds timeTakenC;

     r=endTimeC.SecondsFrom(timerC,timeTakenC);

     test(r==KErrNone);

     test.Printf(_L("Time taken for test = %d seconds\n"),timeTakenC.Int());

     // TheFs.SetAllocFailure(gAllocFailOff);

     TheFs.Close();

     test.End();

     test.Close();

     __UHEAP_MARKEND;

     delete cleanup;

     return(KErrNone);

     }