// Copyright (c) 1995-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:

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include "t_server.h"

#include "t_chlffs.h"

#include "fs_utils.h"

#include "f32_test_utils.h"

using namespace F32_Test_Utils;

RTest test(_L("T_FILE"));

TBool gShortFileNamesSupported = EFalse;

static TBuf8<1500> gBuf;

TInt gDriveNum = -1;

static void testShare()

//

// Test file sharing.

//

	{

	test.Start(_L("Test exclusive sharing"));

	MakeFile(_L("TESTER"));

/*

	Extra code to answer a question about a potential WINS bug.  WINS Elocal returns

	KErrAccessDenied to the write operation but EFat returns

	KErrNone...

	RFile f1;

	TInt r=f1.Open(TheFs,_L("TESTER"),EFileRead|EFileShareAny);

	test(r==KErrNone);

	RFile f2;

	r=f2.Open(TheFs,_L("TESTER"),EFileWrite|EFileShareAny);

	test(r==KErrNone);

	r=f2.Write(_L("0"));

	test.Printf(_L("returned %d"),r);

	f1.Close();

	f2.Close();

	r=TheFs.Delete(_L("TESTER"));

	test(r==KErrNone);

*/

	RFile f1;

	TInt r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

	test(r==KErrNone);

	RFile f2;

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

	test(r==KErrInUse);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrInUse);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

	test(r==KErrInUse);

	f1.Close();

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareExclusive);

	test(r==KErrNone);

	f1.Close();

	test.Next(_L("Test readers only sharing"));

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareReadersOnly);

	test(r==KErrArgument);

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

	test(r==KErrInUse);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

	test(r==KErrInUse);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareReadersOnly);

	test(r==KErrArgument);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone);

	f1.Close();

	f2.Close();

	test.Next(_L("Test any sharing"));

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareAny);

	test(r==KErrNone);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

	test(r==KErrInUse);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrInUse);

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

	test(r==KErrNone);

	f1.Close();

	f2.Close();

	test.End();

	}

static void testChangeMode()

//

// Test changing the share mode of a file between EFileShareReadersOnly <-> EFileShareExclusive

//

	{

	test.Start(_L("Test change mode"));

	RFile f1;

	RFile f2;

	TInt r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

	test(r==KErrNone); // Opened exclusive

	r=f1.ChangeMode(EFileShareReadersOnly);

	test(r==KErrNone); // Change to readers only

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone); // Open as reader

	r=f1.ChangeMode(EFileShareExclusive);

	test(r==KErrAccessDenied); // Change back to exclusive fails

	r=f2.ChangeMode(EFileShareExclusive);

	test(r==KErrAccessDenied); // Change to exclusive fails

	f1.Close(); // Close other reader

	r=f2.ChangeMode(EFileShareExclusive);

	test(r==KErrNone); // Change to exclusive succeeds.

	f2.Close();

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone); // Opened readers only

	r=f1.ChangeMode(EFileShareExclusive);

	test(r==KErrNone); // Change to exclusive

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrInUse); // Open as reader fails

	r=f1.ChangeMode(EFileShareReadersOnly);

	test(r==KErrNone); // Change to readers only

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone); // Open as reader

	r=f1.ChangeMode(EFileShareExclusive);

	test(r==KErrAccessDenied); // Change back to exclusive fails

	r=f2.ChangeMode(EFileShareExclusive);

	test(r==KErrAccessDenied); // Change to exclusive fails

	f1.Close(); // Close other reader

	r=f2.ChangeMode(EFileShareExclusive);

	test(r==KErrNone); // Change to exclusive succeeds.

	f2.Close();

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareExclusive);

	test(r==KErrNone); // Opened exclusive for writing

	r=f1.ChangeMode(EFileShareReadersOnly);

	test(r==KErrAccessDenied); // Change to readers fails

	r=f1.ChangeMode(EFileShareExclusive);

	test(r==KErrNone); // No change ok

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrInUse); // Open as reader fails

	f1.Close();

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

	test(r==KErrNone); // Opened share any

	r=f1.ChangeMode(EFileShareExclusive);

	test(r==KErrAccessDenied); // Change to exclusive fails

	r=f1.ChangeMode(EFileShareReadersOnly);

	test(r==KErrAccessDenied); // Change to readers only fails

	f1.Close();

	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

	test(r==KErrNone); // Opened exclusive

	r=f1.ChangeMode(EFileShareAny);

	test(r==KErrArgument); // Change to share any fails KErrArgument

	r=f1.ChangeMode((TFileMode)42);

	test(r==KErrArgument); // Change to random value fails

	f1.Close();

	test.End();

	}

static void testReadFile()

//

// Test read file handling.

