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

//

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include <e32hal.h>

#include "t_server.h"

#include "t_chlffs.h"

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

GLDEF_D RTest test(_L("B_GEN"));

//

// File test - general test of local filing system routines

//             (finishes with formating current device).

// Modified from BB's epoc test code

#define MINIMUM_DATE (315532800L)

#define DateTests   10

// GLREF_D P_DEVICE p_file;

// GLREF_D P_DEVICE p_wind,p_screen,p_cons;

GLDEF_D TBuf<0x100> gNameBuf;

GLDEF_D	TBuf<0x100> gNameOut;

GLDEF_D RFile gFile;

GLDEF_D RFile gFileErr;

GLDEF_D RFile gFile2;

GLDEF_D RDir gDir;

GLDEF_D RFormat gFormat;

//GLDEF_D void *chan1,*chan2;

GLDEF_D TFileName fBuf;

//GLDEF_D TUint8 fBuf[P_FNAMESIZE];

LOCAL_D TBuf8<0x4000> gDataBuf;

LOCAL_D TEntry gFileEntry;

// LOCAL_D P_DINFO volInfo;

LOCAL_D TVolumeInfo volInfo;

// LOCAL_D P_NINFO nInfo;

LOCAL_D TFileName pathBuf;

LOCAL_D TInt NameErr=KErrBadName;

LOCAL_D TInt DirErr=KErrPathNotFound;

LOCAL_D TInt AccessErr=KErrAccessDenied;

LOCAL_D TInt LockedErr=KErrInUse;

LOCAL_D TInt ExistsErr=KErrAlreadyExists;

LOCAL_D TInt NotExistsErr=KErrNotFound;

LOCAL_D TInt EofErr=KErrEof;

LOCAL_D TInt DeviceErr=KErrNotReady;

//LOCAL_D TInt NoFileSystemErr=KErrNotReady;

//LOCAL_D TInt NotSupportedErr=KErrNotSupported;

LOCAL_D TInt ReadOnlyErr=KErrAccessDenied;

LOCAL_D TInt P_FASTREAM=EFileStream;

LOCAL_D TInt P_FAEXEC=0;

LOCAL_D TInt P_FAMOD=KEntryAttArchive;

LOCAL_D TInt P_FAREAD=KEntryAttReadOnly;

//LOCAL_D TInt P_FAHIDDEN=KEntryAttHidden;

//LOCAL_D TInt P_FASYSTEM=KEntryAttSystem;

//LOCAL_C TInt P_FAVOLUME=KEntryAttVolume;

LOCAL_C TInt P_FADIR=KEntryAttDir;

LOCAL_C TInt P_FRANDOM=0;

LOCAL_C TInt P_FABS=ESeekStart;

LOCAL_C TInt P_FUPDATE=EFileWrite;

LOCAL_C void doError(const TDesC &aMess, TInt anErr, TInt line)

	{ 

    test.Printf(_L("%S failed at line %d. Error %d\n"),&aMess, line, anErr);

    test(0);

	}

#define Error(aMess, anErr) doError(aMess, anErr, __LINE__)

LOCAL_C void doError2(const TDesC &aMess, TInt anErr, TInt line, TInt callLine)

	{ 

    test.Printf(_L("%S failed at line %d. Error %d. Called from line %d\n"),&aMess, line, anErr, callLine); \

    test(0);

	}

#define Error2(aMess, anErr, line) doError2(aMess, anErr, __LINE__, line)

LOCAL_C void testWrite(const TDesC& aName,TInt aLen,TInt32 aSize,TBool aShouldChange)

//

// Write to a file

//

    {

	TTime saveTime;

	TInt c;

	test.Printf(_L("Write %u bytes %u\n"),aLen,aShouldChange);

	if ((c=TheFs.Entry(aName,gFileEntry))!=KErrNone)

		Error(_L("File info 600"),c);

	saveTime=gFileEntry.iModified;

	User::After(3000000L); // 30 tenths of a sec = 30 00000 micro seconds

	if ((c=gFile.Open(TheFs,aName,EFileWrite))!=KErrNone)

		Error(_L("Open 50"),c);

	if ((c=gFile.Write(gDataBuf,aLen))!=KErrNone)

		Error(_L("Write"),c);

	gFile.Close();

	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)

		Error(_L("File info 601"),c);

	if ((saveTime!=gFileEntry.iModified)!=aShouldChange)

		Error(_L("Change flag check 6"),0);

	if (gFileEntry.iSize!=aSize)

		Error(_L("Size check 602"),0);

    }

