Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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));
test_KErrNone(TheFs.Delete(KTestFileName8C12B));
#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-0410
//! @SYMTestType CIT
//! @SYMDEF DEF101875 INC100580
//! @SYMTestCaseDesc This test case is to test creation of directories with their Unicode names are
//! duplicate to existing directories .
//! @SYMTestActions 1. Creates a directories with its name contains 4 Unicode characters but occupies
//! 8 bytes ("\x65B0\x6587\x4EF6\x4EF6"), check for creation;
//! 2. Creates a directories with 11 bytes' long Unicode name and first 8 bytes are
//! identical with the directories created in Action 1 ("\x65B0\x6587\x4EF6\x4EF6(A)"),
//! check for file creation;
//! 3. Gets the short name of the directories created in Action 2, compares it with
//! expected short name ("\x65B0\x6587\x4EF6~1"), gets the long name of this
//! directories and compares it with its original Unicode name;
//! 4. Creates a directories with 12 bytes' long Unicode name and first 8 bytes are
//! identical with the directories created in Action 1 and Action 2
//! ("\x65B0\x6587\x4EF6\x4EF6(AB)"), check for directories creation;
//! 5. Gets the short name of the directories created in Action 4, compares it with
//! expected values ("\x65B0\x6587\x4EF6~2"), gets the long name of this directories
//! and compares it with its original Unicode name;
//! @SYMTestExpectedResults
//! 1. Dir creation should return KErrNone;
//! 2. Dir creation should return KErrNone;
//! 3. Comparisons should return 0;
//! 4. Dir creation should return KErrNone;
//! 5. Comparisons should return 0;
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void TestDuplicateLongDirNames()
{
test.Next(_L("Testing tilde and number appended correctly for duplicate long name dirs"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
TheFs.SessionPath(gSessionPath);
TInt r = UserSvr::ChangeLocale(KTestLocale);
test_KErrNone(r);
// These are to test "~1", "~2" behaviours when the first 8 bytes of new directories
// are identical with existing directories
_LIT(KTestDirName4C8B, "\\F32-TST\\T_LOCALEUTILS_CP932\\\x65B0\x6587\x4EF6\x4EF6\\");
_LIT(KTestDirName7C11B, "\\F32-TST\\T_LOCALEUTILS_CP932\\\x65B0\x6587\x4EF6\x4EF6(A)\\");
_LIT(KTestDirName7C11B_short, "\x65B0\x6587\x4EF6~1");
_LIT(KTestDirName8C12B, "\\F32-TST\\T_LOCALEUTILS_CP932\\\x65B0\x6587\x4EF6\x4EF6(AB)\\");
_LIT(KTestDirName8C12B_short, "\x65B0\x6587\x4EF6~2");
// Create 1st file with 8 bytes long/short name
MakeDir(KTestDirName4C8B);
MakeDir(KTestDirName7C11B);
TFileName sn;
r = TheFs.GetShortName(KTestDirName7C11B, sn);
test_KErrNone(r);
r = sn.Compare(KTestDirName7C11B_short);
test_Equal(r, 0);
MakeDir(KTestDirName8C12B);
r = TheFs.GetShortName(KTestDirName8C12B, sn);
test_KErrNone(r);
r = sn.Compare(KTestDirName8C12B_short);
test_Equal(r, 0);
#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-0791
//! @SYMTestType CIT
//! @SYMDEF DEF117345
//! @SYMTestCaseDesc This test case is to test short name with 'E5' as the leading byte is correctly
//! handled on FAT implementations
//! @SYMTestActions 1. Creates a file with unicode long name "\x88F9.TXT", it will be converted into
//! "\xE5E5.TXT" according to codepage 932 when creating short name.
//! 2. Gets the short name and compare it with its original unicode "\x88F9.TXT", make
//! sure the conversion "\xE5E5.TXT" has been handled correctly
//! @SYMTestExpectedResults
//! 1. Comparisons should return 0;
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void TestLeadingE5Handling()
{
test.Next(_L("Test Leading \'E5\' byte handling (DEF117345)"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
TheFs.SessionPath(gSessionPath);
TInt r = UserSvr::ChangeLocale(KTestLocale);
test_KErrNone(r);
_LIT(KTestFilePathAndName, "\\F32-TST\\T_LOCALEUTILS_CP932\\\x88F9.TXT");
_LIT(KTestFileShortName, "\x88F9.TXT");
MakeFile(KTestFilePathAndName);
TFileName sn;
r = TheFs.GetShortName(KTestFilePathAndName, sn);
test_KErrNone(r);
r = sn.Compare(KTestFileShortName);
test_Equal(r, 0);
#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-2320
//! @SYMTestType CIT
//! @SYMDEF PDEF130334
//! @SYMTestCaseDesc This test case is to test creating a file with "\u3005" name correctly
//! @SYMTestActions 1. Creates a file with unicode long name "\u3005.TXT"
//! 2. Gets the short name and compare it with its original unicode "\u3005.TXT"
//! 3. Gets the long name and compare it with its original unicode "\u3005.TXT"
//! @SYMTestExpectedResults
//! 1. Comparisons should return 0;
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void TestDEF130334()
{
test.Next(_L("Test creating a file with \\x3005 name correctly (DEF128521)"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
TheFs.SessionPath(gSessionPath);
TInt r = UserSvr::ChangeLocale(KTestLocale);
test_KErrNone(r);
_LIT(KTestFilePathAndName, "\\F32-TST\\T_LOCALEUTILS_CP932\\\x3005.TXT");
_LIT(KTestFileName, "\x3005.TXT");
MakeFile(KTestFilePathAndName);
TFileName sn;
r = TheFs.GetShortName(KTestFilePathAndName, sn);
test_KErrNone(r);
r = sn.Compare(KTestFileName);
test_Equal(r, 0);
TFileName ln;
r = TheFs.GetLongName(KTestFilePathAndName, ln);
test_KErrNone(r);
r = ln.Compare(KTestFileName);
test_Equal(r, 0);
#else
test.Printf(_L("Test only runs on DEBUG builds, see test logs of debug builds for details."));
#endif
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID PBASE-t_fatcharsetconv-1359
//! @SYMTestType CIT
//! @SYMDEF INC125768
//! @SYMTestCaseDesc This test case is to test the compatibility of file opening, to make sure files
//! with only one DOS entry which contains unicode short name is accessible on Symbian OS
//! from version 9.3 onwards.
//! @SYMTestActions Manually creates a single entried, unicode named file under root direcotry, then
//! access it via RFs::Entry() API using its uniocde name. Check the entry is accessible.
//! @SYMTestExpectedResults
//! RFs::Entry() should return with KErrNone;
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void TestCompatibility()
{
test.Next(_L("test file opening compatibility"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
GetBootInfo();
RFile file;
TFileName fn = _L("\\ABCD");
TInt r=file.Create(TheFs,fn,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 the 1st dir entry, it should be a 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);
test(!fatEntry1.IsVFatEntry());
// Manually modify the short name into unicode characters
// Unicode: 0x(798F 5C71 96C5 6CBB)
// Shift-JIS: 0x(959F 8E52 89EB 8EA1)
TBuf8<8> unicodeSN = _L8("ABCD1234");
unicodeSN[0] = 0x95;
unicodeSN[1] = 0x9F;
unicodeSN[2] = 0x8E;
unicodeSN[3] = 0x52;
unicodeSN[4] = 0x89;
unicodeSN[5] = 0xEB;
unicodeSN[6] = 0x8E;
unicodeSN[7] = 0xA1;
fatEntry1.SetName(unicodeSN);
test(TheDisk.Write(posEntry1, ptrEntry1)==KErrNone);
TheDisk.Close();
// Access the file using its unicode file name
r = UserSvr::ChangeLocale(KTestLocale);
test_KErrNone(r);
fn = _L("\\ABCD");
fn[1] = 0x798F;
fn[2] = 0x5C71;
fn[3] = 0x96C5;
fn[4] = 0x6CBB;
TEntry entry;
TInt err = TheFs.Entry(fn, entry);
test(err==KErrNone);
err = TheFs.Delete(fn);
test(err==KErrNone);
#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-1395
//! @SYMTestType CIT
//! @SYMDEF INC126563
//! @SYMTestCaseDesc This test case is to test the definition of valid DOS characters on Symbian
//! FAT/FAT32 complies with FAT Spec.
//! @SYMTestActions Manually creates a file with "0x7F" characters in its name, then check it can
//! ben accessed successfully.
//! @SYMTestExpectedResults
//! RFs::Entry() should return with KErrNone;
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void TestINC126563()
{
test.Next(_L("Test INC126563: FAT/FAT32: unable to open or delete file whose name contains illegal characters"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
GetBootInfo();
RFile file;
TFileName fn = _L("\\AB");
test.Next(_L("create file \"AB\" under root directory"));
TInt r=file.Create(TheFs,fn,EFileRead);
test(r==KErrNone);
file.Close();
test.Next(_L("manually change file name to \"0x7F0x450x7F0x45\" via raw disk accessing"));
// Assume this file is the first entry in the root directory
r=TheDisk.Open(TheFs,CurrentDrive());
test(r==KErrNone);
//-- read the first dir entry, it should be a 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);
test(!fatEntry1.IsVFatEntry());
TBuf8<8> unicodeSN = _L8("ABCD");
unicodeSN[0] = 0x7F;
unicodeSN[1] = 0x45;
unicodeSN[2] = 0x7F;
unicodeSN[3] = 0x45;
fatEntry1.SetName(unicodeSN);
test(TheDisk.Write(posEntry1, ptrEntry1)==KErrNone);
TheDisk.Close();
// Access the file using its unicode file name
r = UserSvr::ChangeLocale(KTestLocale);
test(KErrNone==r);
test.Next(_L("access entries under root directory via RDir::Open()"));
RDir dir;
r = dir.Open(TheFs, _L("\\"), KEntryAttNormal);
test(KErrNone == r);
TEntryArray entryArray;
r = dir.Read(entryArray);
test(entryArray.Count()==1);
TBuf<0x10> name;
TEntry entry;
entry = entryArray[0];
test.Printf(_L("entryArray[0] = \"%S\"\n"), &entry.iName);
name = entry.iName;
dir.Close();
TFileName fullname= _L("\\");
fullname.Append(name);
test.Next(_L("try to open or delete file entries retrieved"));
r = file.Open(TheFs, fullname, EFileRead);
test(KErrNone == r);
file.Close();
r = TheFs.Delete(fullname);
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-1402
//! @SYMTestType CIT
//! @SYMDEF INC127905
//! @SYMTestCaseDesc This test case is to test RFs::ScanDrive() does not incorrectly remove files
//! with unicode short file names.
//! @SYMTestActions Creates a file with unicode file names then check if the file is still accessible
//! after scandrive operations.
//! @SYMTestExpectedResults
//! RFs::Delete() should return with KErrNone;
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
void TestINC127905()
{
test.Next(_L("Test INC127905: Unicode name file deleted after Scandrive"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
TFileName fn = _L("ABCDE");
fn[0] = 0x3055;
fn[1] = 0x307E;
fn[2] = 0x3056;
fn[3] = 0x307E;
fn[4] = 0x306A;
TInt r = UserSvr::ChangeLocale(KTestLocale);
test(KErrNone==r);
MakeFile(fn);
_LIT(KShortName, "\x3055\x307E\x3056~1");
TFileName sn;
r = TheFs.GetShortName(fn, sn);
test(r==KErrNone);
r = sn.Compare(KShortName);
test(r==0);
r = TheFs.ScanDrive(_L("gSessionPath"));
test(r==KErrNone);
r = TheFs.Delete(fn);
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
}
void CallTestsL(void)
{
test.Title();
test.Start(_L("Starting T_LOCALEUTILS_CP932 tests"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
// Test only runs on Fat file systems
TheFs.SessionPath(gSessionPath);
TInt driveNum = CurrentDrive();
TFSName name;
TInt r = TheFs.FileSystemName(name, driveNum);
if (KErrNone == r)
{
if (name.Compare(_L("Fat")) != 0)
{
test.Printf(_L("Test only runs on 'Fat' drives"));
}
else
{
// Enables codepage dll implementation of LocaleUtils functions for this test only
r = TheFs.ControlIo(driveNum, KControlIoEnableFatUtilityFunctions);
test_KErrNone(r);
CreateTestDirectory(_L("\\F32-TST\\T_LOCALEUTILS_CP932\\"));
TestBeforeFATCharsetConvInteg();
TestUnicodeVolumeLabel();
TestShortNameBoundary();
TestConsistentShortNameGeneration();
TestConsistentShortNameExtGeneration();
TestDuplicateLongFileNames();
TestDuplicateLongDirNames();
TestLeadingE5Handling();
TestDEF130334();
TestINC127905();
DeleteTestDirectory();
TestCompatibility();
TestINC126563();
// Disables codepage dll implementation of LocaleUtils functions for other base tests
r = TheFs.ControlIo(driveNum, KControlIoDisableFatUtilityFunctions);
test_KErrNone(r);
}
}
else
{
test.Printf(_L("Drive %C: is not ready!"), 'A'+driveNum);
test(EFalse);
}
#else
test.Printf(_L("Test only runs on DEBUG builds, see test logs of debug builds for details."));
#endif // _DEBUG) || _DEBUG_RELEASE
test.End();
}