// Copyright (c) 2007-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\locl\localeutils\t_localeutils_cp932.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <HAL.H>

#include <f32fsys.h>

#include <f32dbg.h>

#include <e32svr.h>

#include "..\server\t_server.h"

#include "fat_utils.h"

RTest test(_L("T_LOCALEUTILS_CP932"));

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

using namespace Fat_Test_Utils;

static RRawDisk TheDisk;

static TFatBootSector gBootSector;

_LIT(KTestLocale, "t_tlocl_cp932.dll");

void QuickFormat()

    {

    FormatFatDrive(TheFs, CurrentDrive(), ETrue);

    }

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

        }

	}

void GetBootInfo()

	{

	QuickFormat();

	ReadBootSector(gBootSector);

	}

void doDirNameTest(const TDesC& aLongName, const TDesC& aShortName)

	{

	TBuf<KMaxFileName> longDirNamePath;

	TBuf<KMaxFileName> shortDirNamePath;

	TBuf<KMaxFileName> longName;

	TBuf<KMaxFileName> shortName;

	longDirNamePath = gSessionPath;

	longDirNamePath += aLongName;

	longDirNamePath.Append('\\');

	// Create new directory and check creation

	TInt r = TheFs.MkDir(longDirNamePath);

	test_KErrNone(r);

	TUint dumUint=0;

	CDir* dumDir;

	r= TheFs.GetDir(longDirNamePath, dumUint, dumUint, dumDir);

	test_KErrNone(r);

	test_NotNull(dumDir);

	delete dumDir;

	// Check short name

	r = TheFs.GetShortName(longDirNamePath, shortName);

	test_KErrNone(r);

	r = shortName.Compare(aShortName);

	test_Equal(r, 0);

	// Check long name

	shortDirNamePath = gSessionPath;

	shortDirNamePath += shortName;

	shortDirNamePath.Append('\\');

	r = TheFs.GetLongName(shortDirNamePath, longName);

	test_KErrNone(r);

	r = longName.Compare(aLongName);

	test_Equal(r, 0);

	r = TheFs.RmDir(longDirNamePath);

	test_KErrNone(r);

	}

void doFileNameTest(const TDesC& aLongName, const TDesC& aShortName)

	{

	TFileName lgnFullPath;

	TFileName shnFullPath;

	TFileName lgn;

	TFileName shn;

	TInt r = TheFs.SessionPath(gSessionPath);

	test_KErrNone(r);

	lgnFullPath = gSessionPath;

	lgnFullPath += aLongName;

	MakeFile(lgnFullPath);

	// Check short name	

	r = TheFs.GetShortName(lgnFullPath, shn);

	test_KErrNone(r);

	r = shn.Compare(aShortName);

	test_Equal(r, 0);

	// Check long name	

	shnFullPath = gSessionPath;

	shnFullPath += aShortName;

	r = TheFs.GetLongName(shnFullPath, lgn);

	test_KErrNone(r);

	r = lgn.Compare(aLongName);

	test_Equal(r, 0);

	test_KErrNone(TheFs.Delete(lgnFullPath));

	}

#endif //_DEBUG || _DEBUG_RELEASE

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

//! @SYMTestCaseID      PBASE-t_fatcharsetconv-0406

//! @SYMTestType        CIT

//! @SYMDEF             DEF101875

//! @SYMTestCaseDesc    This test case is to test the default behaviours of LocaleUtils functions 

//!                     in FAT.fsy before FATCharsetConv is integrated (i.e. there is no codepage

//!                     dll loaded).

//! @SYMTestActions     1. Creates a file with a name containing 3 valid Unicode characters, 

//!                        gets its short name and compares it with "___", gets its long name and 

//!                        compares it with the original Unicode string;

//!                     2. Creates a file with a name containing 4 Unicode characters, each 16-bit 

//!                        Unicode character contains two illegal 8-bit characters, test if the 

//!                        file can be created successfully, gets its short name and compares it 

//!                        with "____", gets its long name and compares it with the original 

//!                        Unicode string.

//! @SYMTestExpectedResults

//!                     1. The file should be created successfully, the comparisons should return 0;

//!                     2. The file should be created successfully, the comparisons should return 0;