LOCAL_C void testSetEof(const TDesC& aName,TUint32 aPos,TBool aShouldChange)

//

// Set the end of a file

//

	{

	TTime saveTime;

	TInt c;

	test.Printf(_L("Set EOF to %u %u\n"),aPos,aShouldChange);

	if ((c=TheFs.Entry(aName,gFileEntry))!=KErrNone)

		Error(_L("File info 500"),c);

	saveTime=gFileEntry.iModified;

	User::After(3000000L);

	if ((c=gFile.Open(TheFs,aName,EFileWrite))!=KErrNone)

		Error(_L("Open 50"),c);

	if ((c=gFile.SetSize(aPos))!=KErrNone)

		Error(_L("Set EOF 50"),c);

	gFile.Close();

	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)

		Error(_L("File info 501"),c);

	if ((saveTime!=gFileEntry.iModified)!=aShouldChange)

		Error(_L("Change flag check 5"),0);

	}

LOCAL_C void testDir(const TDesC& aDirName)

//

// Create a directory

//

    {

	TInt c;

	test.Printf(_L("Test dir %S\n"),&aDirName);

	c=gDir.Open(TheFs,aDirName,KEntryAttNormal);

	if (c!=KErrNone)

		Error(_L("Directory open 1000"),c);

	gDir.Close();

	TChar drive(aDirName[0]);

	TInt driveNo;

	c=RFs::CharToDrive(drive,driveNo);

	test(c==KErrNone);

	if ((c=TheFs.Volume(volInfo,driveNo))!=KErrNone)

		Error(_L("Device info 1000"),c);

    }

/*

LOCAL_C void testNodeInfo(const TDesC& aName,TInt type,TInt anErr)

//

// Test p_ninfo.

//

    {

//    TInt c;

	test.Printf(_L("Node info: %S\n"),&aName);

//	if ((c=p_ninfo(aDirName,&nInfo))!=anErr)

//		Error(_L("Device info"),c);

	if (anErr==0)

		{

//		if (!(nInfo.version==2 || nInfo.version==3))

//			Error(_L("Node version check"),0);

//		if (nInfo.type!=type)

//			Error(_L("Node type check"),0);

		}

    }

*/

LOCAL_C void testDeviceInfo(const TDesC& aDeviceName,TInt anErr)

//

// Test p_dinfo.

//

    {

	TInt c;

	test.Printf(_L("Device info: %S\n"),&aDeviceName);

	TInt drive=KDefaultDrive;

	if (aDeviceName.Length())

		{

		c=RFs::CharToDrive(aDeviceName[0],drive);

		test(c==KErrNone);

		}		

	if ((c=TheFs.Volume(volInfo,drive))!=anErr)

		Error(_L("Device info"),c);

	if (anErr==0)

		{

//		if (!(volInfo.version==2 || volInfo.version==3)) ********* version is not a member of TVolumeInfo

//			Error(_L("Device version check"),0);

		if (volInfo.iFree>volInfo.iSize)

			Error(_L("Free greater than size check"),0);

		}

    }

LOCAL_C void testFileInfo(const TDesC& aFileName,TInt anErr)

//

// Test entry info

//

	{

	TInt c;

	test.Printf(_L("File info: %S\n"),&aFileName);

	if ((c=TheFs.Entry(aFileName,gFileEntry))!=anErr)

		Error(_L("Get info 100"),c);

	if (anErr==0)

		{

		if (aFileName.Length()>=2 && aFileName[0]=='Z' && aFileName[1]==':')

			{

			if ((gFileEntry.iAtt&(P_FAREAD|P_FAEXEC|P_FASTREAM)) != (TUint32)(P_FAREAD|P_FAEXEC|P_FASTREAM) && gFileEntry.iAtt!=KEntryAttDir)

				Error(_L("Info status check Z:\\"),0);

			}

		else

			{

			if (gFileEntry.iAtt&KEntryAttDir)

				return; // Found directory entry

			if (gFileEntry.iAtt!=(TUint32)(P_FASTREAM|P_FAMOD))

				Error(_L("Info status check"),0);

			if (gFileEntry.iSize!=0L)

				Error(_L("Info size check"),0);

			}

		}

	}

LOCAL_C void testRenameFromRoot(const TDesC& aRName,const TDesC& aDName)

