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

 // f32test\fat32\t_compat32.cpp

 //

 //

 #define __E32TEST_EXTENSION__

 #include <f32file.h>

 #include <e32svr.h>

 #include <e32test.h>

 #include <f32dbg.h>

 #include "t_server.h"

 #include "fat_utils.h"

 using namespace Fat_Test_Utils;

 RTest test(_L("T_COMPAT32"));

 static RRawDisk TheDisk;

 static TFatBootSector gBootSector;

 static void QuickFormat()

     {

     FormatFatDrive(TheFs, CurrentDrive(), ETrue);

     }

 static void ReadBootSector(TFatBootSector& aBootSector)

 	{

     TInt nRes = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, aBootSector);

     test(nRes == KErrNone);

     if(!aBootSector.IsValid())

         {

         test.Printf(_L("Wrong bootsector! Dump:\n"));

         aBootSector.PrintDebugInfo();

         test(0);

         }

 	}

 static void GetBootInfo()

 	{

 	QuickFormat();

 	ReadBootSector(gBootSector);

 	}

 enum TNameCase

 	{

 	EUpper, // Test directory entries with 8.3 uppercase (no VFAT entries expected)

 	ELower, // Test directory entries with 8.3 lowercase (   VFAT entries expected)

 	EMixed  // Test directory entries with 8.3 mixed     (   VFAT entries expected)

 	};

 /**

     Fiddles with root directory entries.

     Creates a file, if it has 1 VFAT and 1 DOS dir. entries, places an illegal lower case

     symbol to the DOS entry, fixing VFAT name checksums

 */

 static void DoFiddleWithFileNames(TNameCase aCase)

 {

 	TFileName fileName = _L("\\WORD");

 	TBool expectVfatEntry = EFalse;

 	switch(aCase)

 		{

 		case EUpper:

 			break;

 		case ELower:

 			fileName = _L("\\word");

 			expectVfatEntry = ETrue;

 			break;

 		case EMixed:

 			fileName = _L("\\WoRd");

 			expectVfatEntry = ETrue;

 			break;

 		default:

 			test(0);

 			break;

 		}

 	RFile file;

 	TInt r=file.Create(TheFs,fileName,EFileRead);

 	test(r==KErrNone);

 	file.Close();

 //	Assume this file is the first entry in the root directory

 	r=TheDisk.Open(TheFs,CurrentDrive());

 	test(r==KErrNone);

     //-- read 1st dir. entry it can be FAT or VFat , depending on the filename

     const TInt posEntry1=gBootSector.RootDirStartSector() << KDefaultSectorLog2; //-- dir entry1 position

     TFatDirEntry fatEntry1;

 	TPtr8 ptrEntry1((TUint8*)&fatEntry1,sizeof(TFatDirEntry));

     test(TheDisk.Read(posEntry1, ptrEntry1)==KErrNone);

     if(!fatEntry1.IsVFatEntry())

     {//-- we expected FAT entry, everything is OK

         test(!expectVfatEntry);

     }

     else

     {//-- we have 2 FAT entries, 1st is VFat, 2nd is DOS.

      //-- put lower case letters into DOS entry( not compliant with FAT specs), correct VFat entries checksums,

      //-- in this case the system shall correctly deal with the file, using long names.

         test(expectVfatEntry);

         test(fatEntry1.iData[0] == 0x41); //-- must have only 2 entries

         //-- read DOS entry now

         TFatDirEntry fatEntry2;

         TPtr8 ptrEntry2((TUint8*)&fatEntry2,sizeof(TFatDirEntry));

         const TInt posEntry2 = posEntry1 + sizeof(TFatDirEntry); //-- dir entry2 position

         test(TheDisk.Read(posEntry2, ptrEntry2)==KErrNone);

         //-- ensure that the name and checksum are correct

         test(fatEntry1.iData[13] == CalculateShortNameCheckSum(fatEntry2.Name()));

         test(fatEntry2.Name()==_L8("WORD       "));

         //-- put lower case symbol to the DOS entry and fix the checksum

         _LIT8(KBadDosName, "Word       ");

         fatEntry2.SetName(KBadDosName);

         fatEntry1.iData[13] = CalculateShortNameCheckSum(fatEntry2.Name());

         //-- write data to the disk

         test(TheDisk.Write(posEntry1, ptrEntry1)==KErrNone);

         test(TheDisk.Write(posEntry2, ptrEntry2)==KErrNone);

     }

 	TheDisk.Close();

 }

 //

 // Replace a 8.3 filename with upper and lower case letters which is, actually out of FAT specs.

 // I.e. VFAT entries are valid, but DOS entry has a lower case symbol, which is wrong.

 //

 LOCAL_C void Test1(TNameCase aCase)

 	{

 	test.Next(_L("Replace a file with a wrong DOS entry"));

 	QuickFormat();

     //-- N.B. This shall be the before any dir. entries creation in the root directory

     //-- because it directly accesses the directory's 1st file

     DoFiddleWithFileNames(aCase);

     RFile file;

     TInt r;

 	r=file.Replace(TheFs,_L("\\FILE.TMP"),EFileRead);

 	test(r==KErrNone);

 	r=file.Write(_L8("Hello World"));

 	file.Close();

 	r=TheFs.Replace(_L("\\File.tmp"),_L("\\Word"));

 	test(r==KErrNone);

 	CDir* entryCount;

 	r=TheFs.GetDir(_L("\\*.*"),KEntryAttMaskSupported,ESortNone,entryCount);

 	test(r==KErrNone);

 	TInt count=entryCount->Count();

 	test(count==1);

 	delete entryCount;

 	}

 //

 // Renaming a 8.3 filename with upper and lower case letters which is, actually out of FAT specs.

 // I.e. VFAT entries are valid, but DOS entry has a lower case symbol, which is wrong.

 //

 LOCAL_C void Test2(TNameCase aCase)

 	{

 	test.Next(_L("Rename a file with a wrong DOS entry"));

 	QuickFormat();

 	RFile file;

     TInt r;

     //-- N.B. This shall be the before any dir. entries creation in the root dir

     //-- because it directly accesses the directory's 1st file

     DoFiddleWithFileNames(aCase);

 	r=file.Create(TheFs,_L("\\TEST"),EFileRead);

 	test(r==KErrNone);

 	file.Close();

 	r=TheFs.Rename(_L("\\TEST"),_L("\\Word"));

 	test(r==KErrAlreadyExists);

 	r=TheFs.Delete(_L("\\TEST"));

 	test(r==KErrNone);

 	CDir* entryCount;

 	r=TheFs.GetDir(_L("\\*.*"),KEntryAttMaskSupported,ESortNone,entryCount);

 	test(r==KErrNone);

 	TInt count=entryCount->Count();

 	test(count==1);

 	delete entryCount;

 	}

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

 //! @SYMTestCaseID			PBASE-T_COMPAT32-0686

 //! @SYMTestType			CT

 //! @SYMREQ					DEF115314

 //! @SYMTestCaseDesc		Test character '`' (0x60) is recognized as a legal char for short file names.

 //! @SYMTestActions			Creates a file named "\x60\x60\x60.TXT", checks only DOS entry is created for

 //!							it and its short name equals "```.TXT" instead of "___.TXT"

 //! @SYMTestExpectedResults	The operation completes with error code KErrNone;

 //! @SYMTestPriority		High

 //! @SYMTestStatus			Implemented

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

 void TestDEF115314()

 	{

 	test.Next(_L("Test DEF115314: TTG:<`(0x60) code cannot be used as valid Short File Name>"));

 	QuickFormat();

 	RFile file;

     TInt r;

     TFileName fn;

     fn.Format(_L("%c:\\\x60\x60\x60.TXT"), (TUint8)gDriveToTest);

     r = TheFs.Delete(fn);

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

 	r = file.Create(TheFs, fn, EFileRead);

 	test(r==KErrNone);

 	file.Close();

 	r=TheDisk.Open(TheFs,CurrentDrive());

 	test(r==KErrNone);

     //-- read 1st dir. it should be DOS Entry

     const TInt posEntry1=gBootSector.RootDirStartSector() << KDefaultSectorLog2; //-- dir entry1 position

     TFatDirEntry fatEntry1;

 	TPtr8 ptrEntry1((TUint8*)&fatEntry1,sizeof(TFatDirEntry));

     test(TheDisk.Read(posEntry1, ptrEntry1)==KErrNone);

     TheDisk.Close();

     test(!fatEntry1.IsVFatEntry());

     // tests short name

     TFileName sn;

     r = TheFs.GetShortName(fn, sn);

     test(r==KErrNone);

     test(sn.Compare(_L("```.TXT"))==0);

     r = TheFs.Delete(fn);

 	test(r==KErrNone);

 	}

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 _LIT(KTestLocale, 			"t_tlocl_cp932.dll");

 _LIT(KTestUnicodeFileName, 	"\\\x65B0\x6587\x4EF6");

 #endif //_DEBUG || _DEBUG_RELEASE

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

 //! @SYMTestCaseID			PBASE-T_COMPAT32-0685

 //! @SYMTestType			CT

 //! @SYMREQ					DEF113633

 //! @SYMTestCaseDesc		Test FAT volume creates VFat entries for short unicode named files

 //! @SYMTestActions			Enables FatUtilityFunctions. Loads cp932 codepage dll. Create a file

 //!							named as "\x65B0\x6587\x4EF6", checks both a VFat entry and a DOS

 //!							entry have been created for the file.

 //! @SYMTestExpectedResults	The operation completes with error code KErrNone;

 //! @SYMTestPriority		High

 //! @SYMTestStatus			Implemented

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

 void TestDEF113633()

 	{

 	test.Next(_L("Test DEF113633 - FAT should create VFat entries for unicode character contained file names"));

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 	QuickFormat();

 	RFile file;

     TInt r;

     TInt drvNum;

     r = TheFs.CharToDrive(gDriveToTest,drvNum);

 	test(r==KErrNone);

     // turn on FatUtilityFunctions

     r = TheFs.ControlIo(drvNum, KControlIoEnableFatUtilityFunctions);

 	test(r==KErrNone);

 	// load cp932 codepage dll

 	r = UserSvr::ChangeLocale(KTestLocale);

 	test(r==KErrNone);

     // create file "\x65B0\x6587\x4EF6", check DOS entry & VFat entry

 	r = file.Create(TheFs, KTestUnicodeFileName, EFileRead);

 	test(r==KErrNone);

 	file.Close();

 	r=TheDisk.Open(TheFs,CurrentDrive());

 	test(r==KErrNone);

     //-- read 1st dir. it should be VFat

 //    const TInt posEntry1=gRootDirStart; //-- dir entry1 position

     const TInt posEntry1=gBootSector.RootDirStartSector() << KDefaultSectorLog2; //-- dir entry1 position

     TFatDirEntry fatEntry1;

 	TPtr8 ptrEntry1((TUint8*)&fatEntry1,sizeof(TFatDirEntry));

     test(TheDisk.Read(posEntry1, ptrEntry1)==KErrNone);

     test(fatEntry1.IsVFatEntry());

     test(fatEntry1.iData[0] == 0x41); //-- must have only 2 entries

     //-- read DOS entry now

     TFatDirEntry fatEntry2;

     TPtr8 ptrEntry2((TUint8*)&fatEntry2,sizeof(TFatDirEntry));

     const TInt posEntry2 = posEntry1 + sizeof(TFatDirEntry); //-- dir entry2 position

     test(TheDisk.Read(posEntry2, ptrEntry2)==KErrNone);

     //-- ensure that the name and checksum are correct

     test(!fatEntry2.IsVFatEntry());

     test(fatEntry1.iData[13] == CalculateShortNameCheckSum(fatEntry2.Name()));

     // delete file

     TheDisk.Close();

     r = TheFs.Delete(KTestUnicodeFileName);

 	test(r==KErrNone);

 	// turn off FatUtilityFunctions

 	r = TheFs.ControlIo(drvNum, KControlIoDisableFatUtilityFunctions);

 	test(r==KErrNone);

 #else

 	test.Printf(_L("Test only runs on DEBUG builds, see test logs of debug builds for details."));

 #endif  // _DEBUG) || _DEBUG_RELEASE

 	}

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

 // If the parent directory of a directory is the root directory,

 // the '..' entry should point to start cluster 0 in any case

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

 void TestPDEF116912()

 	{

 	test.Next(_L("Test PDEF116912 - Check that '..' parent cluster address is 0 after renaming\n"));

   	TInt drvNum;

 	test(KErrNone == TheFs.CharToDrive(gDriveToTest, drvNum));

 	if(!Is_Fat32(TheFs, drvNum))

 		{

 		_LIT(KMessage, "Test only applicable to FAT32 file systems. Skipping.\n");

 		test.Printf(KMessage);

 		return;

 		}

 	QuickFormat();

 	_LIT(KDirA, "\\dirA\\");

 	_LIT(KDirB, "\\dirB\\");

 	test(KErrNone == TheFs.MkDir(KDirA));

 	test(KErrNone == TheFs.Rename(KDirA, KDirB));

 	test(gBootSector.IsValid());

 	TInt mediaPosition = gBootSector.RootDirStartSector() * gBootSector.BytesPerSector();

 	TFatDirEntry dirEntry;

 	TPtr8 ptrEntry((TUint8*) &dirEntry,sizeof(TFatDirEntry));

 	_LIT8(KDirBMatchPattern, "DIRB *");

 	_LIT8(KDotDotMatchPattern, ".. *");

 	const TInt KMaxEntriesToSearch = (gBootSector.SectorsPerCluster() * gBootSector.BytesPerSector()) / KSizeOfFatDirEntry;

 	test(KErrNone == TheDisk.Open(TheFs, drvNum));

 	for(TInt c = 0; c < KMaxEntriesToSearch; c++)

 		{

 	    test(KErrNone == TheDisk.Read(mediaPosition, ptrEntry));

 		if(KErrNotFound == ptrEntry.Match(KDirBMatchPattern))

 			{

 			// keep scanning

 			mediaPosition += sizeof(TFatDirEntry);

 			}

 		else

 			{

 			// found, locate '..' entry

 			test(dirEntry.StartCluster() >= KFatFirstSearchCluser);

 			mediaPosition  = gBootSector.FirstDataSector();

 			mediaPosition += (dirEntry.StartCluster() - KFatFirstSearchCluser) * gBootSector.SectorsPerCluster();

 			mediaPosition *= gBootSector.BytesPerSector();

 			mediaPosition += KSizeOfFatDirEntry; // '..' is always the 2nd entry

 			test(KErrNone == TheDisk.Read(mediaPosition, ptrEntry));

 			test(KErrNotFound != ptrEntry.Match(KDotDotMatchPattern));

 			test(dirEntry.StartCluster() == 0);

 			TheDisk.Close();

 			return;

 			}

 		}

 	// dirB entry not found - test failed

 	TheDisk.Close();

 	test(0);

 	}

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

 /**

     Test replacing files by theis short names

 */

 void TestReplaceByShortName()

 {

     test.Next(_L("Test replacing files using short names\n"));

     QuickFormat();

     _LIT(KLongName1,  "abcdefghi.txt");

     _LIT(KShortName1, "ABCDEF~1.TXT");

     const TInt KFile1Sz = 100;

     _LIT(KLongName2,  "abcdefghij.txt");

     _LIT(KShortName2, "ABCDEF~2.TXT");

     const TInt KFile2Sz = 200;

     TInt        nRes;

     TFileName   fn;

     TEntry      entry;

     TheFs.SetSessionPath(_L("\\"));

     nRes = CreateCheckableStuffedFile(TheFs, KLongName1, KFile1Sz);

     test_KErrNone(nRes);

     nRes = TheFs.GetShortName(KLongName1, fn);

     test(nRes == KErrNone && fn == KShortName1); //-- just check short name generation

     nRes =CreateCheckableStuffedFile(TheFs, KLongName2, KFile2Sz);

     test_KErrNone(nRes);

     nRes = TheFs.GetShortName(KLongName2, fn);

     test(nRes == KErrNone && fn == KShortName2); //-- just check short name generation

     //-- try to replace the file with itself using its short name alias

     //-- nothing shall happen and the file must remain the same

     nRes = TheFs.Replace(KLongName1, KShortName1);

     test(nRes == KErrNone);

     nRes = TheFs.Entry(KLongName1, entry);

     test(nRes == KErrNone);

     test(entry.iSize == KFile1Sz);

     nRes = TheFs.Entry(KShortName1, entry);

     test(nRes == KErrNone);

     test(entry.iSize == KFile1Sz);

     nRes = TheFs.Replace(KShortName1, KLongName1);

     test(nRes == KErrNone);

     nRes = TheFs.Entry(KLongName1, entry);

     test(nRes == KErrNone);

     test(entry.iSize == KFile1Sz);

     nRes = TheFs.Entry(KShortName1, entry);

     test(nRes == KErrNone);

     test(entry.iSize == KFile1Sz);

     nRes = VerifyCheckableFile(TheFs, KLongName1);

     test(nRes == KErrNone);

     nRes = VerifyCheckableFile(TheFs, KShortName1);

     test(nRes == KErrNone);

     //-- replace "abcdefghi.txt" by "ABCDEF~2.TXT" which is the alias for "abcdefghij.txt"

     //-- expected: contents and all attributes of the "abcdefghij.txt" is replaced with "abcdefghi.txt"

     //-- "abcdefghi.txt" entries gets deleted.

     nRes = TheFs.Replace(KLongName1, KShortName2);

     test(nRes == KErrNone);

     //User::After(5*K1Sec);

     /*

     nRes = VerifyCheckableFile(TheFs, KLongName2);

     test(nRes == KErrNone);

     nRes = VerifyCheckableFile(TheFs, KShortName2);

     test(nRes == KErrNone);

     */

     nRes = TheFs.Entry(KLongName2, entry);

     test(nRes == KErrNone);

     test(entry.iSize == KFile1Sz);

     nRes = TheFs.Entry(KShortName2, entry);

     test(nRes == KErrNone);

     test(entry.iSize == KFile1Sz && entry.iName == KLongName2);

 }

 GLDEF_C void CallTestsL()

 //

 // Call tests that may leave

 //

 	{

 	TInt drvNum;

 	TInt r=TheFs.CharToDrive(gDriveToTest,drvNum);

 	test(r==KErrNone);

     if (!Is_Fat(TheFs,drvNum))

 		{

 		test.Printf(_L("CallTestsL: Skipped: Requires FAT filesystem to run.\n"));

 		return;

 		}

     //-- set up console output

     SetConsole(test.Console());

     //-- print drive information

     PrintDrvInfo(TheFs, drvNum);

 	GetBootInfo();

 	Test1(EUpper); // Test directory entries with 8.3 uppercase (no VFAT entries expected)

 	Test1(ELower); // Test directory entries with 8.3 lowercase (   VFAT entries expected)

 	Test1(EMixed); // Test directory entries with 8.3 mixed     (   VFAT entries expected)

 	Test2(EUpper); // Test directory entries with 8.3 uppercase (no VFAT entries expected)

 	Test2(ELower); // Test directory entries with 8.3 lowercase (   VFAT entries expected)

 	Test2(EMixed); // Test directory entries with 8.3 mixed     (   VFAT entries expected)

 	TestDEF115314();

 	TestDEF113633();

 	TestPDEF116912();

     TestReplaceByShortName();

 	}