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

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include "t_server.h"

#include "t_file64bit.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_KErrNone(r);

    RFile64 file;

	TFileName fileName;

	fileName.Append(gDriveToTest);

	fileName.Append(KTestPath);

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

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

	test_KErrNone(r);

    r = file.SetSize(K4GBMinusOne);

	test_KErrNone(r);

	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_KErrNone(r);

	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_KErrNone(r);

	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();

	test_KErrNone(r);

	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse && aPos >= K4GB)

		{

		test_Equal(0, len);

		}

	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_KErrNone(r);

	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_KErrNone(r);

	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_KErrNone(r);

	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_Value(r, 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_KErrNone(r);

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

	test_Value(r, r == KErrNone || 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_KErrNone(r);

	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_KErrNone(r);

	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_KErrNone(r);

	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_KErrNone(r);

	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_Value(r, 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_KErrNone(r);

	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_Value(r, 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 r = RFile64::Seek(ESeekCurrent,seekPos);

	test_KErrNone(r);

	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_KErrNone(r);

			}

		else

			{

			test_Value(r, r == KErrNotSupported);

			}

		}

	else

		{

		test_KErrNone(r);	

		}

	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 r = RFile64::Seek(ESeekCurrent,seekPos);

	test_KErrNone(r);

	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_KErrNone(aStatus.Int());

			}

		else

			{

			test_Equal(KErrNotSupported, aStatus.Int());

			}

		}

	else

		{

		test_KErrNone(aStatus.Int());

		}

	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 r = RFile64::Seek(ESeekCurrent,seekPos);

	test_KErrNone(r);

	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_KErrNone(r);

			}

		else

			{

			test_Value(r, r == KErrNotSupported);

			}

		}

	else

		{

		test_KErrNone(r);

		}

	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 r = RFile64::Seek(ESeekCurrent,seekPos);

	test_KErrNone(r);

	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_KErrNone(aStatus.Int());

			}

		else

			{

			test_Equal(KErrNotSupported, aStatus.Int());

			}

		}

	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_KErrNone(r);

			}

		else

			{