//

//

//

	{

	TInt c;

	if ((c=TheFs.Rename(aRName,aDName))!=KErrNone)

		Error(_L("Rename 92"),c);

	if ((c=gFile.Open(TheFs,aDName,EFileStream))!=KErrNone)

		Error(_L("Open 92"),c);

	gFile.Close();

	if ((c=TheFs.Delete(aRName))!=NotExistsErr)

		Error(_L("Delete 92"),c);

	}

LOCAL_C void testRenameToRoot(const TDesC& pName,const TDesC& rName)

//

//

//

	{

	TInt c;

	if ((c=gFile.Replace(TheFs,pName,EFileStream))!=KErrNone)

		Error(_L("Create 91"),c);

	gFile.Close();

	if ((c=TheFs.Rename(pName,rName))!=KErrNone)

		Error(_L("Rename 91"),c);

	if ((c=gFile.Open(TheFs,rName,EFileStream))!=KErrNone)

		Error(_L("Open 91"),c);

	gFile.Close();

	if ((c=TheFs.Delete(pName))!=NotExistsErr)

		Error(_L("Delete 91"),c);

	}

LOCAL_C void verifyTestPat1()

//

//

//

	{

	TInt i;

	TInt c;

	if ((c=gFile.Open(TheFs,_L("\\TESTPAT1.DAT"),EFileStream))!=KErrNone)

		Error(_L("Create testpat1"),c);

	gDataBuf.SetLength(0);

	if ((c=gFile.Read(gDataBuf,512))!=KErrNone || gDataBuf.Length()!=512)

		Error(_L("Read 90"),c);

	gFile.Close();

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

		{

		if (gDataBuf[i]!='X')

			Error(_L("Data check"),0);

		}

	}

void TestINC103141() // PDEF104017

	{

	test.Printf(_L("Test INC103141\n"));

	_LIT(KDir1, "\\INC103141\\TEST");

	_LIT(KDir2, "\\INC103141\\test");

	TBuf<32> dirname;

	dirname.Copy(KDir1);

	dirname.Append(KPathDelimiter);

	MakeDir(dirname);

	TInt err = TheFs.Rename(KDir1, KDir2);

	test(err == KErrNone);

	err = TheFs.RmDir(dirname);

	test(err == KErrNone);

	err = TheFs.RmDir(KDir1);

	test(err == KErrNone);

	}

LOCAL_C void testRename()

//

// Test TheFs.Rename function.

