// 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:

// f32test\server\t_csfsoakfn.cpp

// 

//

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include <f32dbg.h>

#include "t_server.h"

#include "t_tdebug.h"

#include "t_cfssoak.h"

/// Time value constants

LOCAL_D const TInt KSecond   = 1000000;

LOCAL_D const TInt KTenthSec = KSecond / 10;

/// Time to wait before session/subsession close, to allow some writes to

/// complete but not all (1 second per write with slow FS)

LOCAL_D const TInt KSessionWaitTime = 25 * KTenthSec;

/// Number of writes we expect to have completed

LOCAL_D const TInt KSessionNumEnded = KSessionWaitTime / KSecond;

GLREF_D TExtension gPrimaryExtensions[];

// -----------------------------------------------------------------

void TSoakStats::Print()

///

/// Print a statistics header.

///

	{

	TTest::Printf(_L("                    Total                Fail\n"));

	}

void TSoakStats::Print(const TDesC& aTitle)

///

/// Print the statistics for this item (title, total executed, number executed

/// this time, total failures, failures this time) then reset the "this time"

/// values.

///

	{

	TTest::Printf(_L("  %-8S %8d %+8d   %8d %+8d\n"),

				  &aTitle, iTotal, iThis, iFail, iThisF);

	iThis = 0;

	iThisF = 0;

	}

void TSoakStats::Inc()

///

/// Increment both the total and "this time" execution numbers.

///

	{

	iTotal++;

	iThis++;

	}

void TSoakStats::Fail()

///

/// Increment both the total and "this time" failure numbers.

///

	{

	iFail++;

	iThisF++;

	}

// -----------------------------------------------------------------

TSoakReadOnly::TSoakReadOnly() : iDrive(-1)

///

/// Initialise the "read only" tests, connect the file session.

///

	{

	TInt r = iFs.Connect();

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("iFs connect"));

	}

TSoakReadOnly::TSoakReadOnly(TInt aDriveCh) : iDrive(aDriveCh)

///

/// Initialise the "read only" tests, connect the file session, setting up

/// a drive to be excluded from the reading.

/// @param aDriveCh Drive letter to be excluded.

///

	{

	TInt r = iFs.Connect();

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("iFs connect"));

	}

TSoakReadOnly::~TSoakReadOnly()

///

/// Destructor -- close the file session.

///

	{

	iFs.Close();

	}

TInt TSoakReadOnly::ReadFile(const TDesC& aName, TInt aSize)

///

/// Read a file, expecting a certain size.  No check is done on the actual

/// data, just that it can be read.

/// @param aName Name of the file.

/// @param aSize Expected file size.

///

	{

	TInt r = KErrNone;

	RFile f;

	iReads.Inc();

	r = f.Open(iFs, aName, EFileStreamText);

	if (r == KErrNotFound || r == KErrPathNotFound)

		return KErrNone;

	TBuf<256> errbuf;

	if (r != KErrNone)

		{

		if (r != KErrInUse)

			{

			iFiles.Fail();

			TTest::Printf(_L("%S -- open failed %S\n"), &aName, &TTest::ErrStr(r, errbuf));

			}

		else

			TTest::Printf(_L("Warning: %S -- open failed %S\n"), &aName, &TTest::ErrStr(r, errbuf));

		return r;

		}

	TBuf8<256> buf;

	TInt len = 0;

	while ((r = f.Read(buf)) == KErrNone && buf.Length() > 0)

		len += buf.Length();

	f.Close();

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

		{

		iReads.Fail();

		TTest::Printf(_L("ERROR %S -- READ FAILED %S\n"), &aName, &TTest::ErrStr(r, errbuf));

		}

	else if (len < aSize)

		{

		iReads.Fail();

		TTest::Printf(_L("ERROR %S -- %d READ, %d EXPECTED\n"), &aName, len, aSize);

		}

	else if (len > aSize)

		TTest::Printf(_L("Warning: %S -- %d read, %d expected\n"), &aName, len, aSize);

	return r;

	}

TInt TSoakReadOnly::ScanDirs(TInt aDriveCh, TInt aReadInterval)

///