//! @SYMTestPriority    High

//! @SYMTestCaseDependencies

//!                     This test should be run before any codepage DLL is loaded, 

//!	                    i.e., prior to all other test cases defined in this file.

//! @SYMTestStatus      Implemented

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

void TestBeforeFATCharsetConvInteg()

	{

	test.Next(_L("Test default unicode handling in FAT implementation"));

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

	_LIT(KTestNormalUnicodeFileName, 				"\x65B0\x6587\x4EF6.TXT");

	_LIT(KTestNormalUnicodeFileNameShortDefualt, 	"___.TXT");

	_LIT(KTestFileNameWithIllegalChars, 			"\x222F\x2F3A\x3C3E\x7C00.TXT");

	_LIT(KFileNameWithIllegalCharsShort, 			"____.TXT");

	TInt r = TheFs.ControlIo(CurrentDrive(), KControlIoDisableFatUtilityFunctions);

	test_KErrNone(r);

	// Create file and check creation

	MakeFile(KTestNormalUnicodeFileName);

	TFileName shn;

	// Check short name	to test if there is any codepage DLL loaded already.

	r = TheFs.GetShortName(KTestNormalUnicodeFileName, shn);

	test_KErrNone(r);

	r = shn.Compare(KTestNormalUnicodeFileNameShortDefualt);

	test_Equal(r, 0);

	TFileName lgn;

	r = TheFs.GetLongName(KTestNormalUnicodeFileNameShortDefualt, lgn);

	test_KErrNone(r);

	r = lgn.Compare(KTestNormalUnicodeFileName);

	test_Equal(r, 0);

	// Test illegal 8-bit ASCII chars in 16-bit Unicode chars.

	MakeFile(KTestFileNameWithIllegalChars);

	r = TheFs.GetShortName(KTestFileNameWithIllegalChars, shn);

	test_KErrNone(r);

	r = shn.Compare(KFileNameWithIllegalCharsShort);

	test_Equal(r, 0);

	test_KErrNone(TheFs.Delete(KTestFileNameWithIllegalChars));

	test_KErrNone(TheFs.Delete(KTestNormalUnicodeFileName));

	r = TheFs.ControlIo(CurrentDrive(), KControlIoEnableFatUtilityFunctions);

	test_KErrNone(r);

#else

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

#endif  // _DEBUG) || _DEBUG_RELEASE

	}

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

//! @SYMTestCaseID      PBASE-t_fatcharsetconv-0407

//! @SYMTestType        CIT

//! @SYMDEF             DEF101875

//! @SYMTestCaseDesc    This test case is to test volume label setting with Unicode characters

//! @SYMTestActions     1. Changes locale to load testing codepage dll, check returning error code

//!                     2. Sets volume label with Unicode (less than 11 bytes long), test setting 

//!                        success, gets volume label and compares it with the original Unicode string;

//!                     3. Sets volume label with a Unicode string contains less than 11 characters 

//!                        but occupies bigger than 11 bytes, checks the returning error code;

//!                     4. Compares the volume label with the Unicode string used in action 2

//! @SYMTestExpectedResults

//!                     1. KErrNone should be returned;

//!                     2. The comparison should return 0;

//!                     3. KErrBadName should be returned;

//!                     4. The comparison should return 0;

//! @SYMTestPriority    High

//! @SYMTestStatus      Implemented

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