//

	{

	TBuf<32> xName;

	TInt i;

	TInt c;

	test.Printf(_L("Test TheFs.Rename\n"));

	test.Printf(_L("Test rename into root\n"));

	if ((c=gFile.Replace(TheFs,_L("\\TESTPAT1.DAT"),EFileStream|P_FUPDATE))!=KErrNone)

		Error(_L("Create testpat1"),c);

	gDataBuf.Fill('X',512);

	if ((c=gFile.Write(gDataBuf,512))!=KErrNone)

		Error(_L("Write 90"),c);

	gFile.Close();

	if ((c=TheFs.MkDir(_L("\\DIRX\\")))!=KErrNone)

		Error(_L("Make dir 90"),c);

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

		{

		xName.Format(_L("\\DIRX\\FILEX%u"),i);

		TPtrC rootName(xName.Ptr()+5,xName.Length()-5);

		testRenameToRoot(xName,rootName);

		verifyTestPat1();

		}

	test.Printf(_L("Test rename from root\n"));

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

		{

		xName.Format(_L("\\DIRX\\FILEX%u"),i);

		TPtrC rootName(xName.Ptr()+5,xName.Length()-5);

		testRenameFromRoot(rootName,xName);

		verifyTestPat1();

		}

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

		{

		xName.Format(_L("\\DIRX\\FILEX%u"),i);

		if ((c=TheFs.Delete(xName))!=KErrNone)

			Error(_L("Delete 93"),c);

		}

	if ((c=TheFs.RmDir(_L("\\DIRX\\")))!=KErrNone)

		Error(_L("Delete DIRX"),c);

	verifyTestPat1();

	if ((c=TheFs.Delete(_L("\\TESTPAT1.DAT")))!=KErrNone)

		Error(_L("Delete 80"),c);

	test.Printf(_L("Test rename with wild cards\n"));

	if ((c=TheFs.Rename(_L("*.*"),_L("FRED")))!=NameErr)

		Error(_L("Rename 100"),c);

	if ((c=TheFs.Rename(_L("?"),_L("FRED")))!=NameErr)

		Error(_L("Rename 101"),c);

	if ((c=TheFs.Rename(_L(""),_L("FRED")))!=KErrBadName) // NameErr)

		Error(_L("Rename 101.11"),c);

	if ((c=TheFs.Rename(_L("."),_L("FRED")))!=NameErr)

		Error(_L("Rename 101.12"),c);

	if ((c=TheFs.Rename(_L("NOEXIST"),_L("*")))!=NameErr)

		Error(_L("Rename 101.1"),c);

	if ((c=gFile.Create(TheFs,_L("FILE1"),EFileStream))!=KErrNone)

		Error(_L("Create 101.2"),c);

	gFile.Close();

	if ((c=TheFs.Rename(_L("FILE1"),_L("AAA?")))!=NameErr)

		Error(_L("Rename 101.3"),c);

	if ((c=TheFs.Rename(_L("FILE1"),_L("")))!=KErrBadName) // NameErr)

		Error(_L("Rename 101.41"),c);

	if ((c=TheFs.Rename(_L(""),_L("")))!=KErrBadName) // NameErr)

		Error(_L("Rename 101.42"),c);

	if ((c=TheFs.Delete(_L("FILE1")))!=KErrNone)

		Error(_L("Delete 101.5"),c);

	if ((c=TheFs.Rename(_L("\\"),_L("FRED")))!=NameErr)

		Error(_L("Rename 101.6"),c);

	test.Printf(_L("Test rename of directories\n"));

	if ((c=TheFs.MkDir(_L("\\DIR1\\")))!=KErrNone)

		Error(_L("Make dir 102"),c);

	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\A2345678.123")))!=KErrNone)

		Error(_L("Rename 103.1"),c);

	if ((c=TheFs.Rename(_L("\\A2345678.123"),_L("\\DIR2")))!=KErrNone)

		Error(_L("Rename 103.2"),c);

	if ((c=TheFs.Rename(_L("\\DIR2"),_L("\\A234567.1234")))!=KErrNone) // ****** NameErr) Long filenames are supported

		Error(_L("Rename 103.3"),c);

	if ((c=TheFs.Rename(_L("\\A234567.1234"),_L("\\DIR2")))!=KErrNone)

		Error(_L("Rename 103.3"),c);

	if ((c=TheFs.MkDir(_L("\\DIR1\\")))!=KErrNone)

		Error(_L("Make dir 104"),c);

	test.Printf(_L("Test rename of open files\n"));

	if ((c=gFile.Create(TheFs,_L("\\DIR1\\FILE1"),EFileStreamText))!=KErrNone)

		Error(_L("Create 105"),c);

	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=LockedErr)

		Error(_L("Rename 106"),c);

	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR2\\FILE1")))!=LockedErr)

		Error(_L("Rename 106.1"),c);

	if ((c=gFile2.Open(TheFs,_L("\\DIR2\\FILE1"),EFileStream))!=NotExistsErr)

		Error(_L("Create 105"),c);

	gFile.Close();

	test.Printf(_L("Test rename to same name\n"));

	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=KErrNone) // !=ExistsErr)

		Error(_L("Rename 105.1"),c);

	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\DIR1")))!=KErrNone) // !=ExistsErr)

		Error(_L("Rename 105.2"),c);

	test.Printf(_L("Test rename of read-only files\n"));     // IS ALLOWED //

	if ((c=TheFs.SetAtt(_L("\\DIR1\\FILE1"),KEntryAttReadOnly,0))!=KErrNone)

		Error(_L("Att 106"),c);

	if ((c=TheFs.Entry(_L("\\DIR1\\FILE1"),gFileEntry))!=KErrNone)

		Error(_L("File info 106.1"),c);

	test.Printf(_L("STATUS=%04x\n"),gFileEntry.iAtt);

	if (gFileEntry.iAtt!=(TUint32)(P_FAREAD|P_FASTREAM|P_FAMOD))

		Error(_L("Status check 106.2"),0);

	if ((c=TheFs.Entry(_L("\\DIR1"),gFileEntry))!=KErrNone)

		Error(_L("File info 106.3"),c);

	test.Printf(_L("STATUS=%04x\n"),gFileEntry.iAtt);

	if (gFileEntry.iAtt!=(TUint32)(P_FASTREAM|P_FADIR))

		Error(_L("Status check 106.4"),0);

	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=KErrNone) // !=ExistsErr)

		Error(_L("Rename 107"),c);

	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE2")))!=KErrNone)

		Error(_L("Rename 108"),c);

	if ((c=TheFs.Rename(_L("\\DIR1\\FILE2"),_L("\\DIR2\\FILE2")))!=KErrNone)

		Error(_L("Rename 109"),c);

	if ((c=gFile2.Open(TheFs,_L("\\DIR2\\FILE2"),EFileStream))!=KErrNone)

		Error(_L("Create 110"),c);

	gFile2.Close();

	if ((c=TheFs.Rename(_L("\\DIR2\\FILE2"),_L("\\DIR1\\FILE1")))!=KErrNone)

		Error(_L("Rename 110.1"),c);

	if ((c=TheFs.SetAtt(_L("\\DIR1\\FILE1"),0,KEntryAttReadOnly))!=KErrNone)

		Error(_L("Att 111"),c);

	test.Printf(_L("Test rename of files across directories\n"));

	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR2\\FILE1")))!=KErrNone)

		Error(_L("Rename 112"),c);

	if ((c=gFile.Open(TheFs,_L("\\DIR2\\FILE1"),EFileStream))!=KErrNone)

		Error(_L("Exist 113"),c);

	gFile.Close();

	test.Printf(_L("Test rename of directories across directories\n"));

	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\DIR2\\DIR1")))!=KErrNone) // ******** AccessErr)

		Error(_L("Rename 114"),c);

	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\")))!=NameErr)

		Error(_L("Rename 114.1"),c);

	if ((c=TheFs.Delete(_L("\\DIR2\\FILE1")))!=KErrNone)

		Error(_L("Delete 115"),c);

	if ((c=TheFs.RmDir(_L("\\DIR2\\DIR1\\")))!=KErrNone)

		Error(_L("Delete 115"),c);

	if ((c=TheFs.RmDir(_L("\\DIR2\\")))!=KErrNone)

		Error(_L("Delete 115"),c);

	TestINC103141();  // PDEF104017

	}    