//

	{

	test.Start(_L("Test read file"));

	RFile f,ZFile;

	TInt r=f.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText);

	test(r==KErrNone);

	TFileName fn = _L("Z:\\TEST\\T_FILE.CPP");

	fn[0] = gExeFileName[0];

	r=ZFile.Open(TheFs,fn,EFileStreamText);

	test(r==KErrNone);

	test.Next(_L("Read file"));

	TBuf8<0x100> a,b;

	FOREVER

		{

		r=f.Read(b);

		test(r==KErrNone);

		r=ZFile.Read(a);

		test(r==KErrNone);

		test(a==b);

		if (b.Length()<b.MaxLength())

			break;

		}

	b.SetLength(10);

	r=f.Read(b);

	test(r==KErrNone);

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

	f.Close();

	ZFile.Close();

	test.Next(_L("Read way beyond the end of the file"));

	r=f.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText);

	test(r==KErrNone);

	r=f.Read(3000000,gBuf);

	test(r==KErrNone);

	f.Close();

	test.Next(_L("Write way beyond the end of the file"));

	r=f.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite);

	test(r==KErrNone);

	gBuf.SetLength(10);

	r=f.Write(3000000,gBuf);

	test(r==KErrNone);

	f.Close();

	test.End();

	}

static void testMultipleReadFile()

//

// Test multiple read file handling.

//

	{

	test.Start(_L("Test multiple read file"));

	RFile f1;

	TInt r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone);

	RFile f2;

	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone);

	test.Next(_L("Read file"));

	FOREVER

		{

		TBuf8<0x100> b1;

		r=f1.Read(b1);

		test(r==KErrNone);

		TBuf8<0x100> b2;

		r=f2.Read(b2);

		test(r==KErrNone);

		test(b1==b2);

		if (b1.Length()<b1.MaxLength())

			break;

		}

	test.Next(_L("Close file"));

	f1.Close();

	f2.Close();

	test.End();

	}

static void testWriteFile()

//

// Test write file handling.

//

	{

	test.Start(_L("Test write file"));

	RFile file;

	TFileName fn = _L("File.File");

	TBuf8<16> testData=_L8("testData");

	// write test 1

	TInt r=file.Replace(TheFs,fn,EFileStreamText);

	test(r==KErrNone);

	test.Next(_L("Write file"));

	r=file.Write(testData);

	test(r==KErrNone);

	file.Close();

	// test write modes

	// test writing with EFileRead

	r=file.Open(TheFs,fn,EFileStreamText|EFileRead);

	test(r==KErrNone);

	test.Next(_L("Write file"));

	r=file.Write(testData);

	test(r==KErrAccessDenied);

	file.Close();

	// test writing with EFileWrite

	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite);

	test(r==KErrNone);

	test.Next(_L("Write file"));

	r=file.Write(testData);

	test(r==KErrNone);

	file.Close();

	// test writing with share mode EFileShareExclusive

	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite|EFileShareExclusive);

	test(r==KErrNone);

	test.Next(_L("Write file"));

	r=file.Write(testData);

	test(r==KErrNone);

	file.Close();

	// test writing with share mode EFileShareReadersOnly (fails with KErrArgument)

	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite|EFileShareReadersOnly);

	test(r==KErrArgument);

	// test writing with share mode EFileShareReadersOrWriters

	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite|EFileShareReadersOrWriters);

	test(r==KErrNone);

	test.Next(_L("Write file"));

	r=file.Write(testData);

	test(r==KErrNone);

	file.Close();

	// test writing with share mode EFileShareAny

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

	test(r==KErrNone);

	test.Next(_L("Write file"));

	r=file.Write(testData);

	test(r==KErrNone);

	file.Close();

	// tidy up

	r=TheFs.Delete(fn);

	test(r==KErrNone);

	test.End();

	}

static void CopyFileToTestDirectory()

//

// Make a copy of the file in ram

//

	{

	TFileName fn = _L("Z:\\TEST\\T_FILE.CPP");

	fn[0] = gExeFileName[0];

	TParse f;

	TInt r;

	r=TheFs.Parse(fn,f);

	test(r==KErrNone);

	TParse fCopy;

	r=TheFs.Parse(f.NameAndExt(),fCopy);

	test(r==KErrNone);

	RFile f1;

	r=f1.Open(TheFs,f.FullName(),EFileStreamText|EFileShareReadersOnly);

	test(r==KErrNone);

	RFile f2;

	r=f2.Replace(TheFs,fCopy.FullName(),EFileWrite);

	test(r==KErrNone);

	TBuf8<512> copyBuf;

	TInt rem;

	r=f1.Size(rem);

	test(r==KErrNone);

	TInt pos=0;

	while (rem)

		{

		TInt s=Min(rem,copyBuf.MaxSize());

		r=f1.Read(pos,copyBuf,s);

		test(r==KErrNone);

		test(copyBuf.Length()==s);

		r=f2.Write(pos,copyBuf,s);

		test(r==KErrNone);

		pos+=s;

		rem-=s;

		}

	f1.Close();

	f2.Close();

	}

static void testFileText()

//

// Test TFileText class methods

