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

		nfiles = aNfiles;

	nfiles = Math::Rand(iSeed) % nfiles + 5;

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

	// TTest::Printf(_L("nfiles = %d\n"), nfiles);

	TInt i;

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

		{

		aName.SetLength(oldlen);

		TBool dir = (Math::Rand(iSeed) % 5 == 0);

		if (dir && oldlen < 80)

			{

			aName.Append(_L("d"));

			aName.AppendNum(i);

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

			r = iFs.MkDir(aName);

			TInt busycount = 120;

			while (busycount-- > 0)

				{

				r = iFs.MkDir(aName);

				if (r == KErrDiskFull)

					TTest::Printf(_L("Disk full creating %S\n"), &aName);

				if (r != KErrInUse)

					break;

				TTest::Printf(_L("Warning: KErrInUse creating %S\n"), &aName);

				User::After(1*KSecond);

				}

			// TTest::Printf(_L("mkdir %S = %d\n"), &aName, r);

			if (r == KErrNone || r == KErrAlreadyExists)

				{

				r = Fill(aName, nfiles - i - 2);

				}

			if (r != KErrNone)

				break;

			}

		else

			{

			aName.Append(_L("F"));

			aName.AppendNum(i);

			RFile f;

			TInt busycount = 120;

			while (busycount-- > 0)

				{

				r = f.Replace(iFs, aName, EFileStreamText | EFileWrite);

				if (r != KErrInUse)

					break;

				TTest::Printf(_L("Warning: KErrInUse creating %S\n"), &aName);

				User::After(1*KSecond);

				}

			if (r == KErrNone)

				{

				// iNames.AppendL(aName);

				TInt num = Math::Rand(iSeed) % filesz + 10;

				TBuf8<256> buf;

				buf.Fill(TText(' '), 256);

				TInt wr = 0;

				while (num-- > 0 && r == KErrNone)

					{

					r = f.Write(buf);

					if (r == KErrNone)

						wr += 256;

					else

						break;

					}

				f.Close();

				/*

				if (r == KErrDiskFull)

					TTest::Printf(_L("Disk full writing %S\n"), &aName);

				*/

				if (r != KErrNone)

					break;

				}

			else

				{

				// TTest::Printf(_L("creat %S = %d\n"), &aName, r);

				if (r == KErrDiskFull)

					TTest::Printf(_L("Disk full creating %S\n"), &aName);

				break;

				}

			}

		}

	aName.SetLength(oldlen);

	return r;

	}

TSoakRemote::TSoakRemote(TInt aDriveCh)

///

/// Initialise testing for 'remote' drive (special filesystem).  Connects to

/// file session, initialises the drive and timer, sets up the buffers and

/// file name.

/// @param aDriveCh Drive letter for the drive to test.

///

	{

	TInt r = iFs.Connect();

	if (r != KErrNone)

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

	iDrvCh = aDriveCh;

	iSync  = EFalse;

	iFs.CharToDrive(iDrvCh, iDrive);

	iTimer.CreateLocal();

	Setup();

	}

void TSoakRemote::Setup()

/// Set up the buffers and the filename to be used.

	{

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

		{

		iBuff[i].Fill('_', KSoakBufLen);

		iStat[i] = KErrNone;

		}

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

	}

void TSoakRemote::Remount(TBool aSync)

///

/// Remount the test drive as (a)synchronous.

/// @param aSync If true, the drive is set as synchronous access, otherwise

///              as asynchronous.