void TestUnicodeVolumeLabel()

	{

	test.Next(_L("Test unicode volume labels"));

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

	TInt r = UserSvr::ChangeLocale(KTestLocale);

	test_KErrNone(r);

	r = TheFs.SessionPath(gSessionPath);

	test_KErrNone(r);

	TInt driveNum;

	r = TheFs.CharToDrive(gSessionPath[0], driveNum);

	test_KErrNone(r);

	// Retrieves the original volume label

	TVolumeInfo vInfo;

	r = TheFs.Volume(vInfo, driveNum);

	const TInt KVolumeLabelSize = 11;

	TBuf<KVolumeLabelSize> originalVolumeLabel(vInfo.iName);

	// Tests setting volume label with unicode characters

	_LIT(KUnicodeVolumeLabel, 		"\x65B0\x65B0\x65B0");

	r = TheFs.SetVolumeLabel(KUnicodeVolumeLabel, driveNum);

	test_KErrNone(r);

	r = TheFs.Volume(vInfo, driveNum);

	test_KErrNone(r);

	r = vInfo.iName.Compare(KUnicodeVolumeLabel);

	test_Equal(r, 0);

	// Tests setting volume label with unicode characters that bigger than 11 bytes

	_LIT(KVolumeLabelOverflow,		"\x65B0\x65B0\x65B0\x65B0\x65B0\x65B0");

	r = TheFs.SetVolumeLabel(KVolumeLabelOverflow, driveNum);

	// locale dll and codepage dll both return diff retrun values so check against both cases.

	test((r == KErrBadName) || (r == KErrOverflow));

	r = TheFs.Volume(vInfo, driveNum);

	test_KErrNone(r);

	r = vInfo.iName.Compare(KUnicodeVolumeLabel);

	test_Equal(r, 0);

	// Sets back the original volume label

	r = TheFs.SetVolumeLabel(originalVolumeLabel, driveNum);

	test_KErrNone(r);

#else

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

#endif  // _DEBUG) || _DEBUG_RELEASE

	}

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

//! @SYMTestCaseID      PBASE-t_fatcharsetconv-0408

//! @SYMTestType        CIT

//! @SYMDEF             DEF101875

//! @SYMTestCaseDesc    This test case is to test the "8 bytes" boundary of short name length, 

//!                     which is defined in FAT Specification.

//! @SYMTestActions     1. Creates files and directories with different Unicode strings that 

//!                        have different combinations of length (of characters) and size (of 

//!                        bytes occupied), check for error of creation.

//!                     2. Gets their short name, compares with expected values, gets their long 

//!                        name, compares with original Unicode strings.

//!                        The strings and short name tested are as below:

//!                        2.1. original string: "Abc"

//!                             expected short name: "ABC";

//!                        2.2. original string: "\x65B0\x6587\x4EF6\x4EF6"

//!                             expected short name: "\x65B0\x6587\x4EF6\x4EF6";

//!                        2.3. original string: "\x65B0\x6587\x4EF6(01)"

//!                             expected short name: "\x65B0\x6587\x4EF6~1";

//!                        2.4. original string: "Abcdefghi"

//!                             expected short name: "ABCDEF~1";

//!                        2.5. original string: "\x65B0(Abcdefgh)"

//!                             expected short name: "\x65B0(ABC~1";

//! @SYMTestExpectedResults

//!						1. File should be created with no error;

//!                     2. Comparisons should return 0;

//! @SYMTestPriority    High

//! @SYMTestStatus      Implemented

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

void TestShortNameBoundary()

	{

	test.Next(_L("8 bytes' name boundary tests"));

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

	TInt r = UserSvr::ChangeLocale(KTestLocale);

	test_KErrNone(r);

	// File names will be used for testing boundaries

	_LIT(KTestFileName3C3B, 		"Abc");						// 3 characters, 3 bytes long

	_LIT(KTestFileName3C3B_short,	"ABC");						// Expected short name

	_LIT(KTestFileName4C8B, 		"\x65B0\x6587\x4EF6\x4EF6");// 4 characters, 8 bytes long

	_LIT(KTestFileName4C8B_short,	"\x65B0\x6587\x4EF6\x4EF6");// Expected short name

	_LIT(KTestFileName7C10B, 		"\x65B0\x6587\x4EF6(01)");	// 7 characters, 10 bytes long

	_LIT(KTestFileName7C10B_short, 	"\x65B0\x6587\x4EF6~1");	// Expected short name

	_LIT(KTestFileName9C9B, 		"Abcdefghi");				// 9 characters, 9 bytes long

	_LIT(KTestFileName9C9B_short, 	"ABCDEF~1");				// Expected short name

	_LIT(KTestFileName9C10B, 		"\x65B0(Abcdefgh)");		// 9 characters, 10 bytes long

	_LIT(KTestFileName9C10B_short, 	"\x65B0(ABC~1");			// Expected short name

	// Test file creation and long/short name generation

	doFileNameTest(KTestFileName3C3B, 		KTestFileName3C3B_short); 

	doFileNameTest(KTestFileName4C8B, 		KTestFileName4C8B_short);

	doFileNameTest(KTestFileName7C10B, 		KTestFileName7C10B_short);

	doFileNameTest(KTestFileName9C9B, 		KTestFileName9C9B_short);

	doFileNameTest(KTestFileName9C10B, 		KTestFileName9C10B_short);

	doDirNameTest(KTestFileName3C3B, 		KTestFileName3C3B_short);

	doDirNameTest(KTestFileName4C8B, 		KTestFileName4C8B_short);

	doDirNameTest(KTestFileName7C10B, 		KTestFileName7C10B_short);

	doDirNameTest(KTestFileName9C9B, 		KTestFileName9C9B_short);

	doDirNameTest(KTestFileName9C10B, 		KTestFileName9C10B_short);

#else

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

#endif  // _DEBUG) || _DEBUG_RELEASE

	}

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

