// Copyright (c) 1997-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_format.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include "t_server.h"

#include "t_chlffs.h"

#include "f32_test_utils.h"

using namespace F32_Test_Utils;

GLREF_D TFileName gSessionPath;

void GenerateMediaChange()

	{

	TBuf<2> b;

	b.SetLength(2);

	b[0]=gSessionPath[0];

	b[1]=':';

	RFormat format;

	TInt count;

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

	test(r==KErrNone);

	format.Close();

	}

RTest test(_L("T_FORMAT"));

RSemaphore gSleepThread;

TRequestStatus gThreadLogon;

static TInt gDrive=-1;

static const TInt KSectorSize=512;

static const TInt KHeapSize=0x200;

enum TTestCode{ETest3,ETest5};

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

TInt DoFormatSteps(RFormat& aFormat, TInt& aFmtCnt)

{

    TInt nRes = KErrNone;

    while(aFmtCnt)

    {

        nRes = aFormat.Next(aFmtCnt);

        if(nRes != KErrNone)

        {

            test.Printf(_L("RFormat::Next() failed! code:%d\n"), nRes);

            break;

        }

    }

    return nRes;

}

static void WaitForMedia()

//

// Wait until the media change is serviced

//

	{

	FOREVER

		{

		TInt r=TheFs.MkDir(_L("\\"));

		if (r!=KErrNotReady)

			break;

		User::After(100000);

		}

	}

static TInt ThreadEntryPoint(TAny* aTestCode)

//

// Thread entry point

//

	{

	RFs fs;

	TInt ret=fs.Connect();

	test(ret==KErrNone);

	ret=fs.SetSessionPath(gSessionPath);

	test(ret==KErrNone);

	TTestCode testCode=*(TTestCode*)&aTestCode;

	TInt count;

	RFormat format;

	switch (testCode)

		{

		case ETest3:

			{

			ret=format.Open(fs,gSessionPath,EQuickFormat,count);

			test(ret==KErrNone);

            ret = DoFormatSteps(format, count);

            test(ret==KErrNone);

            format.Close();

			break;

			}

		case ETest5:

			{

			ret=format.Open(fs,gSessionPath,EFullFormat,count);

			test(ret==KErrNone);

			gSleepThread.Signal();

			User::After(100000000);		

			break;

			}

		default:

			break;

		}

	return(KErrNone);

	}

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

static void CorruptCurrentDrive()

//

// Corrupt the current drive

//

	{

	test.Printf(_L("CorruptCurrentDrive() %c:"), 'A'+CurrentDrive());

	RRawDisk raw;

	TInt r=raw.Open(TheFs,CurrentDrive());

	test(r==KErrNone);

	if (!Is_Lffs(TheFs, gDrive))

		{

		TBuf8<KSectorSize> zeroBuf(KSectorSize);

		Mem::FillZ((TAny*)zeroBuf.Ptr(),zeroBuf.MaxSize());

        //-- for FAT32 we need to corrupt a backup BOOT sector as well,

        //-- otherwise it can be used and some tests will fail..

        const TInt KMaxSectors = 25; //-- how many sectors to corrupt

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

            {

            r=raw.Write(i*KSectorSize, zeroBuf);

		    test(r==KErrNone);

            }

		}

	else

		{

		TBuf8<32> zeroBuf(32);

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

			zeroBuf[j]=(TUint8)j; //Not actuall zero buf for lffs

		// For LFFS, the media may not exhibit a contiguous region of sufficient length

		// to support a continuous sequence of writes. This is the case if the 

		// Control Mode Size is non-zero

		TInt cntlModeSize=GetLFFSControlModeSize();

		if(cntlModeSize==0)

			{

			//test.Printf(_L("CorruptCurrentDrive() - Control mode  size is zero\n"),r);

			for (TInt writePos=0;writePos<0x20200;writePos+=32)

				{

				r=raw.Write(writePos,zeroBuf);

				// The device driver most likely fails when writing a random

				// buffer due to read back checks. Since we're writing

				// aligned 32-byte blocks, we don't need to bother that much.

				// The device driver writes the block but fails when reading

				// it back.

				// test(r==KErrNone);

				}

			}

		else if(cntlModeSize>0)

			{

			//test.Printf(_L("CorruptCurrentDrive() - Control mode = 0x%x\n"),r);

			// For devices which have a non-zero control mode size, the writes may

			// require segmentation.

			TInt cmBase=0;

			TInt cmOffset=0;

			TInt bufOffset=0;

			TInt bytesWritten=0;

			TPtrC8 writeBuf;

			while(bytesWritten < 0x20200)

				{

				TInt bufLeft = 32 - bufOffset;	// 32 from size of zeroBuf

				TInt spaceLeft = cntlModeSize - cmOffset;

				TInt writeLen=(bufLeft>spaceLeft)? spaceLeft : bufLeft;

				writeBuf.Set(&(zeroBuf[bufOffset]),writeLen);

				TInt writePos = cmBase + cmOffset;

				r=raw.Write(writePos,writeBuf);

				bytesWritten += writeLen;

				if(bufLeft < spaceLeft)

					{

					bufOffset = 0;

					cmOffset += bufLeft;

					}

				else if(bufLeft == spaceLeft)

					{

					bufOffset = 0;

					cmOffset = 0;

					cmBase += (2*cntlModeSize);

					}

				else	

					{	// bufRemaining>spaceRemaining

					bufOffset += spaceLeft;

					cmOffset = 0;

					cmBase += (2*cntlModeSize);

					}

				}

			}

		else

			{

			// Negative value (error code) returned from GetLFFSControlModeSize()

			test.Printf(_L("CorruptCurrentDrive() - Control mode = %d (ERROR!) \n"),cntlModeSize);

			test(0);

			}

		}

	raw.Close();

	}

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