///

	{

	TFileName fsname;

	iSync = aSync;

	TInt r = iFs.FileSystemName(fsname, iDrive);

	TEST(r == KErrNone || r == KErrNotFound);

	if (fsname.Length() > 0)

		{

		r = iFs.ExtensionName(gPrimaryExtensions[iDrive].iName, iDrive, 0);

		if (r == KErrNone)

			gPrimaryExtensions[iDrive].iExists = ETrue;

		r = iFs.DismountFileSystem(fsname, iDrive);

		if(r != KErrNone)

			{

			TTest::Fail(HERE, r, _L("Dismounting file system %S"), &fsname);

			}

		}

	TBufC<16> type = _L("asynchronous");

	if (iSync)

		type = _L("synchronous");

	TTest::Printf(_L("Remount filesystem %c: %S as %S\n"), iDrvCh, &fsname, &type);

#ifdef __CONCURRENT_FILE_ACCESS__

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

		r=iFs.MountFileSystem(fsname,iDrive,iSync);

	else

		r=iFs.MountFileSystem(fsname,gPrimaryExtensions[iDrive].iName,iDrive,iSync);

#else

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

		r=iFs.MountFileSystem(fsname,iDrive);

	else

		r=iFs.MountFileSystem(fsname,gPrimaryExtensions[iDrive].iName,iDrive);

#endif

	TEST(r==KErrNone);

	}

TInt TSoakRemote::TestSubSession()

///

/// Test what happens when a file is closed in the middle of writing it.  Note

/// that this assumes that the filesystem under test takes a second for each

/// write operation (i.e. is the special test filesystem).

///

	{

	TInt r = iFile.Replace(iFs, iName, EFileStreamText | EFileWrite);

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("opening %S for writing"), iName.Ptr());

	TInt i;

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

		{

		iFile.Write(iBuff[i], iStat[i]);

		}

	// wait for a couple of writes to complete, then close the file before the

	// others finish

	User::After(KSessionWaitTime);

	TTest::Printf(_L("Wait ended"));

	iFile.Close();

	TTest::Printf(_L("Close ended"));

	// test what has happened

	TBool bad = EFalse;

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

		{

		User::WaitForRequest(iStat[i]);

		r = iStat[i].Int();

		switch (r)

			{

			case KErrNone:

				if (i >= KSessionNumEnded)

					{

					TTest::Printf(_L("Write %d not cancelled"), i);

					bad = ETrue;

					}

				break;

			case KErrCancel:

				if (i <= KSessionNumEnded)

					{

					TTest::Printf(_L("Write %d incorrectly cancelled"), i);

					bad = ETrue;

					}

				TTest::Printf(_L("write %d cancelled\n"), i);

				break;

			default:

				TTest::Fail(HERE, r, _L("incorrect status for write %d"), i);

			}

		}

	iFs.Delete(iName);

	TPtrC sbuf(iSync ? _L("sync") : _L("async"));

	if (bad)

		{

		TTest::Printf(_L("TestSubSession %c: %S FAILED\n"), iName[0], &sbuf);

		// Commented out for the moment as result is undefined

		// TTest::Fail(HERE, _L("TestSubSession %c: %S FAILED\n"), iName[0], &sbuf);

		}

	TTest::Printf(_L("TestSubSession %c: %S OK\n"), iName[0], &sbuf);

	return KErrNone;

	}

TInt TSoakRemote::TestSession()

///

/// Test what happens when a session is closed in the middle of writing a file.

/// Note that this assumes that the filesystem under test takes a second for

/// each write operation (i.e. is the special test filesystem).