//! @SYMTestCaseID      PBASE-t_fatcharsetconv-0794

//!	@SYMTestCaseDesc    This test case is to test the extensions of the short names generated are consistent for file names

//!                     consisting of UNICODE characters. In a shortname, if the character at the third location (in 8.3 format)

//!						is a head byte of a UNICODE character then it should be ignored.

//! @SYMTestActions     1. Creates files and directories with different Unicode strings that 

//!                        have different combinations of extension length (of characters) and size (of 

//!                        bytes occupied), check for error of creation.

//!                     2. Gets their short name, compares with expected values, gets their long 

//!                        name, compares with original Unicode strings.

//!                        The strings and short name tested are as below:

//!                        2.1. original string: "abcdef.\x65B0"

//!                             expected short name: "ABCDEF.\x65B0";

//!                        2.2. original string: "abcdef.t\x65B0"

//!                             expected short name: "ABCDEF.T\x65B0";

//!                        2.3. original string: "abcdef.\x65B0t"

//!                             expected short name: "ABCDEF.\x65B0T";

//!                        2.4. original string: "abcdefg.\x65B0\x65B0"

//!                             expected short name: "ABCDEF~1.\x65B0";

//!                        

//! @SYMTestExpectedResults

//!						1. File should be created with no error;

//!                     2. Comparisons should return 0;

//! @SYMTestPriority    High

//! @SYMTestStatus      Implemented

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

void TestConsistentShortNameExtGeneration()

	{

	test.Next(_L("Test consistent short name extensions are generated"));

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

	TInt r = UserSvr::ChangeLocale(KTestLocale);

	test_KErrNone(r);

	// File names will be used for testing boundaries

	_LIT(KTestFileNameExt1C2B, 			"abcdefg.\x65B0");		// 1 characters, 2 bytes long ;only one Unicode character in the extension

	_LIT(KTestFileNameExt1C2B_short,	"ABCDEFG.\x65B0");		//Expected short name					

	_LIT(KTestFileNameExt2C3B2U, 		"abcdefg.t\x65B0");		// 2 characters, 3 bytes long ;Unicode character at the 2nd location of the extension

	_LIT(KTestFileNameExt2C3B2U_short, 	"ABCDEFG.T\x65B0");		//Expected short name

	_LIT(KTestFileNameExt2C3B1U, 		"abcdefg.\x65B0t");		// 2 characters, 3 bytes long ;Unicode character at the 1st location of the extension

	_LIT(KTestFileNameExt2C3B1U_short,	"ABCDEFG.\x65B0T");		//Expected short name

	_LIT(KTestFileNameExt2C4B, 			"abcdefg.\x65B0\x65B0");// 2 characters, 4 bytes long ;both are Unicode characters in the extension

	_LIT(KTestFileNameExt2C4B_short,	"ABCDEF~1.\x65B0");		//Expected short name				

	// Test file creation and long/short name generation

	doFileNameTest(KTestFileNameExt1C2B, 	KTestFileNameExt1C2B_short);

	doFileNameTest(KTestFileNameExt2C3B2U, 	KTestFileNameExt2C3B2U_short);

	doFileNameTest(KTestFileNameExt2C3B1U, 	KTestFileNameExt2C3B1U_short);

	doFileNameTest(KTestFileNameExt2C4B, 	KTestFileNameExt2C4B_short);

	doDirNameTest(KTestFileNameExt1C2B, 	KTestFileNameExt1C2B_short);

	doDirNameTest(KTestFileNameExt2C3B2U, 	KTestFileNameExt2C3B2U_short);

	doDirNameTest(KTestFileNameExt2C3B1U, 	KTestFileNameExt2C3B1U_short);

	doDirNameTest(KTestFileNameExt2C4B, 	KTestFileNameExt2C4B_short);

#else

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

#endif  // _DEBUG) || _DEBUG_RELEASE

	}

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

