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

 // //File Name:	f32test/server/t_file64bit.cpp

 // //Description:This file contains implementation for checking the 64bit file

 // //			server functionality. All the affected APIs are tested.

 // //While generating a file for reading, the contents are generated such that 

 // //every four bytes of the file contains its location. So the file would be

 // //generated as:

 // // 0000: 00 00 00 00 

 // // 0004: 04 00 00 00

 // // 0008: 08 00 00 00

 // // .. etc

 // 

 //

 #include <f32file.h>

 #include <e32test.h>

 #include <e32svr.h>

 #include "t_server.h"

 #include "t_file64bit.h"

 #include "..\\fileshare\\handshare64bit.h"

 #include <f32pluginutils.h>

 #include <massstorage.h>

 #include <e32math.h>

 #include "f32_test_utils.h"

 using namespace F32_Test_Utils;

 RTest test(_L("T_FILE64BIT Tests"));

 _LIT(KTestPath,  ":\\F32-TST\\TFILE64BIT\\");

 // to test any file system that supports file sizes of greater than 4GB -1, 

 // this value shall be set.

 TBool KFileSizeMaxLargerThan4GBMinusOne = EFalse;

 TInt GenerateBigFileContents()

 	{

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

 	TInt r;

     const TUint KBufSize = 256*K1KiloByte;

     RBuf8 buf;

     r = buf.CreateMax(KBufSize);

     test(r == KErrNone);

     RFile64 file;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GBMinusOne.txt"));

 	r = file.Replace(TheFs,fileName, EFileWrite);

 	test(r == KErrNone);

     r = file.SetSize(K4GBMinusOne);

 	test(r == KErrNone);

 	TInt64 nNumberOfBytesToWrite = 0;

 	TInt64 nNumberOfBytesWritten = 0;

 	for (TInt64 pos = 0; pos < K4GBMinusOne; pos += nNumberOfBytesWritten)

 		{

 		// Prepare the write buffer

 		for (TUint n = 0; n<KBufSize; n += 4)

 			{

             *((TUint*) &buf[n]) = I64LOW(pos + n);

 			}

 		nNumberOfBytesToWrite = Min(MAKE_TINT64(0,KBufSize), K4GBMinusOne - pos);

         TPtrC8 pText(buf.Ptr(), KBufSize);

 		file.Write(pText, (TInt)nNumberOfBytesToWrite);

         nNumberOfBytesWritten = nNumberOfBytesToWrite; 

 		}

 	r = file.Flush();

 	test(r == KErrNone);

 	test.Printf(_L("\nFile writing is completed!!"));

 	file.Close();

     buf.Close();

     return KErrNone;

 	}

 TInt RFileHandleSharer64Bit::Connect()

 	{

 	return CreateSession(KServerName, TVersion(1,0,0));

 	}

 TInt RFileHandleSharer64Bit::Exit()

 	{

 	return SendReceive(EMsgExit, TIpcArgs(NULL));

 	}

 TInt RFileHandleSharer64Bit::SetTestDrive(TInt aDrive)

 	{

 	return SendReceive(EMsgDrive, TIpcArgs(aDrive));

 	}

 TInt RFileHandleSharer64Bit::PassFileHandleProcessLargeFileClient(TIpcArgs& aIpcArgs)

 	{

 	return SendReceive(EMsgPassFileHandleProcessLargeFileClient, aIpcArgs);

 	}

 TInt RFileHandleSharer64Bit::PassFileHandleProcessLargeFileCreator()

 	{

 	return SendReceive(EMsgPassFileHandleProcessLargeFileCreator);

 	}

 TInt RFileHandleSharer64Bit::GetFileHandleLargeFile2(TInt &aHandle, TFileMode aFileMode)

 	{

 	TPckgBuf<TInt> fh;

 	TInt fsh = SendReceive(EMsgGetFileHandleLargeFile, TIpcArgs(&fh, aFileMode));

 	aHandle = fh();

 	return fsh;

 	}

 void RFileHandleSharer64Bit::Sync()

 	{

 	SendReceive(EMsgSync, TIpcArgs());

 	}	

 CFileManObserver::CFileManObserver(CFileMan* aFileMan)

 	{

 	__DECLARE_NAME(_S("CFileManObserver"));

 	iFileMan = aFileMan;

 	}

 MFileManObserver::TControl CFileManObserver::NotifyFileManStarted()

 	{

 	return(MFileManObserver::EContinue);

 	}

 MFileManObserver::TControl CFileManObserver::NotifyFileManOperation()

 	{

 	return(MFileManObserver::EContinue);

 	}

 MFileManObserver::TControl CFileManObserver::NotifyFileManEnded()

 	{

 	TInt lastError = iFileMan->GetLastError();

 	TFileName fileName = iFileMan->CurrentEntry().iName;

 	test.Printf(_L("NotifyFileManEnded(): Error %d File %S\n"),lastError, &fileName);

 	if (lastError == KErrNone)

 		iNotifyEndedSuccesses++;

 	else

 		iNotifyEndedFailures++;

 	return(MFileManObserver::EContinue);

 	}

 RFsTest& RFsTest::Replace(const TDesC &anOldName, const TDesC &aNewName)

 //

 // Replaces a single file with another

 //

 	{

 	test.Printf(_L("%S File Replaced with %S\n"),&anOldName,&aNewName);\

 	TInt r = TheFs.Replace(anOldName,aNewName);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFsTest& RFsTest::ReadFileSection(const TDesC& aName, TInt64 aPos,TDes8& aBuffer,TInt aLen)

 //

 // Reads data from the file without opening it. Expected not to fail.

 //

 	{

 	test.Printf(_L("Read File Section %S\n"),&aName);

 	TInt r = TheFs.ReadFileSection(aName,aPos,aBuffer,aLen);

 	TInt len = aBuffer.Length();

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if(aPos < K4GB) 

 			test(r == KErrNone);

 		else

 			{

 			test(r == KErrNone);

 			test(len == 0);				

 			}

 		}

 	else

 		{

 		test (r == KErrNone);	

 		}

 	return(*this);

 	}

 RFsTest& RFsTest::GetDir(const TDesC &aName, TUint anEntryAttMask, TUint anEntrySortKey, CDir *&anEntryList)

 //

 // Gets a filtered list of a directory's contents.

 //

 	{

 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);	

 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFsTest& RFsTest::GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList)

 //

 // Gets a filtered list of the directory and the file entries contained in a directory and a

 // list of the directory entries only.

 	{

 	test.Printf(_L("Name of the directory for which directory and file listing is required %S\n"),&aName);	

 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList,aDirList);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFsTest& RFsTest::GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList)

 //

 // Gets a filtered list of directory contents by UID type.

 //

 	{

 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);	

 	TInt r = TheFs.GetDir(aName,anEntryUid,anEntrySortKey,aFileList);

 	test(r == KErrNone);

 	return(*this);	

 	}

 RFileTest::RFileTest(const TDesC& aName)

 //

 // Constructor

 //

 	: iName(aName)

 	{}

 RFileTest& RFileTest::Create(const TDesC& aName, TUint aFileMode)

 //

 // Creates and opens a new file for writing, if the file already exists an error is returned

 //

 	{

 	test.Printf(_L("%S create %S in %d Mode\n"),&iName,&aName,aFileMode);

 	TInt r = RFile64::Create(TheFs,aName,aFileMode);

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

 	return(*this);		

 	}

 RFileTest& RFileTest::Replace(const TDesC& aName)

 //

 // Opens a file for writing, replacing the content of any existing file of the same name

 // if it exists or cretaing a new file if it does not exist.

 //

 	{

 	test.Printf(_L("%S replace %S\n"),&iName,&aName);

 	TInt r = RFile64::Replace(TheFs,aName,EFileStream|EFileWrite);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::Replace(const TDesC& aName, TUint aFileMode)

 //

 // Opens a file in aFileMode, replacing the content of any existing file of the same name

 // if it exists or cretaing a new file if it does not exist.

 //

 	{

 	test.Printf(_L("%S replace %S in %d Mode\n"),&iName,&aName, aFileMode);

 	TInt r = RFile64::Replace(TheFs,aName,aFileMode);

 	if (r == KErrNone)

 		test(r == KErrNone);

 	else

 		test(r == KErrBadName);

 	return(*this);		

 	}

 RFileTest& RFileTest::Open(const TDesC& aName)

 //

 // Open a existing file for reading and writing in shared access mode.

 //

 	{

 	test.Printf(_L("%S open %S\n"),&iName,&aName);

 	TInt r = RFile64::Open(TheFs,aName,EFileWrite|EFileShareAny);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::Open(const TDesC& aName, TUint aFileMode)

 //

 // Opens an existing file using aFileMode.

 //

 	{

 	test.Printf(_L("%S open %S in %d Mode\n"),&iName,&aName, aFileMode);

 	TInt r = RFile64::Open(TheFs,aName,aFileMode);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::Temp(const TDesC& aPath,TFileName& aName,TUint aFileMode)

 //

 // Creates and opens a temporary file with a unique name for writing and reading.

 //

 	{

 	test.Printf(_L("%S Temp file %S in %d Mode\n"),&iName,&aName, aFileMode);

 	TInt r = RFile64::Temp(TheFs,aPath,aName,aFileMode);	

 	test(r == KErrNone);

 	return(*this);

 	}

 void RFileTest::Close()

 //

 // Closes the file.

 //

 	{

 	RFile::Close();

 	}

 RFileTest& RFileTest::Lock(TInt64 aPos, TInt64 aLen)

 //

 // Set a lock on the file. Expected not to fail.

 //

 	{

 	test.Printf(_L("%S lock   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Lock(aPos,aLen);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::LockE(TInt64 aPos, TInt64 aLen)

 //

 // Set a lock on the file. Expected to fail.

 //

 	{

 	test.Printf(_L("%S lockE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Lock(aPos,aLen);

 	test(r == KErrLocked);

 	return(*this);

 	}

 RFileTest& RFileTest::UnLock(TInt64 aPos, TInt64 aLen)

 //

 // Unlock the file. Expected not to fail.

 //

 	{

 	test.Printf(_L("%S ulock  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::UnLock(aPos,aLen);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::UnLockE(TInt64 aPos, TInt64 aLen)

 //

 // Unlock the file. Expected to fail.

 //

 	{

 	test.Printf(_L("%S ulockE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::UnLock(aPos,aLen);

 	test(r == KErrNotFound);

 	return(*this);

 	}

 RFileTest& RFileTest::Write(const TDesC8& aDes)

 //

 // Write to the file.

 //

 	{

 	test.Printf(_L("%S write\n"),&iName);

 	TInt64 seekPos = 0;

 	TInt rr = RFile64::Seek(ESeekCurrent,seekPos);

 	test(rr == KErrNone);

 	TInt r = RFile64::Write(aDes);

 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.

 		r = RFile64::Flush(); 		

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if((seekPos + aDes.Length()) < K4GB)

 			test(r == KErrNone);

 		else

 			test(r == KErrNotSupported);

 		}

 	else

 		{

 		test (r == KErrNone);	

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::Write(const TDesC8 &aDes, TRequestStatus &aStatus)

 //

 // Write to the file.

 //

 	{

 	test.Printf(_L("%S write\n"),&iName);

 	TInt64 seekPos = 0;

 	TInt rr = RFile64::Seek(ESeekCurrent,seekPos);

 	test(rr == KErrNone);

 	RFile64::Write(aDes, aStatus);

 	User::WaitForRequest(aStatus);

 	if( KErrNone == aStatus.Int())	// this is to ensure that the written data is committed and not cached.

 		{

 		RFile64::Flush(aStatus); 

 		User::WaitForRequest(aStatus);

 		}

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if((seekPos + aDes.Length()) < K4GB)

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

 		else

 			test(aStatus.Int() == KErrNotSupported);

 		}

 	else

 		{

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

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::Write(const TDesC8& aDes, TInt aLength)

 //

 // Write aLength specified number of bytes to the file.

 //

 	{

 	test.Printf(_L("%S write\n"),&iName);

 	TInt64 seekPos = 0;

 	TInt rr = RFile64::Seek(ESeekCurrent,seekPos);

 	test(rr == KErrNone);

 	TInt r = RFile64::Write(aDes, aLength);

 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.

 		r = RFile64::Flush(); 		

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if((seekPos + aLength) < K4GB)

 			test(r == KErrNone);

 		else

 			test(r == KErrNotSupported);

 		}

 	else

 		{

 		test(r == KErrNone);

 		}

 	return(*this);	

 	}	

 RFileTest& RFileTest::Write(const TDesC8& aDes, TInt aLength, TRequestStatus &aStatus)	

 //

 // Write aLength specified number of bytes to the file. Expected not to fail (Asynchronous).

 //

 	{

 	test.Printf(_L("%S write\n"),&iName);

 	TInt64 seekPos = 0;

 	TInt rr = RFile64::Seek(ESeekCurrent,seekPos);

 	test(rr == KErrNone);

 	RFile64::Write(aDes,aLength,aStatus);

 	User::WaitForRequest(aStatus);

 	if( KErrNone == aStatus.Int())	// this is to ensure that the written data is committed and not cached.

 		{

 		RFile64::Flush(aStatus);

 		User::WaitForRequest(aStatus);	

 		}

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if((seekPos + aLength) < K4GB)

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

 		else	

 			test(aStatus.Int() == KErrNotSupported);

 		}

 	else

 		{

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

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::WriteP(TInt64 aPos, const TDesC8& aDes)

 //

 // Write to the file. Expected not to fail.

 //

 	{

 	test.Printf(_L("%S write  0x%lx\n"),&iName,aPos);

 	TInt r = RFile64::Write(aPos,aDes);

 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.

 		r = RFile64::Flush();

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if ((aPos + aDes.Length()) < K4GB)

 			test(r == KErrNone);

 		else

 			test(r == KErrNotSupported);

 		}

 	else

 		{

 		test(r == KErrNone);

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes)

 //

 // Write to the file. Expected not to fail.

 // Position is a TUint value

 //

 	{

 	test.Printf(_L("%S write  %08x\n"),&iName,aPos);

 	TInt r = RFile64::Write(aPos,aDes);

 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.

 		r = RFile64::Flush();

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen)

 //

 // Write to the file. Synchronous Expected not to fail.

 //

 	{

 	test.Printf(_L("%S write  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Write(aPos,aDes,aLen);

 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.

 		r = RFile64::Flush();

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if ((aPos + aLen) < K4GB)

 			{

 			if (aLen < 0)

 				test(r == KErrArgument);

 			else

 				test(r == KErrNone);

 			}

 		else

 			test(r == KErrNotSupported);

 		}

 	else

 		{

 		if (aLen < 0)

 			test(r == KErrArgument);

 		else

 			test(r == KErrNone);

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes, TInt aLen)

 //

 // Write to the file. Synchronous Expected not to fail.

 // Position is a TUint value

 //

 	{

 	test.Printf(_L("%S write  %08x-%08x\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Write(aPos,aDes,aLen);

 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.

 		r = RFile64::Flush();

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::WriteE(TInt64 aPos, const TDesC8& aDes, TInt aLen)

 //

 // Write to the file. Expected to fail.

 //

 	{

 	test.Printf(_L("%S writeE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Write(aPos,aDes,aLen);

 	if (aLen < 0)

 		test(r == KErrArgument);

 	else

 		test(r == KErrLocked);

 	return(*this);

 	}

 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen, TRequestStatus &aStatus)

 // 

 // Write to the file. Asynchronous

 	{

 	test.Printf(_L("%S write  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	RFile64::Write(aPos,aDes,aLen,aStatus);

 	User::WaitForRequest(aStatus);

 	if( KErrNone == aStatus.Int())	// this is to ensure that the written data is committed and not cached.

 		{

 		RFile64::Flush(aStatus);

 		User::WaitForRequest(aStatus);	

 		}

 	if(aLen < 0)

 		test(aStatus.Int() == KErrArgument);

 	else

 		{

 		if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 			{

 			if((aPos + aLen) < K4GB)

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

 			else

 				test(aStatus.Int() == KErrNotSupported);

 			}

 		else

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

 		}

 	return(*this);	

 	}

 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TRequestStatus &aStatus)

 //

 // Write to the file (Asynchronous).

 	{

 	test.Printf(_L("%S write  0x%lx\n"),&iName,aPos);

 	RFile64::Write(aPos,aDes,aStatus);

 	User::WaitForRequest(aStatus);

 	if( KErrNone == aStatus.Int())	// this is to ensure that the written data is committed and not cached.

 		{

 		RFile64::Flush(aStatus);

 		User::WaitForRequest(aStatus);	

 		}

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if((aPos + aDes.Length()) < K4GB)

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

 		else

 			test(aStatus.Int() == KErrNotSupported);

 		}

 	else

 		{

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

 		}

 	return(*this);	

 	}

 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes, TRequestStatus &aStatus)

 //

 // Write to the file (Asynchronous).

 // Position is a TUint value

 //

 	{

 	test.Printf(_L("%S write  %08x\n"),&iName,aPos);

 	RFile64::Write(aPos,aDes,aStatus);

 	User::WaitForRequest(aStatus);

 	if( KErrNone == aStatus.Int())	// this is to ensure that the written data is committed and not cached.

 		{

 		RFile64::Flush(aStatus);

 		User::WaitForRequest(aStatus);	

 		}

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

 	return(*this);	

 	}

 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes, TInt aLen, TRequestStatus &aStatus)

 // 

 // Write to the file. Asynchronous

 // Position is a TUint value

 //

 	{

 	test.Printf(_L("%S write  %08x-%08x\n"),&iName,aPos,aPos+aLen-1);

 	RFile64::Write(aPos,aDes,aLen,aStatus);

 	User::WaitForRequest(aStatus);

 	if( KErrNone == aStatus.Int())	// this is to ensure that the written data is committed and not cached.

 		{

 		RFile64::Flush(aStatus);

 		User::WaitForRequest(aStatus);	

 		}

 	if(aLen < 0)

 		test(aStatus.Int() == KErrArgument);

 	else

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

 	return(*this);	

 	}

 RFileTest& RFileTest::Read(TDes8& aDes) 

 //

 // Read from the file. Expected not to fail (Synchronous).

 //

 	{

 	test.Printf(_L("%S read \n"),&iName);

 	TInt r = RFile64::Read(aDes);

 	test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::Read(TDes8& aDes, TRequestStatus& aStatus) 

 //

 // Read from the file. Expected not to fail (Asynchronous).

 //

 	{

 	TInt64 size = 0;

 	test.Printf(_L("%S read \n"),&iName);

 	RFile64::Read(aDes, aStatus);

 	User::WaitForRequest(aStatus);

 	TInt len = aDes.Length();

 	TInt rr = RFile64::Size(size);

 	test(rr == KErrNone);

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if(size < K4GB)

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

 		else

 			{

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

 			test(len == 0);	

 			}

 		}

 	else

 		{

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

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::Read(TDes8& aDes,TInt aLen,TRequestStatus& aStatus) 

 //

 // Read from the file. Expected not to fail (Asynchronous).

 //

 	{

 	TInt64 size = 0;

 	test.Printf(_L("%S read \n"),&iName);

 	RFile64::Read(aDes,aLen,aStatus);

 	User::WaitForRequest(aStatus);

 	TInt len = aDes.Length();

 	TInt rr = RFile64::Size(size);

 	test(rr == KErrNone);

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if(size < K4GB)

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

 		else

 			{

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

 			test(len == 0);	

 			}

 		}

 	else

 		{

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

 		}	

 	return(*this);

 	}

 RFileTest& RFileTest::Read(TDes8 &aDes, TInt aLen)

 //

 // Read from the file. Expected not to fail (Synchronous).

 //

 	{

 	test.Printf(_L("%S read 0x%08x bytes\n"),&iName,aLen);

 	TInt r = RFile64::Read(aDes,aLen);

 	if(aLen < 0)

 		test(r == KErrArgument);

 	else

 		test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen) 

 //

 // Read from the file. Expected not to fail (Synchronous).

 //

 	{

 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Read(aPos,aDes,aLen);

 	TInt len = aDes.Length();

 	if(aLen < 0)

 		test(r == KErrArgument);

 	else 

 		test(r == KErrNone);

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{	

 		if(aPos >= K4GB) 

 			test(len == 0);

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::ReadE(TInt64 aPos, TDes8& aDes, TInt aLen) 

 //

 // Reads the specified number of bytes from the file at a specified offset. Expected to fail.

 //

 	{

 	test.Printf(_L("%S readE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Read(aPos,aDes,aLen);

 	test(r == KErrLocked);

 	return(*this);

 	}

 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus) 

 //

 // Reads the specified number of bytes from the file at a specified offset, Expected not to fail (Asynchronous).

 //

 	{

 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	RFile64::Read(aPos,aDes,aLen,aStatus);

 	User::WaitForRequest(aStatus);

 	TInt len = aDes.Length();

 	if(aLen < 0)

 		test(aStatus.Int() == KErrArgument);

 	else

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

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if(aPos >= K4GB) 

 			test(len == 0);		

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::ReadP(TInt64 aPos, TDes8& aDes)

 //

 // Reads from the file at the specfied offset with in the file (Synchronous).

 //

 	{

 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);

 	TInt r = RFile64::Read(aPos,aDes);

 	test(r == KErrNone);

 	return(*this);	

 	}

 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes)

 //

 // Reads from the file at the specfied offset with in the file (Synchronous).

 // Offset is specified as a TUint value.

 //

 	{

 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);

 	TInt r = RFile64::Read(aPos,aDes);

 	test(r == KErrNone);

 	return(*this);	

 	}

 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes,TRequestStatus& aStatus)

 //

 // Reads from the file at the specfied offset with in the file (Asynchronous).

 // Offset is specified as a TUint value.

 //

 	{

 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);

 	RFile64::Read(aPos,aDes,aStatus);

 	User::WaitForRequest(aStatus);

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

 	return(*this);

 	}

 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes, TInt aLen) 

 //

 // Read from the file. Expected not to fail (Synchronous).

 // Offset is specified as a TUint value.

 //

 	{

 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	TInt r = RFile64::Read(aPos,aDes,aLen);

 	if(aLen < 0)

 		test(r == KErrArgument);

 	else 

 		test(r == KErrNone);

 	return(*this);

 	}

 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus) 

 //

 // Reads the specified number of bytes from the file at a specified offset, Expected not to fail (Asynchronous).

 // Offset is specified as a TUint value.

 //

 	{

 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);

 	RFile64::Read(aPos,aDes,aLen,aStatus);

 	User::WaitForRequest(aStatus);

 	if(aLen < 0)

 		test(aStatus.Int() == KErrArgument);

 	else

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

 	return(*this);

 	}

 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TRequestStatus& aStatus)

 //

 // Reads from the file at the specfied offset with in the file (Asynchronous).

 //

 	{

 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);

 	RFile64::Read(aPos,aDes,aStatus);

 	User::WaitForRequest(aStatus);

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

 	return(*this);

 	}

 RFileTest& RFileTest::SetSize(TInt64 aSize)

 //

 // Set the size of the file. Expected not to fail.

 //

 	{

 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);

 	TInt r = RFile64::SetSize(aSize);

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if(aSize < K4GB)

 			test(r == KErrNone);

 		else

 			test(r == KErrNotSupported);

 		}

 	else

 		{

 		test(r == KErrNone);

 		}

 	return(*this);

 	}

 RFileTest& RFileTest::SetSizeE(TInt64 aSize)

 //

 // Set the size of the file. Expected to fail.

 //

 	{

 	test.Printf(_L("%S sizeE: 0x%lx\n"),&iName,aSize);

 	TInt r = RFile64::SetSize(aSize);

 	test(r == KErrLocked);

 	return(*this);

 	}

 RFileTest& RFileTest::Size(TInt64& aSize)

 //

 // Gets the current file size. Expected not to fail.

 //

 	{

 	TInt r = RFile64::Size(aSize);

 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);

     if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		if(aSize < K4GB)

 			test(r == KErrNone);

 		else

 			test(r == KErrTooBig);

 		}

 	else

 		{

 		test(r == KErrNone);

 		}

 	return(*this);	

 	}

 RFileTest& RFileTest::Seek(TSeek aMode, TInt64& aPos)

 //

 // Sets the current file position. Expected not to fail.

 //

 	{

 	test.Printf(_L("Seek to pos %LD in %d Mode\n"),aPos, aMode);

 	TInt r = RFile64::Seek(aMode, aPos);

 	if(aPos < 0)

 		test(r == KErrArgument);

 	else

 		test(r == KErrNone);

 	return(*this);	

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0756

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Test opening a large file = 2GB in size

 @SYMTestActions     

 1) Gets the entry details for a file using RFs::Entry(). The original file size=2GB

 2) Open a large file whose size = 2GB, with File Mode = EFileRead

 3) Close the file

 @SYMTestExpectedResults

 1) File size = 2GB

 2) KErrNone, File open successful

 3) File closed successfully

 @SYMTestStatus      Implemented

 */

 void TestOpen2GB()

 	{

 	TEntry entry;

 	TInt64 testSize, size = 0;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File2GB.txt"));

 	testSize = K2GB;

 	test.Next(_L("Create the file using RFile64::Replace and set the size and close"));

 	TestRFile1.Replace(fileName);

 	TestRFile1.SetSize(testSize);

 	TestRFile1.Close();

 	test.Next(_L("2GB File: Open"));

 	TInt r = TheFs.Entry(fileName, entry);

 	test(r == KErrNone);

 	test((TUint) entry.iSize == testSize);

     TestRFile1.Open(fileName, EFileRead);

 	TestRFile1.Size(size);

 	test(size == testSize);

 	TestRFile1.Close();

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0757

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Test opening a large file = 3GB in size

 @SYMTestActions     

 1) Gets the entry details for a file using RFs::GetEntry(). The original file size=3GB

 2) Open a large file whose size = 3GB, with File Mode = EFileRead

 3) Close the file

 @SYMTestExpectedResults

 1) File size = 3GB

 2) KErrNone, File open successful

 3) File closed successfully

 @SYMTestStatus      Implemented

 */

 void TestOpen3GB()

 	{

 	TInt r;

 	TEntry entry;

 	TInt64 testSize, size = 0;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File3GB.txt"));

 	testSize = K3GB;

 	test.Next(_L("Create the file using RFile64::Replace and set the size and close"));

 	TestRFile1.Replace(fileName);

 	TestRFile1.SetSize(testSize);

 	TestRFile1.Close();

 	test.Next(_L("3GB File: Open"));

 	r = TheFs.Entry(fileName, entry);

 	test(r == KErrNone);

 	test((TUint) entry.iSize == testSize);

 	TestRFile1.Open(fileName,EFileRead);

 	TestRFile1.Size(size);

 	test(size == testSize);

 	TestRFile1.Close();

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0758

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Test opening a large file < 4GB in size

 @SYMTestActions     

 1) Gets the entry details for a file using RFs::GetEntry(). The original file size=4GB-1

 2) Open a large file whose size = 4GB-1, with File Mode = EFileRead

 3) Close the file

 @SYMTestExpectedResults

 1) File size = 4GB-1

 2) KErrNone, File open successful

 3) File closed successfully

 @SYMTestStatus      Implemented

 */

 void TestOpen4GBMinusOne()

 	{

 	TInt r;

 	TEntry entry;

 	TInt64 testSize, size = 0;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GBMinusOne.txt"));

 	testSize = K4GB-1;

 	test.Next(_L("Create the file using RFile64::Replace and set the size and close"));

 	TestRFile1.Replace(fileName);

 	TestRFile1.SetSize(testSize);

 	TestRFile1.Close();

 	test.Next(_L("4GB-1 File: Open"));

 	r = TheFs.Entry(fileName, entry);

 	test(r == KErrNone);

 	test((TUint) entry.iSize == testSize);

 	TestRFile1.Open(fileName, EFileRead);

 	TestRFile1.Size(size);

 	test(size == testSize);

 	TestRFile1.Close();

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0759

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Test opening a large file 4GB in size

 @SYMTestActions     

 1) Gets the entry details for a file using RFs::GetEntry(). The original file size=4GB

 2) Open a large file whose size = 4GB, with File Mode = EFileRead

 3) Close the file

 @SYMTestExpectedResults

 1) File size = 4GB

 2) KErrNone, File open successful

 3) File closed successfully

 @SYMTestStatus      Implemented

 */

 void TestOpen4GB()

 	{

 	TInt r;

 	TEntry entry;

 	TInt64 testSize, size = 0;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GB.txt"));

 	testSize = K4GB;

 	test.Next(_L("Create the file using RFile64::Replace and set the size and close"));

 	TestRFile1.Replace(fileName);

 	TestRFile1.SetSize(testSize);

 	TestRFile1.Close();

 	test.Next(_L("4GB File: Open"));

 	r = TheFs.Entry(fileName, entry);

 	test(r == KErrNone);

 	if ((TUint) entry.iSize == testSize)

 		{

 		TestRFile1.Open(fileName, EFileRead);

 		TestRFile1.Size(size);

 		test(size == testSize);

 		TestRFile1.Close();

 		}

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}	

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0760

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests opening a large file > 2GB in size

 @SYMTestActions     

 1) Create a new file named "File4GBMinusOne.txt"

 2) Open the file with file mode = EFileWrite

 3) Set the file size to 4GB-1

 4) Write few bytes to the file and close

 5) Close the file

 6) Open the file "File4GBMinusOne.txt"

 7) If FAT32 file system, set the file size to 4GB

 8) Close the file

 9) Open the file with file mode = EDeleteOnClose

 @SYMTestExpectedResults

 1) File creation successful with KErrNone

 2) File open successful with KErrNone

 3) KErrNone, Sets the file size to 4GB-1

 4) KErrNone, write is successful and file closed successfully

 5) File closed successfully

 6) KErrNone, file open successful

 7) KErrNotSupported. For next generation file system KErrNone is expected

 8) File closed successfully

 9) File open failed with KErrArgument

 @SYMTestStatus      Implemented

 */

 void TestOpenMoreThan2GB()

 	{

 	// constants and literals

 	test.Next(_L("\nTest Files of size more than 2GB\n"));

 	TInt64 			size;

 	TBuf8<KBUFSIZE> readBuf;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GBMinusOne.txt"));

 	test.Start(_L("Test to create a large file > 2GB\n"));

 	TestRFile1.Replace(fileName);

 	test.Next(_L("Set the file size to 4GB-1\n"));

 	size = K4GBMinusOne;

 	TestRFile1.SetSize(size);

 	TBuf8<10> writeBuf;

 	writeBuf.Zero();

 	for(TInt count = 0; count < 10; count++)

 		{

 		writeBuf.Append(count);

 		}

    	test.Next(_L("Write 10 bytes to the file\n"));

 	TestRFile1.Write(0, writeBuf, 10);	

 	test.Next(_L("Read 10 bytes from position 0\n"));

 	TestRFile1.Read(0, readBuf, 10); 

 	test(writeBuf == readBuf);

 	TInt64 s;

 	TestRFile1.Size(s);

 	if(s < K4GB)

 		{

 		test.Printf(_L("\nFile size is less than 4 GB !!!!\n"));	

 		}

 	TestRFile1.Close();

 	test.Next(_L("Open the file File4GBMinusOne.txt\n"));

 	TestRFile1.Open(fileName);

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)	

 		{

 		test.Next (_L("Set the file size to 4GB\n"));

 		size = K4GB;

 		TestRFile1.SetSize(size);

 		}

 	TestRFile1.Close();

 	RFile64 file64;

 	TInt r = file64.Open(TheFs,fileName,EDeleteOnClose);

 	test (r == KErrArgument);

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0761

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests opening a file using RFile and RFile64 in file sharing mode

 @SYMTestActions     

 1) Create a file using RFile::Replace()

 2) Open the file using RFile::Open()  and file mode = EFileShareAny

 3) Write 100 bytes to the file and close the file

 4) Open the same file using RFile64::Open() and file mode = EFileShareAny

 5) Set the file size to 4GB-1 using RFile64::SetSize().

 6) Get the file size using RFile::Size()

 7) Seek to the file position 2GB+5 using RFile::Seek()

 8) Get the file size using RFile64::Size()

 9) Seek to the file position 4GB-10 using RFile64::Seek()

 10) Read from the file position 4GB-10 using RFile::Read() of length 5 bytes

 11) Close the file.

 12) Open the file using RFile::Open().

 13) Open the file using RFile64::Open() and close the file.

 @SYMTestExpectedResults

 1) File created successful with KErrNone.

 2) File opened successfully with KErrNone.

 3) Write successful with KErrNone.

 4) File opened successfully with KErrNone.

 5) File size set successfully with KErrNone.

 6) Fail with KErrNotSupported.

 7) Seek operation fail with KErrArgument.

 8) FileSize == 4GB-1.

 9) KErrNone.

 10) Read fail with KErrNotSupported.

 11) File closed successfully.

 12) File Open failed with KErrTooBig.

 13) File open successfully with KErrNone and file closed successfully.

 @SYMTestStatus      Implemented

 */

 void TestOpenRFileRFile64()

 	{

 	RFile file;

 	TInt size;

 	TInt64 size64;

 	TInt count;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GBMinusOne.txt"));

 	test.Start(_L("Test opening a file using RFile and RFile64 in file sharing mode\n"));

 	TInt r = file.Replace(TheFs,fileName,EFileShareAny|EFileWrite);

 	test(r == KErrNone);

 	TBuf8<100> writeBuf;

 	TBuf8<100> readBuf;

 	writeBuf.Zero();

 	for(count = 0; count < 100; count++)

 		{

 		writeBuf.Append(count);

 		}

    	test.Next(_L("Write 100 bytes to the file\n"));

 	r = file.Write(0, writeBuf, 100);	

 	test(r == KErrNone);

 	test.Next(_L("Read 100 bytes from position 0"));

 	r = file.Read(0, readBuf, 100); 

 	test(r == KErrNone);

 	test.Next(_L("Compare the read data to the written data"));

 	test(readBuf == writeBuf);

 	test.Next(_L("Open the same file using RFile64::Open"));

 	TestRFile1.Open(fileName,EFileShareAny|EFileWrite);

 	test.Next(_L("Set the file size to 4GB-1\n"));

 	TestRFile1.SetSize(K4GBMinusOne);

 	test.Next(_L("Query the file size using Rfile::Size()\n"));

 	r = file.Size(size);

 	test (r == KErrTooBig);

 	test.Next(_L("Seek to the file position using 2GB+5 using RFile::Seek()\n"));

 	TUint seekPos1 = K2GB + 5;

 	TInt seekPos  = (TInt)seekPos1;

 	r = file.Seek(ESeekStart,seekPos);

 	test(r == KErrArgument);

 	test.Next(_L("Get the file size using RFile64::Size()\n"));

 	TestRFile1.Size(size64);

 	test.Next(_L("Seek to the file position 4GB-10 using RFile64::Seek()\n"));

 	TInt64 seekPos64 = K4GB - 10;

 	TestRFile1.Seek(ESeekStart,seekPos64);

 	TBuf8<5> writeBuf64;

 	TBuf8<5> readBuf64;

 	writeBuf64.Zero();

 	for(count = 0; count < 5; count++)

 		{

 		writeBuf64.Append(count);

 		}

 	test.Next(_L("Read from the file position 4GB-10 using RFile::Read() of length 5 bytes\n"));

 	TestRFile1.Write(seekPos64,writeBuf64,5);

 	TestRFile1.Seek(ESeekStart,seekPos64);

 	TestRFile1.Read(seekPos64,readBuf64,5);

 	test(readBuf64 == writeBuf64);

 	TestRFile1.Close();

 	file.Close();

 	test.Next(_L("Open the file using Rfile::Open()\n"));

 	r = file.Open(TheFs,fileName,EFileShareAny|EFileWrite);

 	test(r == KErrTooBig);

 	test.Next(_L("Open the file using Rfile64::Open() and close\n"));

 	TestRFile1.Open(fileName,EFileShareAny|EFileWrite);

 	TestRFile1.Close();

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0762

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests the temporary file creation using RFile64::Temp()

 @SYMTestActions     

 1) Create a Temporary file using RFile64::Temp() in write mode and DeleteOnClose

 2) Set the file size to 4GB-1

 3) Write 100 bytes to the file at position 2GB+1

 4) Write 1 byte to file position 4GB-2

 5) Write 10 bytes to file position 0.

 6) Write 1 byte to file position 4GB+1

 7) Read and compare the data at position 2GB+1,4GB-2,0 and close the file

 8) Delete the temporary file.

 9) Create a temporary file using RFile64::Temp() in write mode and without DeleteOnClose flag

 10) Close the File

 11) Delete the temporary file

 @SYMTestExpectedResults

 1) Temporary file created successfully 

 2) File size = 4GB-1

 3) Write successful with KErrNone

 4) Write successful with KErrNone

 5) Write successful with KErrNone

 6) Write fail with KErrNotSupported

 7) Read data == written data

 8) KErrNotFound, since the file is already deleted on close

 9) File created successfully

 10) File closed

 11) File deleted successfully

 @SYMTestStatus      Implemented

 */

 void TestCreateTempFile()

 	{

 	TInt count;

 	TFileName testDir;

 	testDir.Append(gDriveToTest);

 	testDir.Append(KTestPath);

 	TInt r = TheFs.MkDir(testDir);

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

 	TFileName fileName;

 	TestRFile1.Temp(testDir, fileName, EFileWrite|EDeleteOnClose);

 	test.Next(_L("Set the file size to 4GB-1\n"));

 	TestRFile1.SetSize(K4GBMinusOne);

 	TInt64 size = 0;

 	TestRFile1.Size(size);

 	test (size == K4GBMinusOne);

 	TBuf8<0x64> writeBuf;

 	TBuf8<0x64> readBuf;

 	writeBuf.Zero();

 	for(count = 0; count < 100; count++)

 		{

 		writeBuf.Append(count);

 		}

 	TInt64 seekPos = K2GB + 1;

 	test.Next(_L("Write 100 bytes to the file at position 2GB+1\n"));

 	TestRFile1.Write(seekPos, writeBuf, 100);	

 	test.Next(_L("Read 100 bytes from position 2GB+1"));

 	TestRFile1.Read(seekPos, readBuf, 100); 

 	test(writeBuf == readBuf);

 	test.Next(_L("Write 1 byte to the file at position 4GB-2\n"));

 	TBuf8<01> writeBuf1Byte;

 	TBuf8<01> readBuf1Byte;

 	writeBuf1Byte.Zero();

 	writeBuf1Byte.Append(0);

 	seekPos = K4GBMinusTwo;

 	TestRFile1.Write(seekPos, writeBuf1Byte, 1);	

 	test.Next(_L("Read 1 byte from position 4GB-2"));

 	seekPos = K4GBMinusTwo;

 	TestRFile1.Read(seekPos, readBuf1Byte, 1); 

 	test(writeBuf1Byte == readBuf1Byte);

 	test.Next(_L("Write 10 bytes to the file at position 0\n"));

 	TBuf8<10> writeBuf10Byte;

 	TBuf8<10> readBuf10Byte;

 	writeBuf10Byte.Zero();

 	for(count = 0; count < 10; count++)

 		{

 		writeBuf10Byte.Append(count);

 		}

 	TestRFile1.Write(0, writeBuf10Byte, 10);	

 	test.Next(_L("Read 10 byte from position 0"));

 	TestRFile1.Read(0, readBuf10Byte, 10); 

 	test(writeBuf10Byte == readBuf10Byte);

 	test.Next(_L("Write 1 byte to the file at position 4GB+1\n"));

 	seekPos = K4GB + 1;

 	TestRFile1.Write(seekPos, writeBuf1Byte, 1);

 	TestRFile1.Close();

 	test.Next(_L("Delete the temporary file\n"));

 	r = TheFs.Delete(fileName);

 	test(r == KErrNotFound);

 	test.Next(_L("Create a temporary file using RFile64::Temp without EDeleteOnClose flag\n"));

 	TestRFile1.Temp(testDir, fileName, EFileWrite);

 	test.Next(_L("Close the file\n"));	

 	TestRFile1.Close();

 	test.Next(_L("Delete the temporary the file\n"));	

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0763

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests the file creation using RFile64::Create()

 @SYMTestActions     

 1) Create a file FileLargeOne.txt in write mode.

 2) Set the file size to 3GB-4KB

 3) Seek the file: Mode = ESeekEnd

 4) Write to a file with current position and length =4KB

 5) Get the file size.

 6) Write to a file at position 0 and length = 100 bytes.

 7) Write to a file at position 4GB -2 and length = 1 byte

 8) Write to a file at position 4GB -2 and length = 3 byte

 9) Read and compare the data written at position 0, 4GB-1

 10) Close the File.

 11) Create the file FileLargeOne.txt in write mode.

 12) Create a file with invalid path and file name.

 @SYMTestExpectedResults

 1) File created successfully with KErrNone 

 2) File size = 3GB-4KB

 3) KErrNone

 4) Write successful with KErrNone

 5) File size == 3GB

 6) Write successful with KErrNone

 7) Write successful with KErrNone

 8) Write fails with KErrNotSupported.

 9) Read data == written data.

 10) File closed successfully.

 11) File creation failed with KErrAlreadyExists

 12) File Creation failed with KErrPathNotFound.

 @SYMTestStatus      Implemented

 */

 void TestCreateRFile64()

 	{

 	TInt count;

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("FileLargeOne.txt"));

 	test.Next(_L("create a file named FileLargeOne.txt\n"));

 	TestRFile1.Create(fileName, EFileWrite);

 	test.Next(_L("set the file size to 3GB - 4KB\n"));

 	TestRFile1.SetSize(K3GB-K4KB);

 	TInt64 size = 0;

 	TestRFile1.Size(size);

 	test (size == K3GB-K4KB);

 	test.Next(_L("seek to the end of the file\n"));

 	TInt64 seekPos = 0;

 	TestRFile1.Seek(ESeekEnd,seekPos);

 	test(seekPos == K3GB-K4KB);	

 	test.Next(_L("write to the file current position and length = 4KB\n"));

 	TBuf8<4096> writeBufK4KB;

 	TBuf8<4096> readBufK4KB;

 	for (count = 0; count < 4096; count++)

 		{

 		writeBufK4KB.Append(count+1);

 		}

 	TestRFile1.Write(writeBufK4KB,K4KB);

 	test.Next(_L("read from the file from position K3GB-K4KB and length = 4KB\n"));

 	seekPos = K3GB - K4KB;

 	TestRFile1.Read(seekPos,readBufK4KB,K4KB);

 	test(writeBufK4KB == readBufK4KB);

 	test.Next(_L("get the size of the file\n"));

 	size = 0;

 	TestRFile1.Size(size);

 	test(size == K3GB);

 	test.Next(_L("write to the file at position 0 and length = 100bytes\n"));

 	TBuf8<0x64> writeBuf100B;

 	TBuf8<0x64> readBuf100B;

 	writeBuf100B.Zero();

 	for(count = 0; count < 100; count++)

 		{

 		writeBuf100B.Append(count);

 		}

 	seekPos = 0;

 	TestRFile1.Write(seekPos, writeBuf100B, 100);	

 	test.Next(_L("Read 100 bytes from position 0"));

 	TestRFile1.Read(seekPos, readBuf100B, 100); 

 	test(writeBuf100B == readBuf100B);

 	test.Next(_L("Write 1 byte to the file at position 4GB-2\n"));

 	TBuf8<01> writeBuf1Byte;

 	TBuf8<01> readBuf1Byte;

 	writeBuf1Byte.Zero();

 	writeBuf1Byte.Append(0);

 	seekPos = K4GBMinusTwo;

 	TestRFile1.SetSize(K4GB-1);

 	TestRFile1.Write(seekPos, writeBuf1Byte, 1);	

 	test.Next(_L("Read 1 byte from position 4GB-2"));

 	seekPos = K4GBMinusTwo;

 	TestRFile1.Read(seekPos, readBuf1Byte, 1); 

 	test(writeBuf1Byte == readBuf1Byte);

 	test.Next(_L("Write 3 bytes to the file at position 4GB-1\n"));

 	TBuf8<3> writeBuf3Byte;

 	writeBuf3Byte.Zero();

 	for(count = 0; count < 3; count++)

 		{

 		writeBuf3Byte.Append(count);

 		}

 	seekPos = K4GBMinusTwo;

 	TestRFile1.Write(seekPos, writeBuf1Byte, 3);	

 	TestRFile1.Close();

 	test.Next(_L("create a file named FileLargeOne.txt(KErrAlreadyExists)\n"));

 	TestRFile1.Create(fileName,EFileWrite);

 	test.Next(_L("create a file with InvalidPath and fileName\n"));	

 	RFile64 file64;

 	TInt r = file64.Create(TheFs, _L("C:\\InvalidPathName\\FileName"),EFileWrite);

 	test(r == KErrPathNotFound);

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}	

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0764

 @SYMTestPriority    High

 @SYMTestRequirement REQ9531 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests the file creation using RFile64::Replace()

 @SYMTestActions     

 1) Replace a file FileLargeOne.txt in write mode using RFile64::Replace.

 2) Set the file size to 4GB-1

 3) Write to a file with position = 4GB-4KB-2 and length = 4KB

 4) Get the file size

 5) Seek the file: Mode = ESeekEnd,pos = 0.

 6) Write to a file with current position, length = 1 byte

 7) Seek the file: Mode = ESeekStart

 8) Write to a file with current position and length = 4KB

 9) Seek the file: Mode = ESeekEnd

 10)Read from the current position and length = 1 byte and compare with written data

 11)Seek the file: Mode = ESeekStart

 12)Read the data from the current position and length = 4KB and compare with written data

 13)Close the file

 14)Replace a file FileLargeOne.txt in write mode

 15)Get the file size

 16)Close the file.

 17)Replace a file FileLargeOne.txt with invalid path

 @SYMTestExpectedResults

 1) File created successfully with KErrNone 

 2) File size = 4GB-1

 3) Write successful with KErrNone

 4) File size = 4GB-1

 5) KErrNone

 6) Write successful with KErrNone

 7) KErrNone

 8) Write successful with KErrNone

 9) KErrNone

 10)Written data == Read data

 11)KErrNone

 12)Written data == Read data

 13)File Closed

 14)File creatd successfully with KErrNone

 15)File size = 0

 16)File Closed

 17)File creation failed with KErrPathNotFound.

 @SYMTestStatus      Implemented

 */

 void TestReplaceRFile64()

 	{

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("FileLargeOne.txt"));

 	test.Next(_L("Replace a file named FileLargeOne.txt\n"));

 	TestRFile1.Replace(fileName, EFileWrite);

 	test.Next(_L("Set the size of the file to 4GB-1\n"));

 	TestRFile1.SetSize(K4GB-1);

 	TBuf8<4096> writeBufK4KB;

 	TBuf8<4096> readBufK4KB;	

 	for (TInt count = 0; count < 4096; count++)

 		{

 		writeBufK4KB.Append(count+1);

 		}

 	test.Next(_L("Write to a file with position = 4GB-4KB-2 and length = 4KB\n"));

 	TInt64 pos = K4GB-K4KB-2;

 	TestRFile1.Write(pos,writeBufK4KB,K4KB);

 	test.Next(_L("Read from 4GB-4KB-1 and compare data\n"));	

 	TestRFile1.Read(pos,readBufK4KB,K4KB);

 	test(writeBufK4KB == readBufK4KB);

 	test.Next(_L("Get the file size\n"));

 	TInt64 size = 0;

 	TestRFile1.Size(size);

 	test (size == K4GB-1);

 	test.Next(_L("Seek the file: Mode = ESeekEnd,pos = 0.\n"));

 	TInt64 seekPos = 0;

 	TestRFile1.Seek(ESeekEnd,seekPos);

 	test(seekPos == K4GB-1);

 	test.Next(_L("Write to a file with current position, length = 1 byte\n"));

 	TBuf8<1> writeBuf1B(_L8("0"));

 	TBuf8<1> readBuf1B;

     if(!KFileSizeMaxLargerThan4GBMinusOne)

         seekPos--;

     TestRFile1.Write(seekPos,writeBuf1B,1); //-- now seek pos is K4GB

 	test.Next(_L("Seek the file: Mode = ESeekStart\n"));	

 	seekPos = 0;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	test.Next(_L("Write to a file with current position and length = 4KB\n"));	

 	TestRFile1.Write(seekPos,writeBufK4KB,K4KB);

 	test.Next(_L("Seek the file: Mode = ESeekEnd\n"));	

 	seekPos = 0;

 	TestRFile1.Seek(ESeekEnd,seekPos);

     if(KFileSizeMaxLargerThan4GBMinusOne)

     {//-- file is larger than 4G-1

         test(seekPos == K4GB);

     }

 	else

     {

         test(seekPos == K4GB-1);

  	}

     seekPos--;

 	test.Next(_L("Read from pos = 4GB-1 and compare data\n"));	

 	TestRFile1.Read(seekPos,readBuf1B,1);

 	test(writeBuf1B == readBuf1B);	

 	test.Next(_L("Seek the file: Mode = ESeekStart\n"));	

 	seekPos = 0;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	test.Next(_L("Read from the file and compare written data\n"));	

 	TestRFile1.Read(seekPos,readBufK4KB,K4KB);

 	test (writeBufK4KB == readBufK4KB);

 	test.Next(_L("Close the file\n"));	

 	TestRFile1.Close();

 	test.Next(_L("Replace a file FileLargeOne.txt in write mode\n"));

 	TestRFile1.Replace(fileName, EFileWrite);

 	test.Next(_L("Get the file size\n"));

 	size = 0;

 	TestRFile1.Size(size);

 	test (size == 0);

 	test.Next(_L("Close the file\n"));	

 	TestRFile1.Close();

 	test.Next(_L("Replace a file FileLargeOne.txt with invalid path\n"));	

 	RFile64 file64;

 	TInt r = file64.Replace(TheFs,_L("C:\\InvalidPath\\FileLargeOne.Txt"),EFileWrite);

 	test (r == KErrPathNotFound);

 	r = TheFs.Delete(fileName);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0765

 @SYMTestPriority    High

 @SYMTestRequirement REQXXXX 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests the file replace using RFs::Replace()

 @SYMTestActions     

 1) Create a file named FileLargeOne.txt using RFile64::Replace()

 2) Set the file size to 3GB and get the file size

 3) Write 10 bytes to location 2GB+10 and close the file

 4) Replace the file named ReNameFileLargeOne.txt using RFs::Replace()

 5) Open the file ReNameFileLargeOne.txt

 6) Set the file size to 4GB-1

 7) Write 10 bytes to the location 3GB+10

 8) Read the above file from the location 3GB+10

 9) Compare the read and the written data

 10)Close the file

 @SYMTestExpectedResults

 1) File created successfully with KErrNone 

 2) File size = 3GB

 3) Write successful with KErrNone and file closed

 4) FileLargeOne.txt is replaced with ReNameFileLargeOne.txt successfully

 5) File ReNameFileLargeOne.txt is opened successfully

 6) KErrNone

 7) Write successful with KErrNone

 8) Read is successful with KErrNone

 9) Written data == Read data

 10)File Closed

 @SYMTestStatus      Implemented

 */

 void TestReplaceRFile64RFs()

 	{

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("FileLargeOne.txt"));

 	test.Next(_L("Replace a file named FileLargeOne.txt\n"));

 	TestRFile1.Replace(fileName, EFileWrite);

 	test.Next(_L("Set the file size to 3GB and get the file size\n"));

 	TestRFile1.SetSize(K3GB);

 	TInt64 size = 0;

 	TestRFile1.Size(size);

 	test (size == K3GB);

 	test.Next(_L("Write 10 bytes to location 2GB+10 and close the file\n"));

 	TBuf8<10> writeBuf;

 	TBuf8<10> readBuf;	

 	for (TInt count = 0; count < 10; count++)

 		{

 		writeBuf.Append(count+1);

 		}

 	TInt64 pos = K2GB+10;

 	TestRFile1.Write(pos,writeBuf,10);

 	TestRFile1.Read(pos,readBuf,10);

 	test(readBuf == writeBuf);

 	TestRFile1.Close();

 	test.Next(_L("Replace the file named ReNameFileLargeOne.txt using RFs::Replace()\n"));

 	TFileName fileNameReplace;

 	fileNameReplace.Append(gDriveToTest);

 	fileNameReplace.Append(KTestPath);

 	fileNameReplace.Append(_L("ReNameFileLargeOne.txt\n"));

 	TestRFs.Replace(fileName,fileNameReplace);

 	test.Next(_L("Open the file ReNameFileLargeOne.txt\n"));

 	TestRFile1.Open(fileNameReplace,EFileWrite);

 	test.Next(_L("Set the file size to 4GB-1\n"));

 	TestRFile1.SetSize(K4GB-1);

 	size = 0;

 	TestRFile1.Size(size);

 	test (size == K4GB-1);

 	test.Next(_L("Write 10 bytes to the location 3GB+10\n"));

 	pos = K3GB+10;

 	TestRFile1.Write(pos,_L8("ABCDEFGHIJ"),10);

 	test.Next(_L("Read the above file from the location 3GB+10 and compare\n"));

 	TBuf8<10> readBuffer;	

 	TestRFile1.Read(pos,readBuffer,10);

 	test(readBuffer == _L8("ABCDEFGHIJ"));

 	test.Next(_L("Close the file and delete\n"));

 	TestRFile1.Close();

 	TInt r = TheFs.Delete(fileNameReplace);

 	test(r == KErrNone);

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0766

 @SYMTestPriority    High

 @SYMTestRequirement REQXXXX

 @SYMTestType        CIT

 @SYMTestCaseDesc    Test the file creation using RFile64::AdoptFromClient()

 @SYMTestActions 

 1) Connect to the File server 

 2) Create a file and set the file size to 4GB-1

 3) Write few bytes to the location 4GB-10, length = 9bytes

 4) Transfer the file handle using TransferToServer() close the file

 5) Adopt the already open file from a client using RFile64::Adopt::AdoptFromClient()

 6) Read the file from position 4GB-10 and compare the data

 @SYMTestExpectedResults

 1) Connection successful

 2) File created successfully

 3) Write successful with KErrNone

 4) KErrNone, Transfer to server is successful

 5) successfully Allows the server to adopt an already open file from a client process

 6) File read should be successful and Read Data = Test Data

 @SYMTestStatus      Implemented

 */

 void TestRFile64AdoptFromClient()

 	{

 	test.Next(_L("Tests for checking RFile64::AdoptFromClient()"));

 	RProcess p;

 	TInt r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);

 	test(r == KErrNone);

 	test.Next(_L("Connect to the File server \n"));

 	RFs fs;

 	r = fs.Connect();

 	test(r == KErrNone);

 	// Check the number of open file handles

 	TInt resCount = fs.ResourceCount();

 	test(resCount == 0);

 	r = fs.ShareProtected();

 	test(r == KErrNone);

 	r = fs.CreatePrivatePath(gDrive);

 	test(r == KErrNone);

 	r = fs.SetSessionToPrivate(gDrive);

 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));

 	RFile64 file1;

 	r = file1.Replace(fs,KClientFileName,EFileWrite);

 	test(r == KErrNone);

 	r = file1.SetSize(K4GB-1);

 	test(r == KErrNone);

 	test.Next(_L("Write few bytes to the location 4GB-10, length = 9bytes\n"));

 	r = file1.Write(K4GB-10,KTestData3(),9);

 	test(r == KErrNone);

 	file1.Close();

 	r = p.SetParameter(3, gDrive);

 	test(r == KErrNone);

 	p.Resume();

 	test.Next(_L("Transfer the file handle using TransferToServer() close the file\n"));

 	RFileHandleSharer64Bit handsvr;

 	do

 		{

 		r = handsvr.Connect();

 		}

 	while(r == KErrNotFound);

 	test(r == KErrNone);

 	r = handsvr.SetTestDrive(gDrive);

 	test(r == KErrNone);

 	r = fs.SetSessionToPrivate(gDrive);

 	test(r == KErrNone);

 	r = file1.Open(fs,KClientFileName,EFileRead);

 	test(r == KErrNone);

 	// pass the file handle to FHServer

 	test.Next(_L("RFile::TransferToServer()"));

 	TIpcArgs ipcArgs;

 	r = file1.TransferToServer(ipcArgs, 0, 1);

 	test(r == KErrNone);

 	test.Next(_L("Adopt the already open file from a client using RFile64::AdoptFromClient()\n"));

 	r = handsvr.PassFileHandleProcessLargeFileClient(ipcArgs);

 	test(r == KErrNone);

 	// verify that the original file handle's position is unchanged

 	TInt64 pos = 0;

 	r = file1.Seek(ESeekCurrent, pos);

 	test(r == KErrNone);

 	test(pos == 0);

 	// make sure we can still use it

 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));

 	TBuf8<9> rbuf;

 	r = file1.Read(K4GB-10,rbuf);

 	test(r == KErrNone);

 	test (rbuf == KTestData3);

 	// Close the file

 	file1.Close();	

 	handsvr.Exit();

 	handsvr.Close();

 	r = fs.MkDir(_L("C:\\mdir"));

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

 	// Check the number of open file handles

 	resCount = fs.ResourceCount();

 	test(resCount == 0);

 	r = fs.Delete(KClientFileName);

 	test(r == KErrNone);

 	fs.Close();

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0767

 @SYMTestPriority    High

 @SYMTestRequirement REQXXXX

 @SYMTestType        CIT

 @SYMTestCaseDesc    Test the file creation using RFile64::AdoptFromCreator()

 @SYMTestActions 

 1) Create a process named "FHServer64Bit.exe"

 2) Connect to the File server 

 3) Create a file and set the file size to 4GB-1

 4) Write few bytes to the location 4GB-10, length = 3 bytes

 5) Transfer the file handle using TransferToProcess() close the file

 6) Resume the process "FHServer64bit.exe" 

 7) Adopts the already open file from a client using RFile64::AdoptFromCreator()

 8) Read the file from position 4GB-10 and compare the data

 @SYMTestExpectedResults

 1) Process is created successfully with KErrnone

 2) Connection successful

 3) File created successfully

 4) Write successful with KErrNone

 5) KErrNone, Transfer to other process is successful

 6) Server process should be resumed

 7) successfully Allows the server to adopt an already open file from a client process

 8) File read should be successful and Read Data = Test Data

 @SYMTestStatus      Implemented

 */

 void TestRFile64AdoptFromCreator()

 	{

 	TInt r;

 	test.Next(_L("Tests for checking RFile64::AdoptFromCreator()"));

 	//create test server

 	test.Next(_L("Create a process named FHServer64Bit.exe\n"));

 	RProcess p;

 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);

 	test(r == KErrNone);

 	test.Next(_L("Connect to the file server\n"));

 	RFs fs;

 	r = fs.Connect();

 	test(r == KErrNone);

 	// Check the number of open file handles

 	TInt resCount = fs.ResourceCount();

 	test(resCount == 0);

 	r = fs.ShareProtected();

 	test(r == KErrNone);

 	r = fs.CreatePrivatePath(gDrive);

 	test(r == KErrNone);

 	r = fs.SetSessionToPrivate(gDrive);

 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));

 	RFile64 file1;

 	r = file1.Replace(fs,KClientFileName,EFileWrite);

 	test(r == KErrNone);

 	r = file1.SetSize(K4GB-1);

 	test(r == KErrNone);

 	test.Next(_L("Write few bytes to the location 4GB-10, length = 3bytes\n"));

 	r = file1.Write(K4GB-10,KTestData2(),3);

 	test(r == KErrNone);

 	file1.Close();

 	r = file1.Open(fs, KClientFileName, EFileWrite);

 	test(r == KErrNone);

 	// NB slot 0 is reserved for the command line

 	test.Next(_L("Transfer the file handle using TransferToProcess() close the file"));

 	r = file1.TransferToProcess(p, 1, 2);

 	r = p.SetParameter(3, gDrive);

 	test(r == KErrNone);

 	r = fs.SetSessionToPrivate(gDrive);

 	test(r == KErrNone);

 	// make sure we can still read from the file

 	TBuf8<3> rbuf;

 	r = file1.Read(K4GB-10,rbuf,3);

 	test(r == KErrNone);

 	r = rbuf.CompareF(KTestData2());

 	test(r == KErrNone);

 	file1.Close();

 	r = fs.MkDir(_L("C:\\mdir"));

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

 	// Check the number of open file handles - 

 	// should be 1 (the one duplicated for the other process)

 	resCount = fs.ResourceCount();

 	test(resCount == 1);

 	fs.Close();

 	test.Next(_L("Resume the process FHServer64bit.exe "));

 // Start the server thread

 	p.Resume();

 // connect to the server

 	RFileHandleSharer64Bit handsvr;

 	do

 		{

 		r = handsvr.Connect();

 		}

 	while(r == KErrNotFound);

 	test(r == KErrNone);

 	r = handsvr.SetTestDrive(gDrive);

 	test(r == KErrNone);

 	// wait for server to read the file

 	r = handsvr.PassFileHandleProcessLargeFileCreator();

 	test (r == KErrNone);

 	// cleanup	

 	handsvr.Exit();

 	handsvr.Close();

 	p.Close();

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0768

 @SYMTestPriority    High

 @SYMTestRequirement REQXXXX

 @SYMTestType        CIT

 @SYMTestCaseDesc    Test the file creation using RFile64::AdoptFromServer()

 @SYMTestActions 

 1) Connect to the File server 

 2) Create a file and set the file size to 4GB-1

 3) Write few bytes to the location 4GB-10, length = 9bytes

 4) Adopt an already open file from a server using RFile64::AdoptFromServer()

 5) Read the file from position 4GB-10 and compare the data

 @SYMTestExpectedResults

 1) Connection successful

 2) File created successfully

 3) Write successful with KErrNone

 4) successfully Allows the client to adopt an already open file from a server process

 5) File read should be successful and Read Data = Test Data

 @SYMTestStatus      Implemented

 */

 void TestRFile64AdoptFromServer()

 	{

 	test.Next(_L("Tests for checking RFile64::AdoptFromServer()"));

 	TInt r;

 	test.Next(_L("Connect to the file server\n"));

 	RFs fs;

 	r = fs.Connect();

 	test(r == KErrNone);

 	// Check the number of open file handles

 	TInt resCount = fs.ResourceCount();

 	test(resCount == 0);

 	r = fs.ShareProtected();

 	test(r == KErrNone);

 	r = fs.CreatePrivatePath(gDrive);

 	test(r == KErrNone);

 	r = fs.SetSessionToPrivate(gDrive);

 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));

 	RFile64 file1;

 	r = file1.Replace(fs,KClientFileName,EFileWrite);

 	test(r == KErrNone);

 	r = file1.SetSize(K4GB-1);

 	test(r == KErrNone);

 	r = file1.Write(K4GB-10,KTestData3(),9);

 	test(r == KErrNone);

 	file1.Close();

 	r = fs.Delete(KClientFileName);

 	test(r == KErrNone);

 	RProcess p;

 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);

 	test(r == KErrNone);

 	// Request an open file (write mode) from the server

 	// using RFile64::AdoptFromServer()

 	test.Next(_L("Adopt an already open file from a server using RFile64::AdoptFromServer()\n"));

 	p.Resume();

 	RFileHandleSharer64Bit handsvr;

 	do

 		{

 		r = handsvr.Connect();

 		}

 	while(r == KErrNotFound);

 	test(r == KErrNone);

 	r = handsvr.SetTestDrive(gDrive);

 	test(r == KErrNone);

 	TInt ssh;

 	TInt fsh = handsvr.GetFileHandleLargeFile2(ssh, EFileWrite);

 	test (fsh >= 0);

 	// Closing the handle to the server ensures the server has closed it's

 	// RFs and RFile handles - this provides a means of testing whether we 

 	// can still adopt the RFile even if the server has closed it's one.

 	handsvr.Sync(); // make sure server has finished doing what it's doing

 	handsvr.Exit();

 	handsvr.Close();

 	// adopt the file handle from FHServer

 	test.Next(_L("RFile64::AdoptFromServer()"));

 	RFile64 file;

 	r = file.AdoptFromServer(fsh, ssh);

 	test(r == KErrNone);

 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));

 	TBuf8<9> rbuf;

 	r = file.Read(K4GB-10,rbuf);

 	test(r == KErrNone);

 	// server should write KTestData1 ("Server!!!") to file

 	test (rbuf == KTestData4);

 	TFileName fileName;

 	r = file.FullName(fileName);

 	test(r == KErrNone);

 	file.Close();

 	//cleanup

 	r = fs.Delete(fileName);

 	test(r == KErrNone);

 	TFileName sessionPath;

 	r = fs.SessionPath(sessionPath);

 	test(r == KErrNone);

 	r = fs.RmDir(sessionPath);

 	test(r == KErrNone);

 	fs.Close();

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0769

 @SYMTestPriority    High

 @SYMTestRequirement REQ9526 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests for reading a big file synchronously with specified position

 @SYMTestActions     

 1) Big file is read synchronously in a thread, with aPos = 0;

 2) Big file is read synchronously in a thread, with aPos = 2GB-1;

 3) Big file is read synchronously in a thread. With aPos = 4GB -2. File size= 4GB-1.

 4) Check for FAT32 file system, Read from a big file synchronously in a thread with aPos = 4GB.

 @SYMTestExpectedResults 

 1) KErrNone, file is read successfully

 2) KErrNone, file is read successfully

 3) KErrNone, file is read successfully

 4) KErrNone and zero length descriptor, if NGFS is supported we should get the valid data

 @SYMTestStatus      Implemented

 */

 void TestOpenAndReadSyncLargeFile()

 	{

 	const TUint KBufSize = KKB;

 	TUint 			pos;

 	TBuf8<KBufSize> readBuf1;

 	TBuf8<KBufSize> readBuf2;

 	TUint i;

 	TInt r = GenerateBigFileContents();

 	test(r == KErrNone);

 	test.Next(_L("Open & Read Synchronously Large File From Diff Offset:"));

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GBMinusOne.txt"));

 	TestRFile1.Open(fileName,EFileRead);

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 0\n"));

 	// Sync read from pos = 0

 	pos = 0; 

 	readBuf1.Zero();

 	TestRFile1.ReadP(pos, readBuf1);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf1[i - pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 2GB-1\n"));

 	// Sync read from pos = 2GB-1

 	pos = K2GB;

 	readBuf2.Zero();

 	TestRFile1.ReadP(pos, readBuf2);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf2[i - pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 4GB-2\n"));	

 	TBuf8<1> readBuffer;

 	pos = K4GBMinusTwo;

 	TestRFile1.ReadP(pos, readBuffer);

 	test(readBuffer.Length() == 1);

 	// tests need to be repeated for calling the TUint variant of RFile64::Read()

 	pos = 0;

 	TestRFile1.ReadU(pos, readBuf1);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf1[i - pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 2GB\n"));

 	// Sync read from pos = 2GB

 	pos = K2GB;

 	readBuf2.Zero();

 	TestRFile1.ReadU(pos, readBuf2);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf2[i - pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 4GB-2\n"));	

 	pos = K4GBMinusTwo;

 	TestRFile1.ReadU(pos, readBuffer);

 	test(readBuffer.Length() == 1);

 	// tests need to be repeated for calling the current position variant of RFile64::Read()

 	TInt64 seekPos = 0;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	TestRFile1.Read(readBuf1);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)seekPos; i< seekPos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf1[i - (TUint)seekPos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 2GB\n"));

 	// Sync read from pos = 2GB

 	seekPos = K2GB;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	readBuf2.Zero();

 	TestRFile1.Read(readBuf2);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)seekPos; i< seekPos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf2[i - (TUint)seekPos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 4GB-2\n"));	

 	seekPos = K4GBMinusTwo;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	TestRFile1.Read(readBuffer);

 	test(readBuffer.Length() == 1);

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)	

 		{

 		TInt64 pos64 = K4GB;

 		TestRFile1.ReadP(pos64, readBuf1);

 		test(readBuf1.Length() == 0);

 		}

 	TestRFile1.Close();

 	}

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0770

 @SYMTestPriority    High

 @SYMTestRequirement REQ9526 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests for reading a big file asynchronously with specified position

 @SYMTestActions     

 1) Big file is read asynchronously in a thread, with aPos = 0;

 2) Big file is read asynchronously in a thread, with aPos = 2GB-1;

 3) Big file is read asynchronously in a thread. With aPos = 4GB -1.

 4) Check for FAT32 file system, Read from a big file asynchronously in a thread with aPos = 4GB.

 @SYMTestExpectedResults 

 1) KErrNone, file is read successfully

 2) KErrNone, file is read successfully

 3) KErrNone, file is read successfully

 4) KErrNone and zero length descriptor. If NGFS is supported we should get the valid data.

 @SYMTestStatus      Implemented

 */

 void TestOpenAndReadAsyncLargeFile()

 	{

 	const TUint KBufSize = KKB;

 	TInt64  fileSize, size = 0;

 	TUint pos;

 	TUint i;

 	TBuf8<KBufSize> readBuf;

 	readBuf.SetLength(KBufSize);

 	test.Next(_L("Open & Read Asynchronously Large File From Diff Offset:"));

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GBMinusOne.txt"));

 	TestRFile1.Open(fileName,EFileRead);

 	test.Next(_L("Big file is read asynchronously in a thread, with aPos = 0\n"));

 	// Async read from pos = 0

 	TRequestStatus status1 = KRequestPending;

 	pos = 0;

 	TestRFile1.Read(pos, readBuf, status1);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - pos]);

 		test(i == j);

 		}	

 	test.Next(_L("Big file is read asynchronously in a thread, with aPos = 2GB-1\n"));

 	// Async read from pos = 2GB-1

 	TRequestStatus status2 = KRequestPending;

 	pos = K2GB;

 	TestRFile1.Read(pos, readBuf, status2);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read asynchronously in a thread, with aPos = 4GB-1\n"));

 	TBuf8<0x1> readBuf1;

 	// Async read from pos = 4GB-1

 	TRequestStatus status3 = KRequestPending;

 	pos = K4GBMinusTwo;

 	TestRFile1.Read(pos, readBuf1, status3);

 	test(readBuf1.Length() == 1);

 	fileSize = K4GBMinusOne;

 	TestRFile1.Size(size);

 	test(size == fileSize);

 	//tests need to be repeated for calling the TUint variant of RFile64::Read()

 	pos = 0;

 	TestRFile1.ReadU(pos, readBuf, status1);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - pos]);

 		test(i == j);

 		}	

 	test.Next(_L("Big file is read asynchronously in a thread, with aPos = 2GB-1\n"));

 	// Async read from pos = 2GB-1

 	status2 = KRequestPending;

 	pos = K2GB;

 	TestRFile1.ReadU(pos, readBuf, status2);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = pos; i< pos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read asynchronously in a thread, with aPos = 4GB-1\n"));

 	// Async read from pos = 4GB-1

 	status3 = KRequestPending;

 	pos = K4GBMinusTwo;

 	TestRFile1.ReadU(pos, readBuf1, status3);

 	test(readBuf1.Length() == 1);

 	// tests need to be repeated for calling the current position variant of RFile64::Read()

 	TInt64 seekPos = 0;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	TestRFile1.Read(readBuf, status1);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)seekPos; i< seekPos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - (TUint)seekPos]);

 		test(i == j);

 		}	

 	test.Next(_L("Big file is read asynchronously in a thread, with aPos = 2GB-1\n"));

 	// Async read from pos = 2GB-1

 	status2 = KRequestPending;

 	seekPos = K2GB;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	TestRFile1.Read(readBuf, status2);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)seekPos; i< seekPos + (KBufSize / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - (TUint)seekPos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read asynchronously in a thread, with aPos = 4GB-1\n"));

 	// Async read from pos = 4GB-1

 	status3 = KRequestPending;

 	seekPos = K4GBMinusTwo;

 	TestRFile1.Seek(ESeekStart,seekPos);

 	TestRFile1.Read(readBuf1, status3);

 	test(readBuf1.Length() == 1);

 	// Async read from pos = 4GB

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)

 		{

 		TRequestStatus status5 = KRequestPending;

 		TInt64 pos64;

 		pos64 = K4GB;

 		TestRFile1.Read(pos64, readBuf, status5);

 		test(readBuf.Length() == 0);

 		}

 	// Close the file	

 	TestRFile1.Close();

 	}		

 /**

 @SYMTestCaseID      PBASE-T_FILE64BIT-0771

 @SYMTestPriority    High

 @SYMTestRequirement REQ9526 

 @SYMTestType        CIT

 @SYMTestCaseDesc    Tests for reading a big file synchronously with specified position and length

 @SYMTestActions     

 1) Big file is read synchronously in a thread, with aPos = 0 and length = 256bytes

 2) Big file is read synchronously in a thread, with aPos = 2GB-1 and length = 2KB

 3) Big file is read synchronously in a thread, with aPos = 4GB -1 and length = 10 bytes

 4) Check for FAT32 file system. Read from a big file, synchronously in a thread with aPos = 4GB and length = 1KB

 5) Big file is read synchronously in a thread, with aPos = 0 and length = -1

 6) Big file is read synchronously in a thread, with aPos = 0 and length = 0 bytes

 @SYMTestExpectedResults 

 1) KErrNone, file is read successfully

 2) KErrNone, file is read successfully

 3) KErrNone, file is read successfully

 4) KErrNone, with zero length descriptor. If NGFS is supported we should get the valid data

 5) KErrArgument

 6) KErrNone

 @SYMTestStatus      Implemented

 */

 void TestOpenAndReadSyncLargeFileWithLen()

 	{

 	TInt64 pos;

 	TUint i;

 	TBuf8<KMAXBUFSIZE> readBuf;

 	readBuf.SetLength(KMAXBUFSIZE);

 	test.Next(_L("Open & Read Synchronously Large File From Different Offset and Length:"));

 	TFileName fileName;

 	fileName.Append(gDriveToTest);

 	fileName.Append(KTestPath);

 	fileName.Append(_L("File4GBMinusOne.txt"));

 	TestRFile1.Open(fileName,EFileRead);

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 0 and length = 256bytes:"));

 	// Sync read from pos = 0 and length = 256

 	pos = 0;

 	TestRFile1.Read(pos, readBuf, 256);

 	test(readBuf.Length() == 256);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)pos; i< pos + (256 / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - (TUint)pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 2GB and length = K2KB:"));

 	// Sync read from pos = 2GB and length = K2KB

 	pos = K2GB;

 	TestRFile1.Read(pos, readBuf, K2KB);

 	test(readBuf.Length() == K2KB);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)pos; i< pos + (K2KB / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - (TUint)pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 4GB -1 and length = 10:"));

 	// Sync read from pos = 4GB-1 and length = 10

 	pos = K4GBMinusTwo;

 	TestRFile1.Read(pos, readBuf, 10);

 	test(readBuf.Length() == 1); 

 	// Sync read from pos = 4GB and length = KKB

 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)	

 		{

 		pos = K4GB;

 		TestRFile1.Read(pos, readBuf, KKB);

 		test(readBuf.Length() == 0);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 0 and length = -1"));

 	// Sync read from pos = 0 and length = -1	

 	pos = 0;

 	TestRFile1.Read(pos, readBuf, -1);

 	//tests need to repeated for TUint variant of RFile64::Read()

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 0 and length = 256bytes:"));

 	// Sync read from pos = 0 and length = 256

 	pos = 0;

 	TestRFile1.ReadU((TUint)pos, readBuf, 256);

 	test(readBuf.Length() == 256);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)pos; i< pos + (256 / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - (TUint)pos]);

 		test(i == j);

 		}

 	test.Next(_L("Big file is read synchronously in a thread, with aPos = 2GB and length = K2KB:"));

 	// Sync read from pos = 2GB and length = K2KB

 	pos = K2GB;

 	TestRFile1.ReadU((TUint)pos, readBuf, K2KB);

 	test(readBuf.Length() == K2KB);

 	test.Next(_L("Compare the data read to the expected data\n"));

 	for(i = (TUint)pos; i< pos + (K2KB / 4); i+=4)

 		{

 		TUint j =  * ((TUint*) &readBuf[i - (TUint)pos]);