LOCAL_C void testDelete()

//

// Test RFs::Delete function.

//

	{

	TInt c;

	test.Printf(_L("Test RFs::Delete\n"));

	test.Printf(_L("Test delete non-empty directories\n"));

	if ((c=TheFs.MkDir(_L("\\TESTDIR\\")))!=KErrNone)

		Error(_L("Make dir 500"),c);

	if ((c=gFile.Create(TheFs,_L("\\TESTDIR\\NAME.EXT"),EFileStream))!=KErrNone)

		Error(_L("Create"),c);

	if ((c=TheFs.Delete(_L("\\TESTDIR\\")))!=KErrBadName) // ******* AccessErr)

		Error(_L("Delete 501"),c);

	test.Printf(_L("Test delete open file\n"));

	if ((c=TheFs.Delete(_L("\\TESTDIR\\NAME.EXT")))!=LockedErr)

		Error(_L("Delete 502"),c);

	gFile.Close();

	if ((c=TheFs.Delete(_L("\\TESTDIR\\NAME.EXT")))!=KErrNone)

		Error(_L("Delete 503"),c);

	if ((c=TheFs.RmDir(_L("\\TESTDIR\\")))!=KErrNone)

		Error(_L("Delete 504"),c);

	}

LOCAL_C void testUnique(TUint fileFormat)

//

// Test RFile::Temp

//

	{

	TInt pos;

	TInt c;

	test.Printf(_L("Test RFile::Temp\n"));

	gDataBuf.SetLength(1);

	if ((c=gFile.Temp(TheFs,_L(""),gNameBuf,fileFormat))!=KErrNone)

		Error(_L("Directory open 2000"),c);

	if ((c=gFile.Write(gDataBuf,0))!=KErrNone)

		Error(_L("Write 2000"),c);

	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)

		Error(_L("Write 2000"),c);

	pos=0L;

	if ((c=gFile.Seek(ESeekStart,pos))!=KErrNone) // !=E_FILE_INV) Temp file is random access

		Error(_L("Seek 2000"),c);

	gFile.Close();

	if ((c=TheFs.Delete(gNameBuf))!=KErrNone)

		Error(_L("Delete"),c);

	}

LOCAL_C void testFileName(const TDesC& aFileName,TInt res)