//! @SYMTestCaseID		PBASE-t_fatcharsetconv-0795

//! @SYMTestCaseDesc    This test case is to test whether the short names generated for file names

//!                     consisting of UNICODE characters are consistent or not. In a shortname, if the character immediately

//!						preceding the tilde(~) is a head byte of a UNICODE character then it should be ignored.

//! @SYMTestActions     1. Creates files and directories with different Unicode strings that 

//!                        have different combinations of length (of characters) and size (of 

//!                        bytes occupied), check for error of creation.

//!                     2. Gets their short name, compares with expected values, gets their long 

//!                        name, compares with original Unicode strings.

//!                        The strings and short name tested are as below:

//!                        2.1. original string: "a\x65B0(bcd)"

//!                             expected short name: "A\x65B0(BCD)";

//!                        2.2. original string: "ab\x65B0(cdef)"

//!                             expected short name: "AB\x65B0(C~1")";

//!                        2.3. original string: "abc\x65B0(def)"

//!                             expected short name: "ABC\x65B0(~1";

//!                        2.4. original string: "abcd\x65B0(ef)"

//!                             expected short name: "ABCD\x65B0~1";

//!                        2.5. original string: "abcde\x65B0(f)"

//!                             expected short name: "ABCDE~1";

//! @SYMTestExpectedResults

//!						1. File should be created with no error;

//!                     2. Comparisons should return 0;

//! @SYMTestPriority    High

//! @SYMTestStatus      Implemented

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

void TestConsistentShortNameGeneration()

	{

	test.Next(_L("Test consistent short name generation"));

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

	TInt r = UserSvr::ChangeLocale(KTestLocale);

	test_KErrNone(r);

	//unicode characters.

	_LIT(KTestFileName7C8B2U, 		"a\x65B0(bcd)");			// 7 characters, 8 bytes long ,Unicode character at the 2nd location.

	_LIT(KTestFileName7C8B2U_short, "A\x65B0(BCD)");			// Expected short name

	_LIT(KTestFileName9C10B3U, 		"ab\x65B0(cdef)");			// 9 characters, 10 bytes long ,Unicode character at the 3rd location.

	_LIT(KTestFileName9C10B3U_short,"AB\x65B0(C~1");			// Expected short name

	_LIT(KTestFileName9C10B4U, 		"abc\x65B0(def)");			// 9 characters, 10 bytes long ,Unicode character at the 4th location.

	_LIT(KTestFileName9C10B4U_short,"ABC\x65B0(~1");			// Expected short name

	_LIT(KTestFileName9C10B5U, 		"abcd\x65B0(ef)");			// 9 characters, 10 bytes long ,Unicode character at the 6th location.

	_LIT(KTestFileName9C10B5U_short,"ABCD\x65B0~1");			// Expected short name

	_LIT(KTestFileName9C10B6U, 		"abcde\x65B0(f)");			// 9 characters, 10 bytes long ,repeat Unicode character at the 6th location.

	_LIT(KTestFileName9C10B6U_short,"ABCDE~1");					// Expected short name

	// Test file creation and long/short name generation

	doFileNameTest(KTestFileName7C8B2U, 		KTestFileName7C8B2U_short);

	doFileNameTest(KTestFileName9C10B3U, 		KTestFileName9C10B3U_short);

	doFileNameTest(KTestFileName9C10B4U, 		KTestFileName9C10B4U_short);

	doFileNameTest(KTestFileName9C10B5U, 		KTestFileName9C10B5U_short);

	doFileNameTest(KTestFileName9C10B6U, 		KTestFileName9C10B6U_short);

	doDirNameTest(KTestFileName7C8B2U, 			KTestFileName7C8B2U_short);

	doDirNameTest(KTestFileName9C10B3U, 		KTestFileName9C10B3U_short);

	doDirNameTest(KTestFileName9C10B4U, 		KTestFileName9C10B4U_short);

	doDirNameTest(KTestFileName9C10B5U, 		KTestFileName9C10B5U_short);

	doDirNameTest(KTestFileName9C10B6U, 		KTestFileName9C10B6U_short);

#else

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

#endif  // _DEBUG) || _DEBUG_RELEASE

	}

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