static void Test1()

//

// Format disk

//

	{

	test.Next(_L("Test EFullFormat"));

	TInt count;

	RFormat format;

	TInt r=format.Open(TheFs,gSessionPath,EFullFormat,count);

	test(r==KErrNone);

    r = DoFormatSteps(format, count);

    test(r==KErrNone);

	format.Close();

	TVolumeInfo volInfo;

	r=TheFs.Volume(volInfo);

	test(r==KErrNone);

	if (volInfo.iSize-volInfo.iFree!=0)

		{

		test.Printf(_L("Memory 'in use' after a full format = %ld\n"),(volInfo.iSize-volInfo.iFree));

		test.Printf(_L("volInfo.iSize = %ld\n"),volInfo.iSize);

		test.Printf(_L("volInfo.iFree = %ld\n"),volInfo.iFree);

		}

	test.Next(_L("Test EQuickFormat"));

	r=format.Open(TheFs,gSessionPath,EQuickFormat,count);

	test(r==KErrNone);

    r = DoFormatSteps(format, count);

    test(r==KErrNone);

	format.Close();

	r=TheFs.Volume(volInfo);

	test(r==KErrNone);

	if (volInfo.iSize-volInfo.iFree!=0)

		{

		test.Printf(_L("Memory 'in use' after a quick format = %ld\n"),(volInfo.iSize-volInfo.iFree));

		test.Printf(_L("volInfo.iSize = %ld\n"),volInfo.iSize);

		test.Printf(_L("volInfo.iFree = %ld\n"),volInfo.iFree);

		return;

		}

	}

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

static void Test2()

//

// Test access controls

//

	{

	test.Next(_L("Test disk cannot be formatted while a file is open"));

	RFile f;

	TInt r=f.Replace(TheFs,_L("BLARGME.BLARG"),EFileStream);

	test(r==KErrNone);

	TInt count;

	RFormat format;

	r=format.Open(TheFs,gSessionPath,EFullFormat,count);

	test(r==KErrInUse);

	f.Close();

	r=format.Open(TheFs,gSessionPath,EFullFormat,count);

	test(r==KErrNone);

	format.Close();

	CheckFileExists(_L("BLARGME.BLARG"),KErrNone);

	}

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

static void Test3()

//

// Test notification