/// Scan directories on a drive, reading a selection of the files found.

/// @param aDriveCh Drive letter to be scanned.

/// @param aReadInterval Approximate number of files to be read (they are

///                      read at random, so the actual number read may be

///                      less than this number).

///

	{

	TInt r = KErrNone;

	CDirScan* scanner=NULL;

	TRAP(r, scanner=CDirScan::NewL(iFs));

	ScanDirFunc(scanner, aDriveCh, aReadInterval);

	delete scanner;

	return r;

	}

TInt TSoakReadOnly::ScanDirFunc(CDirScan* aScanner, TInt aDriveCh, TInt aReadInterval)

///

/// Scan directories on a drive, reading a selection of the files found.

/// @param aDriveCh Drive letter to be scanned.

/// @param aReadInterval Approximate number of files to be read (they are

///                      read at random, so the actual number read may be

///                      less than this number).

///

	{

	TInt r = KErrNone;

	TBuf<8> name;

	name.Format(_L("%c:\\"), aDriveCh);

	// TTest::Printf(_L("Scanning %S\n"), &name);

	TParse dirName;

	r=iFs.Parse(name, dirName);

	if (r != KErrNone)

		{

		iDrives.Fail();

		return r;

		}

	CDir* entryList = NULL;

	TInt nfiles = 0;

	TRAP(r, aScanner->SetScanDataL(dirName.FullName(),KEntryAttDir,ESortByName));

	if (r != KErrNone)

		{

		TTest::Fail(HERE, r, _L("SetScanData %S"), &dirName.FullName());

		}

	TRAP(r, aScanner->NextL(entryList));

	if (r == KErrPathNotFound)

		return KErrNone;

	if (r != KErrNone)

		{

		TTest::Fail(HERE, r, _L("Scan Next %S"), &dirName.FullName());

		}

	while (entryList)

		{

		for (TInt i = 0; i < entryList->Count(); i++)

			{

			TEntry e = (*entryList)[i];

			if (!e.IsDir())

				++nfiles;

			}

		delete entryList;

		TRAP(r, aScanner->NextL(entryList));

		if (r == KErrPathNotFound)

			break;

		if (r != KErrNone)

			{

			TTest::Fail(HERE, r, _L("Scan Next %S"), &dirName.FullName());

			}

		}

	TInt prob = (nfiles / aReadInterval) + 1;

	TRAP(r, aScanner->SetScanDataL(dirName.FullName(),KEntryAttDir,ESortByName));

	if (r == KErrPathNotFound)

		return KErrNone;

	if (r != KErrNone)

		{

		TTest::Fail(HERE, r, _L("Scan Next %S"), &dirName.FullName());

		}

	for (;;)

		{

		TRAP(r, aScanner->NextL(entryList));

		if (r == KErrPathNotFound)

			return KErrNone;

		if (r != KErrNone)

			{

			TTest::Fail(HERE, r, _L("Scan Next %S"), &dirName.FullName());

			}

		if (entryList==NULL)

			break;

		TInt count=entryList->Count();

		while (count--)

			{

			TEntry e = (*entryList)[count];

			TFileName path=aScanner->FullPath();

			path.Append(e.iName);

			TBuf<16> attr;

			for (TInt j = 0; j < 16; j++)

				{

				if ((1 << j) & e.iAtt)

					attr.Append(TText("RHSVDA X        "[j]));

				}

			if (e.IsDir())

				{

				iDirs.Inc();

				// TTest::Printf(_L("%c:%-50S    <DIR>  %S\n"), aDriveCh, &path, &attr);

				}

			else

				{

				iFiles.Inc();

				TBool read = (aReadInterval && Math::Rand(iSeed) % prob == 0);

				if (read)

					{

					// TTest::Printf(_L("%-50S %8d  %-8S  test\n"), &path, e.iSize, &attr);

					r = ReadFile(path, e.iSize);

					}

				else

					{

					// TTest::Printf(_L("%c:%-50S %8d  %S\n"), aDriveCh, &path, e.iSize, &attr);

					}

				}

			}

		delete entryList;

		entryList=NULL;

		}

	return r;

	}