//! @SYMTestCaseID      PBASE-t_fatcharsetconv-0409

//! @SYMTestType        CIT

//! @SYMDEF             DEF101875 INC100580

//! @SYMTestCaseDesc    This test case is to test creation of files with their Unicode names are 

//!                     duplicate to existing files.

//! @SYMTestActions     1. Creates a file with its name contains 4 Unicode characters but occupies 

//!                        8 bytes ("\x65B0\x6587\x4EF6\x4EF6"), check for creation;

//!                     2. Creates a file with 11 bytes' long Unicode name and first 8 bytes are 

//!                        identical with the file created in Action 1 ("\x65B0\x6587\x4EF6\x4EF6(A)"), 

//!                        check for file creation;

//!                     3. Gets the short name of the file created in Action 2, compares it with 

//!                        expected short name ("\x65B0\x6587\x4EF6~1"), gets the long name of this 

//!                        file and compares it with its original Unicode name;

//!                     4. Creates a file with 12 bytes' long Unicode name and first 8 bytes are 

//!                        identical with the file created in Action 1 and Action 2 

//!                        ("\x65B0\x6587\x4EF6\x4EF6(AB)"), check for file creation;

//!                     5. Gets the short name of the file created in Action 4, compares it with 

//!                        expected values ("\x65B0\x6587\x4EF6~2"), gets the long name of this file 

//!                        and compares it with its original Unicode name;

//! @SYMTestExpectedResults

//!						1. File creation should return KErrNone;

//!                     2. File creation should return KErrNone;

//!                     3. Comparisons should return 0;

//!                     4. File creation should return KErrNone;

//!                     5. Comparisons should return 0;

//! @SYMTestPriority    High

//! @SYMTestStatus      Implemented

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

void TestDuplicateLongFileNames()

	{

	test.Next(_L("Testing tilde and numbers (\"~n\") are applied correctly for multiple long-named files"));

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

	TInt r = UserSvr::ChangeLocale(KTestLocale);

	test_KErrNone(r);

	// These are to test "~1", "~2" behaviours when the first 8 bytes of new files

	//  are identical with existing files

	_LIT(KTestFileName4C8B, 			"\x65B0\x6587\x4EF6\x4EF6.TXT");

	_LIT(KTestFileName7C11B, 			"\x65B0\x6587\x4EF6\x4EF6(A).TXT");	

	_LIT(KTestFileName7C11B_short, 		"\x65B0\x6587\x4EF6~1.TXT");

	_LIT(KTestFileName8C12B, 			"\x65B0\x6587\x4EF6\x4EF6(AB).TXT");	

	_LIT(KTestFileName8C12B_short, 		"\x65B0\x6587\x4EF6~2.TXT");	

	////////////////////////////////////////

	// 1. Test duplicate long file names

	////////////////////////////////////////

	TFileName sn;

	MakeFile(KTestFileName4C8B);

	MakeFile(KTestFileName7C11B);

	r = TheFs.GetShortName(KTestFileName7C11B, sn);

	test_KErrNone(r);

	r = sn.Compare(KTestFileName7C11B_short);

	test_Equal(r, 0);

	MakeFile(KTestFileName8C12B);

	r = TheFs.GetShortName(KTestFileName8C12B, sn);

	test_KErrNone(r);

	r = sn.Compare(KTestFileName8C12B_short);

	test_Equal(r, 0);

	test_KErrNone(TheFs.Delete(KTestFileName4C8B));

	test_KErrNone(TheFs.Delete(KTestFileName7C11B));