//

	{

	test.Next(_L("Test successful format triggers notifier"));

	MakeFile(_L("\\BLARG_BLARG_BLARG.BLG"));

	TRequestStatus reqStat;

	TheFs.NotifyChange(ENotifyEntry,reqStat);

	RThread clientThread;

	TInt r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest3);

	test.Printf(_L("Created helper thread #1, res=%d\n"),r);	

	test(r==KErrNone);

	clientThread.Logon(gThreadLogon);

	clientThread.Resume();

	clientThread.Close();

	User::WaitForRequest(reqStat);

	test.Printf(_L("Notifier triggered #1, res=%d\n"),reqStat.Int());	

	User::WaitForRequest(gThreadLogon);

	test.Printf(_L("Helper thread exited #1, res=%d\n"),gThreadLogon.Int());	

	CheckFileExists(_L("BLARG_BLARG_BLARG.BLG"),KErrNotFound);

	MakeFile(_L("\\BLARG_BLARG_BLARG.BLG"));

	TheFs.NotifyChange(ENotifyAll,reqStat);

	r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest3);

    test.Printf(_L("Created helper thread #2, res=%d\n"),r);	

	test(r==KErrNone);

	clientThread.Logon(gThreadLogon);

	clientThread.Resume();

	clientThread.Close();

	User::WaitForRequest(reqStat);

	test.Printf(_L("Notifier triggered #2, res=%d\n"),reqStat.Int());	

	User::WaitForRequest(gThreadLogon);

	test.Printf(_L("Helper thread exited #2, res=%d\n"),gThreadLogon.Int());	

	CheckFileExists(_L("BLARG_BLARG_BLARG.BLG"),KErrNotFound);

	}

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

static void Test4()

//

// Test partially completed formats

//

	{

    test.Next(_L("Test partially completed formats"));

    if(Is_Automounter(TheFs, gDrive))

        {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward

         //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test.

        test.Printf(_L("This step is skipped for Automounter File System\n"));	

        return;

        }

	MakeFile(_L("\\FORMAT\\DIR1\\BLARG_BLARG_BLARG.BLG"));

	TInt count;

	CorruptCurrentDrive();

    test.Printf(_L("Formatting the drive...\n"));	

	RFormat format;

	TInt r=format.Open(TheFs,gSessionPath,EFullFormat,count);

	test(r==KErrNone);

	while(count)

		{

		RDir dir;

		r=dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal);

		test(r==KErrInUse);

		r=format.Next(count);

		test(r==KErrNone);

		}

	format.Close();

	CheckFileExists(_L("\\FORMAT\\DIR1\\BLARG_BLARG_BLARG.BLG"),KErrPathNotFound);

	}

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

static void Test5()

//

// Test panic formatting thread

//

	{

    test.Next(_L("Test panic formatting thread"));

    if(Is_Automounter(TheFs, gDrive))

        {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward

         //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test.

        test.Printf(_L("This step is skipped for Automounter File System\n"));	

        return;

        }

	CorruptCurrentDrive();

    if (!(IsTestingLFFS() && GetDriveLFFS()==EDriveC)) // ??? Remove after ER5U

		{

//		UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change

		GenerateMediaChange();

		WaitForMedia();

		}

	gSleepThread.CreateLocal(0);

	RThread clientThread;

	TInt r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest5);

	test.Printf(_L("Created helper thread #1, res=%d\n"),r);	

	test(r==KErrNone);

    test.Printf(_L("Panicing formatting thread #1\n"));	

	clientThread.Resume();

	gSleepThread.Wait();

	test.Printf(_L("Panicing formatting thread #2\n"));	

	User::SetJustInTime(EFalse);

	clientThread.Panic(_L("Panic formatting thread"),KErrGeneral);

	User::SetJustInTime(ETrue);

	User::After(200000);	// to let panic take effect

    test.Printf(_L("Panicing formatting thread #3\n"));	

	RDir dir;

	r=dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal);

//	if(IsTestingLFFS() && (r==KErrNone))

//	{

//		dir.Close();

//	}

//	else

//	{

	test(r==KErrCorrupt);