///

	{

	TInt r;

	TInt i;

	TPtrC sbuf(iSync ? _L("sync") : _L("async"));

	r = iFile.Replace(iFs, iName, EFileStreamText | EFileWrite);

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("opening %S for writing"), iName.Ptr());

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

		{

		iFile.Write(iBuff[i], iStat[i]);

		}

	// wait for a couple of them to complete, then close the session

	User::After(KSessionWaitTime);

	TTest::Printf(_L("Close FS %S"), &sbuf);

	// iFs.SetDebugRegister(KFSYS | KFSERV | KTHRD);

	iFs.Close();

	TTest::Printf(_L("FS closed %S"), &sbuf);

	// see what has happened to the writes (wait for at most another 10 seconds).

	TRequestStatus tstat;

	iTimer.After(tstat, 10*KSecond);

	TBool busy = ETrue;

	TInt  file = 0;

	while (tstat == KRequestPending && busy)

		{

		User::WaitForAnyRequest();

		busy = EFalse;

		for (i = file; i < KSoakNumBuf; i++)

			{

			r = iStat[i].Int();

			switch (r)

				{

				case KRequestPending:

					busy = ETrue;

					TTest::Printf(_L("write %d pending\n"), i);

					break;

				case KErrNone:

					file = i + 1;

					TTest::Printf(_L("write %d finished\n"), i);

					break;

				case KErrCancel:

					file = i + 1;

					TTest::Printf(_L("write %d cancelled\n"), i);

					break;

				default:

					file = i + 1;

					TTest::Fail(HERE, r, _L("incorrect status for write %d"), i);

				}

			}

		}

	TBool bad = EFalse;

	if (busy)

		{

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

			{

			TBuf<64> buf;

			r = iStat[i].Int();

			if (r != KErrNone)

				{

				// We expect that the third and subsequent requests will either

				// have failed with cancel or be still outstanding.  If either

				// of the first two have failed or are outstanding, that's an

				// error.

				if (i < KSessionNumEnded || (r != KErrCancel && r != KRequestPending))

					{

					TTest::Fail(HERE, _L("write %d: %S\n"), i, &TTest::ErrStr(r, buf));

					bad = ETrue;

					}

				}

			}

		}

	iTimer.Cancel();

	// if it's got this far, re-connect the file session

	// User::After(100000);

	// TTest::Printf(_L("FS closed (%S) yet?"), &sbuf);

	r = iFs.Connect();

	iFs.SetDebugRegister(0);

	// TTest::Printf(_L("FS opened"));

	if (r != KErrNone)

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

	r = iFs.Delete(iName);

	for (TInt nr = 0; r == KErrInUse && nr < 100; nr++)

		{

		TTest::Printf(_L("Wait for previous session to close"));

		User::After(10*KSecond);

		r = iFs.Delete(iName);

		}

	if (r == KErrNotFound)

		r = KErrNone;

	if (r != KErrNone)

		bad = ETrue;

	TPtrC obuf(bad ? _L("FAIL") : _L("OK"));

	TTest::Printf(_L("TestSession %c: %S %S\n"), iName[0], &sbuf, &obuf);

	if (bad)

		{

		TTest::Printf(_L("Test session close %c: %S FAILED\n"), iName[0], &sbuf);

		// Commented out for the moment as result is undefined

		// TTest::Fail(HERE, _L("Test session close failed"));

		}

	return r;

	}

TInt TSoakRemote::TestMount()

///

/// Test dismounting with a file open (should fail)

///

	{

	TFileName fsname;

	TInt r = iFs.FileSystemName(fsname, iDrive);

	TEST(r == KErrNone || r == KErrNotFound);

	TPtrC sbuf(iSync ? _L("sync") : _L("async"));

	r = iFile.Replace(iFs, iName, EFileStreamText | EFileWrite);

	for (TInt nr = 0; r == KErrInUse && nr < 100; nr++)

		{

		TTest::Printf(_L("Warning: KErrInUse opening %S for writing\n"), &iName);

		User::After(10*KSecond);

		r = iFile.Replace(iFs, iName, EFileStreamText | EFileWrite);

		}

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("opening %S for writing"), &iName);

	if (fsname.Length() > 0)

		{

		r = iFs.DismountFileSystem(fsname, iDrive);

		if (r == KErrNone)

			{

#ifdef __CONCURRENT_FILE_ACCESS__

			r = iFs.MountFileSystem(fsname, iDrive, iSync);

#else

			r = iFs.MountFileSystem(fsname, iDrive);

#endif

			if (r != KErrNone)

				TTest::Fail(HERE, r, _L("MountFileSystem(%S, %C:)"), &fsname, iDrvCh);

			}

		else if (r != KErrInUse)

			{

			TTest::Fail(HERE, r, _L("DismountFileSystem(%S, %C:)"), &fsname, iDrvCh);

			}

		}

	iFile.Close();

	iFs.Delete(iName);

	TTest::Printf(_L("TestMount %c: %S OK\n"), iName[0], &sbuf);

	return KErrNone;

	}