//

	{

	test.Next(_L("Test file text"));

	TPtrC record[5];

	record[0].Set(_L("First record"));

	record[1].Set(_L("Second record"));

	record[2].Set(_L("Third record"));

	record[3].Set(_L("Fourth record"));

	record[4].Set(_L("Fifth record"));

	RFile f;

	TInt r=f.Replace(TheFs,_L("TEXTFILE.TXT"),0);

	test(r==KErrNone);

	TFileText textFile;

	textFile.Set(f);

	TInt i=0;

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

		{

		r=textFile.Write(record[i]);

		test(r==KErrNone);

		}

	r=textFile.Seek(ESeekStart);

	test(r==KErrNone);

	TBuf<16> recBuf;

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

		{

		r=textFile.Read(recBuf);

		test(r==KErrNone);

		test(recBuf==record[i]);

		}

	r=textFile.Read(recBuf);

	test(r==KErrEof);

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

	f.Close();

	test.Next(_L("Test dosfile terminator"));

	TPtrC8 trecord[7];

	TPtrC tTextrecord[7];

	tTextrecord[0].Set(_L("First record\r\n"));

	tTextrecord[1].Set(_L("Second record\r\n"));

	tTextrecord[2].Set(_L("Third record\r\n"));

	tTextrecord[3].Set(_L("Fourth record\r\n"));

	tTextrecord[4].Set(_L("Fifth record\r\n"));

	tTextrecord[5].Set(_L("Sixth record\n\r"));

	tTextrecord[6].Set(_L("Seventh record\n"));

	trecord[0].Set((TUint8*)tTextrecord[0].Ptr(),tTextrecord[0].Length()*sizeof(TText));

	trecord[1].Set((TUint8*)tTextrecord[1].Ptr(),tTextrecord[1].Length()*sizeof(TText));

	trecord[2].Set((TUint8*)tTextrecord[2].Ptr(),tTextrecord[2].Length()*sizeof(TText));

	trecord[3].Set((TUint8*)tTextrecord[3].Ptr(),tTextrecord[3].Length()*sizeof(TText));

	trecord[4].Set((TUint8*)tTextrecord[4].Ptr(),tTextrecord[4].Length()*sizeof(TText));

	trecord[5].Set((TUint8*)tTextrecord[5].Ptr(),tTextrecord[5].Length()*sizeof(TText));

	trecord[6].Set((TUint8*)tTextrecord[6].Ptr(),tTextrecord[6].Length()*sizeof(TText));

	r=f.Replace(TheFs,_L("TEXTFILE.TXT"),0);

	test(r==KErrNone);

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

		{

		TBuf8<256> buf;

		buf.Copy(trecord[i]);

		r=f.Write(buf);

		test(r==KErrNone);

		}

	textFile.Set(f);

	textFile.Seek(ESeekStart);

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

		{

		r=textFile.Read(recBuf);

		test(r==KErrNone);

		test(recBuf==record[i]);

		}

	r=textFile.Read(recBuf);

	test(r==KErrNone);

	test(recBuf==_L("Sixth record"));

	r=textFile.Read(recBuf);

	test(r==KErrNone);

	test(recBuf==_L("\rSeventh record"));

	r=textFile.Read(recBuf);

	test(r==KErrEof);

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

	f.Close();

	test.Next(_L("Test read with bufferSize == dataSize"));

	r=f.Replace(TheFs,_L("TEXTFILE.TXT"),0);

	test(r==KErrNone);

	record[0].Set(_L("1234567890123456"));

//	trecord[0].Set(_L8("1234567890123456\r\n"));

//	trecord[1].Set(_L8("1234567890123456\n"));

	TPtrC tmpTextrecord;

	tmpTextrecord.Set(_L("1234567890123456\r\n"));

	trecord[0].Set((TUint8*)tmpTextrecord.Ptr(),tmpTextrecord.Length()*sizeof(TText));

	tmpTextrecord.Set(_L("1234567890123456\n"));

	trecord[1].Set((TUint8*)tmpTextrecord.Ptr(),tmpTextrecord.Length()*sizeof(TText));

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

		{

		r=f.Write(trecord[i]);

		test(r==KErrNone);

		}

	textFile.Set(f);

	textFile.Seek(ESeekStart);

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

		{

		r=textFile.Read(recBuf);

		test(r==KErrNone);

		test(recBuf==record[0]);

		}

	r=textFile.Read(recBuf);

	test(r==KErrEof);

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

	f.Close();

	test.Next(_L("Read into a buffer < recordSize"));

	TBuf<8> smallBuf;

	r=f.Open(TheFs,_L("TEXTFILE.txt"),0);

	test(r==KErrNone);

	textFile.Set(f);

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

		{

		r=textFile.Read(smallBuf);

		test(r==KErrTooBig);

		test(smallBuf==_L("12345678"));

		}

	f.Close();

	test.Next(_L("Nasty cases: 1) \\r \\n split over buffer boundary"));

	r=f.Replace(TheFs,_L("TEXTFILE.txt"),0);

	test(r==KErrNone);

	HBufC* largeRecord=HBufC::NewL(600);

	largeRecord->Des().SetLength(250);

	largeRecord->Des().Fill('A');

	largeRecord->Des()[249]='\n';

	TPtrC8 bufPtr;

	bufPtr.Set((TUint8*)largeRecord->Ptr(),largeRecord->Size()); // Size() returns length in bytes