//	}

    test.Printf(_L("Formatting the drive...\n"));	

	TInt count;

	RFormat format;

	r=format.Open(TheFs,gSessionPath,EQuickFormat,count);

	test(r==KErrNone);

    r = DoFormatSteps(format, count);

    test(r==KErrNone);

    format.Close();

	MakeFile(_L("BLARGOID.BLARG"));

	CheckFileExists(_L("BLARGOID.BLARG"),KErrNone);

	clientThread.Close();

	gSleepThread.Close();

	}		

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

static void Test6()

//

// Test ramdrive is shrunk after formatting

//

	{

	test.Next(_L("Test ramdrive shrinks after formatting"));

	TVolumeInfo volInfo;

	TInt r=TheFs.Volume(volInfo);

	test(r==KErrNone);

	if ((volInfo.iDrive.iMediaAtt&KMediaAttVariableSize)==0)

		return;

	TInt64 used=volInfo.iSize-volInfo.iFree;

	RFile f;

	r=f.Replace(TheFs,_L("BIGFILE.SIZE"),EFileRead|EFileWrite);

	test(r==KErrNone);

	f.SetSize(0x100000); // 1MB

	f.Close();

	r=TheFs.Volume(volInfo);

	test(r==KErrNone);

	TInt64 used2=volInfo.iSize-volInfo.iFree;

	test(used<used2);

	r=TheFs.Delete(_L("BIGFILE.SIZE"));

	test(r==KErrNone);

	r=TheFs.Volume(volInfo);

	test(r==KErrNone);

	used2=volInfo.iSize-volInfo.iFree;

	test(used==used2);

	r=f.Replace(TheFs,_L("BIGFILE.SIZE"),EFileRead|EFileWrite);

	test(r==KErrNone);

	f.SetSize(0x100000); // 1MB

	f.Close();

	r=TheFs.Volume(volInfo);

	test(r==KErrNone);

	used2=volInfo.iSize-volInfo.iFree;

	test(used<used2);

	TInt count;

	RFormat format;

	r=format.Open(TheFs,gSessionPath,EQuickFormat,count);

	test(r==KErrNone);

    r = DoFormatSteps(format, count);

    test(r==KErrNone);

    format.Close();

	r=TheFs.Volume(volInfo);

	test(r==KErrNone);

	used2=volInfo.iSize-volInfo.iFree;

	test(used>=used2);

	}

static void Test7()

//

// Generate media change before formatting.

//

	{

	test.Next(_L("Generate Media change before formatting"));

    if(Is_Automounter(TheFs, gDrive))

        {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward

         //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test.

        test.Printf(_L("This step is skipped for Automounter File System\n"));	

        return;

        }

    TVolumeInfo volInfo;

	TInt r=TheFs.Volume(volInfo);

	test(r==KErrNone);

    if (volInfo.iDrive.iMediaAtt&KMediaAttVariableSize)

		return; // Don't bother on internal disk

    if (Is_Lffs(TheFs, gDrive))

		return; // Don't bother on LFFS

	CorruptCurrentDrive();

//	UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change

	GenerateMediaChange();

	WaitForMedia();

	TInt count;

	RFormat format;

	r=format.Open(TheFs,gSessionPath,EQuickFormat,count);

	test(r==KErrNone);

    r = DoFormatSteps(format, count);

    test(r==KErrNone);

	format.Close();

	}

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

static void Test8()

//

// Test incomplete format

//

	{

	test.Next(_L("Test incomplete format"));

    if(Is_Automounter(TheFs, gDrive))

        {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward

         //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test.

        test.Printf(_L("This step is skipped for Automounter File System\n"));	

        return;

        }

    CorruptCurrentDrive();

    if (!(IsTestingLFFS() && GetDriveLFFS()==EDriveC)) // ??? Remove after ER5U

		{

//		UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change

		GenerateMediaChange();

		WaitForMedia();

		}

    TVolumeInfo volInfo;

	TInt r=TheFs.Volume(volInfo);

//	test(r==KErrCorrupt);

	TInt count;

	RFormat format;

	r=format.Open(TheFs,gSessionPath,EQuickFormat,count);

	r=TheFs.Volume(volInfo);

	test(r==KErrInUse);

	r=format.Next(count);

	test(r==KErrNone);

	TDriveList driveList;

	r=TheFs.DriveList(driveList);

	test(r==KErrNone);

    if(gDrive == EDriveC)

    {

		r=TheFs.Volume(volInfo, gDrive);

		test(r==KErrInUse);

    } 

    else

    {

		r=TheFs.Volume(volInfo,EDriveC);

		test(r==KErrNone);

		r=TheFs.Volume(volInfo,gDrive);	

		test(r==KErrInUse);

    	r=TheFs.Volume(volInfo,gDrive);	

		test(r==KErrInUse);

    }

    format.Close();

	Format(CurrentDrive());

	}

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