TInt TSoakReadOnly::ScanDrives(TBool aScanDirs, TInt aReadInterval)

///

/// Scan all drives (except the one excluded) for directories and files.

/// @param aScanDirs If true, read subdirectories, if false don't.

/// @param aReadInterval approximate number of files to read.

///

	{

	TInt r = KErrNone;

	TInt i;

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

		{

		TChar drv;

		r=iFs.DriveToChar(i, drv);

		if (r != KErrNone)

			return r;

		TDriveInfo info;

		r=iFs.Drive(info, i);

		if (r != KErrNone)

			return r;

		if (i != iDrive

			&& info.iDriveAtt != 0

			&& info.iType != EMediaUnknown

			&& info.iType != EMediaNotPresent)

			{

			iDrives.Inc();

			// TTest::Printf(_L("Drive %c:"), drv);

			if (aScanDirs)

				{

				iDirs.Inc();

				r = ScanDirs(drv, aReadInterval);

				if (r != KErrNone)

					return r;

				}

			}

		}

	return r;

	}

void

TSoakReadOnly::ExcludeDrive(TInt aDriveCh)

///

/// Set a drive to be excluded from scanning.

/// @param aDriveCh Drive letter to be excluded.

///

	{

	iDrive = aDriveCh;

	}

// --------------------------------------------------------------------------

TSoakFill::TSoakFill()

///

/// Initialise the fill/clean cycle.

///

	{

	iSeed = 186483;

	TInt r = iFs.Connect();

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("iFs connect"));

	}

TInt TSoakFill::SetDrive(TInt aDriveCh)

///

/// Set a drive to be stressed.  The test directory is created and then it is

/// cleaned (in case anything was left over from previous tests).  Note that

/// other directories on the drive are untouched.

/// @param aDriveCh Drive letter to be used.

/// @leave The drive scanning can cause the function to leave.

///

	{

	TInt  r = KErrNone;

	iDrive = aDriveCh;

	if (aDriveCh)

		{

		iDrvCh = aDriveCh;

		iFs.CharToDrive(iDrvCh, iDrive);

		r=iFs.Volume(iInfo, iDrive);

		if (r != KErrNone)

			TTest::Fail(HERE, r, _L("volume info for %C:"), aDriveCh);

		iFree = iInfo.iSize;

		iName.Format(_L("%c:\\SOAK\\"), iDrvCh);

		r = iFs.MkDir(iName);

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

			TTest::Fail(HERE, r, _L("mkdir %S"), &iName);

		r = KErrNone;

		}

	return r;

	}

TInt TSoakFill::FillDrive()

///

/// Fill the drive with files and directories of random lengths.

/// @param aDriveCh Drive letter to be tested, or zero (absent) to use the one

///        set up with SetDrive().

/// @leave Setting up a new drive can cause this function to leave.

///

	{

	TInt  r = KErrNone;

	r=iFs.Volume(iInfo, iDrive);

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("volume info for %C:"), iDrvCh);

	iFree = iInfo.iFree;

	r = iFs.MkDir(iName);

	if (r != KErrNone && r != KErrAlreadyExists && r != KErrNotSupported)

		TTest::Fail(HERE, r, _L("mkdir %S"), &iName);

	do

		{

		r = Fill(iName);

		if (r == KErrDiskFull)

			{

			// TTest::Printf(_L("Disk full on %c:\n"), iDrvCh);

			break;

			}

		if (r != KErrNone)

			TTest::Fail(HERE, r, _L("Filling drive %c"), iDrvCh);

		r=iFs.Volume(iInfo, iDrive);

		if (r != KErrNone)

			TTest::Fail(HERE, r, _L("volume info for %c:"), iDrvCh);

		} while (iInfo.iFree > 0);

	r=iFs.Volume(iInfo, iDrive);

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("volume info for %c:"), iDrvCh);

	if (iInfo.iFree > 0)

		TTest::Printf(_L("Free space on %c: %S %ld KB (out of %ld KB)\n"),

					  iDrvCh,

					  &iInfo.iName,

					  I64LOW(iInfo.iFree / 1024),

					  I64LOW(iInfo.iSize / 1024));

	return r;

	}