/** 

    Test an API that allows force media formatting with the files or other objects opened on the volume

*/

void TestFormat_ForceDismount()

{

	test.Next(_L("Test format with forced media dismounting"));

    if(Is_Lffs(TheFs, gDrive))

    {//-- forced FS dismounting with files/directories opened damages LFFS structure for unknown reason.

     //-- this is a problem of LFFS, anyway, it is not supported.   

        test.Next(_L("This test can't be performed on LFFS, Skipping."));

        return;

    }

    TInt nRes;

    RFormat     format;

    TUint       fmtMode = EQuickFormat;

    TInt        fmtCnt;

    TBuf<10>    drivePath;

    drivePath.Format(_L("%C:\\"), gDrive+'A');

    RBuf8 buf8;

    RFile file1;

    RDir  dir;

    const TInt KBufLen = 128*K1KiloByte;

    nRes = buf8.CreateMax(KBufLen);

    test_KErrNone(nRes);

    _LIT(KFname, "\\file1");

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

    //-- 1.1 open a file, try to format in normal mode; this shall fail with KErrInUse

    test.Printf(_L("Test normal format with normal opened objects\n"));

    nRes = file1.Replace(TheFs, KFname, EFileWrite);

    test_KErrNone(nRes);

    fmtMode = EQuickFormat;

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt);

    test(nRes == KErrInUse);

    format.Close();

    buf8.SetLength(22);

    nRes = file1.Write(buf8);

    test_KErrNone(nRes);

    file1.Close();

    //-- 1.2 open a directory, try to format in normal mode; this shall fail with KErrInUse

	nRes = dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal);

    test_KErrNone(nRes);

    fmtMode = EQuickFormat;

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt);

    test(nRes == KErrInUse);

    format.Close();

    dir.Close();

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

    //-- 2.1 forced quick formatting 

    test.Printf(_L("Test forced quick formatting\n"));

    nRes = file1.Replace(TheFs, KFname, EFileWrite); //-- open a file

    test_KErrNone(nRes);

    nRes = dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal); //-- open a directory

    test_KErrNone(nRes);

    //-- this will mark the current Mount as "Dismounted" and will instantiate another CMountCB for formatting

    fmtMode = EQuickFormat | EForceFormat; 

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); 

    test_KErrNone(nRes);

    nRes = DoFormatSteps(format, fmtCnt);

    test_KErrNone(nRes);

    format.Close();

	nRes=TheFs.CheckDisk(gSessionPath);

	test(nRes==KErrNone||nRes==KErrNotSupported);

    buf8.SetLength(22);

    nRes = file1.Write(buf8);

    test(nRes == KErrDisMounted);

    file1.Close();  //-- this will make the previously "Dismounted" mount die.

    dir.Close();

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

    //-- 2.2 forced full formatting 

    test.Printf(_L("Test forced full formatting\n"));

    nRes = file1.Replace(TheFs, KFname, EFileWrite);

    test_KErrNone(nRes);

    //-- this will mark the current Mount as "Dismounted" and will instantiate another CMountCB for formatting

    fmtMode = EFullFormat | EForceFormat; 

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); 

    test_KErrNone(nRes);

    nRes = DoFormatSteps(format, fmtCnt);

    test_KErrNone(nRes);

    format.Close();

	nRes=TheFs.CheckDisk(gSessionPath);

	test(nRes==KErrNone||nRes==KErrNotSupported);

    buf8.SetLength(22);

    nRes = file1.Write(buf8);

    test(nRes == KErrDisMounted);

    file1.Close();  //-- this will make the previously "Dismounted" mount die.

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

    //-- 3. check that forced formatting will complete NotifyDismount

    test.Printf(_L("Test forced formatting completes NotifyDismount\n"));

    TRequestStatus stat1;

    nRes = file1.Replace(TheFs, KFname, EFileWrite);

    test_KErrNone(nRes);

    TheFs.NotifyDismount(gDrive, stat1, EFsDismountRegisterClient);

    test(stat1.Int() == KRequestPending);

    fmtMode = EQuickFormat;

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt);

    test(nRes == KErrInUse);

    format.Close();

    test(stat1.Int() == KRequestPending);

    fmtMode = EQuickFormat | EForceFormat; 

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); 

    test_KErrNone(nRes);

    format.Close();

    User::WaitForRequest(stat1);

    test(stat1.Int() == KErrNone);

    buf8.SetLength(22);

    nRes = file1.Write(buf8);

    test(nRes == KErrDisMounted);

    file1.Close();  

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

    //-- 4.1 check that forced formatting will succeed with dirty file cache

    test.Printf(_L("Test forced formatting will succeed with dirty file cache\n"));

    nRes = file1.Replace(TheFs, KFname, EFileWrite | EFileWriteBuffered); //-- enable write caching

    test_KErrNone(nRes);

    buf8.SetLength(KBufLen);

    nRes = file1.Write(buf8); //-- this will hopefully get via file write cache

    test_KErrNone(nRes);

    fmtMode = EQuickFormat | EForceFormat; 

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); 

    test_KErrNone(nRes);

    format.Close();

    nRes = file1.Write(buf8);

    test(nRes == KErrDisMounted);

    file1.Close();  

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

    test.Printf(_L("Test forced formatting with disk access objects opened\n"));

    //-- 5.1 check that forced formatting will fail when there are "disk access" objects opened RFormat

    RFormat     format1;

    nRes = format1.Open(TheFs, drivePath, fmtMode, fmtCnt);

    test(nRes == KErrNone);

    fmtMode = EQuickFormat | EForceFormat; 

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); 

    test(nRes == KErrInUse);

    format.Close();

    format1.Close();

    //-- 5.1 check that forced formatting will fail when there are "disk access" objects opened RRawDisk

    RRawDisk    rawDisk;

    nRes = rawDisk.Open(TheFs, gDrive);

    test(nRes == KErrNone);

    fmtMode = EQuickFormat | EForceFormat; 

    nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); 

    test(nRes == KErrInUse);

    format.Close();

    rawDisk.Close();

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

    //-- 6. Try forced formatting with clamped files, this shall fail with KErrInuse

    test.Printf(_L("Test forced formatting and clamps on the volume\n"));

    nRes = file1.Replace(TheFs, KFname, EFileWrite);

    test_KErrNone(nRes);

    buf8.SetLength(KBufLen);

    nRes = file1.Write(buf8); //-- this will hopefully get via file write cache

    test_KErrNone(nRes);

    file1.Flush();

    //-- Clamp file

    RFileClamp handle;

    nRes=handle.Clamp(file1);

    if(nRes != KErrNone)

    {

        test.Printf(_L("file clamps on this drive are not supported\n"));

    }

    else

    {

        fmtMode = EQuickFormat | EForceFormat; 

        nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); 

        test(nRes == KErrInUse);

        format.Close();

    }

    handle.Close(TheFs);

    file1.Close();

    buf8.Close();

}

void CallTestsL()

//

// Call tests that may leave

//

	{

    TInt r;

    r = TheFs.CharToDrive(gDriveToTest, gDrive);

    test(r == KErrNone);

    //-- set up console output 

    F32_Test_Utils::SetConsole(test.Console()); 

    TInt nRes=TheFs.CharToDrive(gDriveToTest, gDrive);

    test(nRes==KErrNone);

    PrintDrvInfo(TheFs, gDrive);

    if(Is_Win32(TheFs, gDrive))

        return; //-- emulator drive c:

	SetSessionPath(_L("\\"));

	Test1();

	Test2();

	Test3();

	Test4();

	Test5();

	Test6();

	Test7();

	Test8();

    TestFormat_ForceDismount();

	r=TheFs.CheckDisk(gSessionPath);

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

	}