TInt TSoakFill::CleanDrive()

///

/// Clean the test directory on the selected drive, removing all files and

/// subdirectories.  Other directories on the drive are left untouched.

/// @leave Scanning the drive can cause the function to leave.

///

	{

	TInt r = KErrNone;

	CDirScan* scanner=0;

	TRAP(r, scanner=CDirScan::NewL(iFs));

	if (r != KErrNone || !scanner)

		TTest::Fail(HERE, r, _L("creating scanner"));

	TParse dirName;

	r=iFs.Parse(iName, dirName);

	if (r != KErrNone)

		{

		if (r == KErrInUse || r == KErrNotFound || r == KErrPathNotFound)

			{

			// valid conditions, don't report error

			r = KErrNone;

			}

		else

			TTest::Fail(HERE, r, _L("Parse %S"), &iName);

		}

	else

		{

		// TTest::Printf(_L("scan %S\n"), &iName);

		CDir* entryList = NULL;

		TRAP(r, scanner->SetScanDataL(dirName.FullName(),KEntryAttDir,ESortByName,CDirScan::EScanUpTree));

		if (r != KErrNone)

			TTest::Fail(HERE, r, _L("SetScanDataL(%S)"), &dirName.FullName());

		TRAP(r, scanner->NextL(entryList));

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

			TTest::Fail(HERE, r, _L("Scan NextL()"));

		while (entryList)

			{

			for (TInt i = 0; i < entryList->Count(); i++)

				{

				TEntry e = (*entryList)[i];

				TFileName path = iName;

				if (path.Right(1) == _L("\\"))

					path.SetLength(path.Length()-1);

				path.Append(scanner->AbbreviatedPath());

				path.Append(e.iName);

				// TTest::Printf(_L("remove %S\n"), &path);

				TBuf<256> buf;

				TInt maxInUseCount = 120;

				do

					{

					if (e.IsDir())

						{

						if (path.Right(1) != _L("\\"))

							path.Append(_L("\\"));

						r = iFs.RmDir(path);

						}

					else

						r = iFs.Delete(path);

					if (r == KErrInUse)

						{

						TTest::Printf(_L("Warning: %S deleting %S\n"), &TTest::ErrStr(r, buf), &path);

						User::After(1*KSecond);

						}

					}

					while (r == KErrInUse && maxInUseCount-- > 0);

				if (r != KErrNone)

					{

					TTest::Printf(_L("ERROR %S deleting %S\n"), &TTest::ErrStr(r, buf), &path);

					}

				}

			delete entryList;

			TRAP(r, scanner->NextL(entryList));

			if (r != KErrNone)

				TTest::Fail(HERE, r, _L("Scan NextL()"));

			}

		}

	delete scanner;

	r = iFs.RmDir(iName);

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

		{

		TTest::Fail(HERE, r, _L("volume info for %C:"), iName[0]);

		}

	r=iFs.Volume(iInfo, iDrive);

	if (r != KErrNone)

		{

		TTest::Fail(HERE, r, _L("volume info for %C:"), iName[0]);

		}

	if (iInfo.iFree > iFree)

		{

		TTest::Printf(_L("Warning: %C: changed size -- was %ld now %ld\n"),

					  iName[0], iFree, iInfo.iFree);

		return r;

		}

	iFree = iInfo.iFree;

	return r;

	}

TInt TSoakFill::Fill(TFileName& aName, TInt aNfiles)

///

/// Recursively create files and subdirectories at random.  If a subdirectory

/// is created, the function recurses to fill it.  This generates a mixture of

/// directories and files of varying lengths.

/// @param aName   Directory in which to create other stuff.

/// @param aNfiles Maximum number of files to create.

/// @return Status of last thing created, KErrDiskFull when out of space.

///

	{

	TInt oldlen = aName.Length();

	if (oldlen + 10 > aName.MaxLength())

		return KErrNone;

	TInt r=iFs.Volume(iInfo, iDrive);

	if (r != KErrNone)

		return r;

	TInt nfiles = I64LOW(iInfo.iFree/10000) + 5;

	if (aNfiles > 0 && nfiles > aNfiles)