diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/apputils/tsrc/T_BaflUtilsImp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lowlevellibsandfws/apputils/tsrc/T_BaflUtilsImp.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,1029 @@ +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "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: +// Tests some code internal to BaflUtils +// +// + +#include "BaUtilsImp.h" +#include +#include +#include + +#define UNUSED_VAR(a) a = a + +const TPtrC KValFolderName=_L("ValidFolderName"); +const TPtrC KCurrentPath=_L("C:\\System\\Data\\"); +const TPtrC KNoFolderName = _L(""); +const TPtrC KInValidFolderName=_L("C:\\System\\Data\\InValid3+FollderName"); + +namespace +{ +CTrapCleanup* TrapCleanup; +RTest test(_L("T_BaflUtilsImp - Internal Bafl function tests")); +} + +class RTestDirectoryScanner : public RDirectoryScanner + { +public: + RTestDirectoryScanner(CDesCArray*& aMember) + : iOpenError(0), iFilesThatExist(aMember) + { + for (TInt i = 0; i != 26; ++i) + iDriveError[i] = 0; + } + virtual TInt Open(RFs&, const TDesC& aMatchPattern) + { + iMatch = aMatchPattern; + iIndex = 0; + return iOpenError; + } + virtual TInt Next(TEntry& aOut) + { + if (!iFilesThatExist) + return KErrEof; + while (iIndex < iFilesThatExist->Count()) + { + TInt i = iIndex++; + if (0 <= (*iFilesThatExist)[i].MatchF(iMatch)) + { + TPtrC fullName=(*iFilesThatExist)[i]; + TParsePtrC name(fullName); + aOut.iName=name.NameAndExt(); + if (1 < fullName.Length() && fullName[1] == ':') + { + TInt drive = fullName[0]; + if ('a' <= drive && drive <= 'z') + drive -= 'a'; + else + { + ASSERT('A' <= drive && drive <= 'Z'); + drive -= 'A'; + } + return iDriveError[drive]; + } + return KErrNone; + } + } + return KErrEof; + } + virtual void Close() {} + TInt iOpenError; + TInt iDriveError[26]; +private: + CDesCArray *&iFilesThatExist; + TInt iIndex; + TFileName iMatch; + }; + +class TTestNearestLanguageFileFinder : public TNearestLanguageFileFinder + { +public: + TTestNearestLanguageFileFinder(const RFs& aFs) + : TNearestLanguageFileFinder(aFs), iTestScanner(iFilesThatExist) + { + iFilesThatExist = 0; + iFilesSearchedFor = 0; + } + ~TTestNearestLanguageFileFinder() + { + delete iFilesThatExist; + delete iFilesSearchedFor; + } + virtual TInt GetCustomResourceDriveNumber() const { return iCustomRscDrive; } + virtual TBool FileExists(const TDesC& aFileName) const + { + test(aFileName[1] == ':'); + test(0 == aFileName.Left(1).CompareF(iDrivesChecked.Left(1))); + iDrivesChecked.Delete(0, 1); + test(0 <= aFileName.MatchF(iFileCheckedFor)); + if (iFilesSearchedFor) + { + test(0 == aFileName.CompareF((*iFilesSearchedFor)[0])); + iFilesSearchedFor->Delete(0); + } + if (!iFilesThatExist) + return EFalse; + TInt i; + iFilesThatExist->Find(aFileName, i); + return (0 <= i && i < iFilesThatExist->Count())? ETrue : EFalse; + } + virtual RDirectoryScanner& DirectoryScanner() { return iTestScanner; } + + TInt iCustomRscDrive; + CDesCArray* iFilesThatExist; + // File that is expected to go into FileExists. + // Can contain wildcards. + TFileName iFileCheckedFor; + // Drives expected in calls to FileExists. The first one is checked then + // discarded each time FileExists is called. + mutable TBuf<26> iDrivesChecked; + CDesCArray* iFilesSearchedFor; + RTestDirectoryScanner iTestScanner; + }; + +void TestPath(const TLanguagePath& aPath, const TLanguage* aExpected, TInt aExpectedCount) + { + for (int i = 0; i != aExpectedCount; ++i) + test(aPath[i] == *aExpected++); + test(aPath[aExpectedCount] == ELangNone); + } + +const TLanguage ExpectedPath[] = { ELangFrench, ELangJapanese, ELangGerman, ELangGreek, + ELangArabic, ELangEnglish, ELangItalian, ELangHebrew }; + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0443 +@SYMTestCaseDesc Tests TLanguagePath class +@SYMTestPriority High +@SYMTestActions Test for adding different language paths +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestAddLanguage() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0443 ")); + TLanguagePath path; + path[0] = ELangNone; + AddLanguage(path, ELangNone); + TestPath(path, ExpectedPath, 0); + AddLanguage(path, ELangFrench); + TestPath(path, ExpectedPath, 1); + AddLanguage(path, ELangFrench); + TestPath(path, ExpectedPath, 1); + AddLanguage(path, ELangNone); + TestPath(path, ExpectedPath, 1); + AddLanguage(path, ELangFrench); + TestPath(path, ExpectedPath, 1); + AddLanguage(path, ELangJapanese); + TestPath(path, ExpectedPath, 2); + AddLanguage(path, ELangFrench); + TestPath(path, ExpectedPath, 2); + AddLanguage(path, ELangNone); + TestPath(path, ExpectedPath, 2); + AddLanguage(path, ELangGerman); + TestPath(path, ExpectedPath, 3); + AddLanguage(path, ELangGreek); + TestPath(path, ExpectedPath, 4); + AddLanguage(path, ELangArabic); + TestPath(path, ExpectedPath, 5); + AddLanguage(path, ELangNone); + TestPath(path, ExpectedPath, 5); + AddLanguage(path, ELangEnglish); + TestPath(path, ExpectedPath, 6); + AddLanguage(path, ELangItalian); + TestPath(path, ExpectedPath, 7); + AddLanguage(path, ELangNone); + TestPath(path, ExpectedPath, 7); + AddLanguage(path, ELangHebrew); + TestPath(path, ExpectedPath, 8); + AddLanguage(path, ELangHebrew); + TestPath(path, ExpectedPath, 8); + AddLanguage(path, ELangEnglish); + TestPath(path, ExpectedPath, 8); + AddLanguage(path, ELangItalian); + TestPath(path, ExpectedPath, 8); + AddLanguage(path, ELangNone); + TestPath(path, ExpectedPath, 8); + AddLanguage(path, ELangFrench); + TestPath(path, ExpectedPath, 8); + AddLanguage(path, ELangNone); + TestPath(path, ExpectedPath, 8); + AddLanguage(path, ELangGerman); + TestPath(path, ExpectedPath, 8); + } + +struct SDowngradeTest + { + TLanguage iIn[4]; + TLanguage iOut[9]; + }; + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0444 +@SYMTestCaseDesc Tests for the functionality of TLocale class +@SYMTestPriority High +@SYMTestActions Test for language downgrades +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestDowngrade(SDowngradeTest& aTest) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0444 ")); + TLocale loc; + loc.SetLanguageDowngrade(0, aTest.iIn[1]); + loc.SetLanguageDowngrade(1, aTest.iIn[2]); + loc.SetLanguageDowngrade(2, aTest.iIn[3]); + TLanguagePath path; + MakeLanguageDowngradePath(path, aTest.iIn[0], ELangNone, loc); + for (int i = 0; ; ++i) + { + test(i < 9); + test(aTest.iOut[i] == path[i]); + if (path[i] == ELangNone) + return; + } + } + + +// Test Dialect enumeration. +// Each value represents a dialect (variant) of a TLanguage language. +// E.g. AmericanSprint is represented by ELangAmerican | EDialectSprint + +// The dialect location -- top six bits +const TUint KDialectFactor=0x0400; +enum TDialect + { + // The following are example dialects for testing only + EDialectSprint = (1*KDialectFactor), + EDialectOrange = (2*KDialectFactor), + EDialectMaximum = EDialectOrange // This must always be equal to the last TDialect enum. + // Up to 63 dialects. + }; + +const TLanguage ELangEnglishOrange = static_cast(ELangEnglish|EDialectOrange); +const TLanguage ELangAmericanSprint = static_cast(ELangAmerican|EDialectSprint); + +SDowngradeTest DowngradeData[] = + { + // 0 = test language + // 1-3 = language downgrade for locale + // 4- = calculated language downgrade path, terminated with ELangNone. + {{ELangEnglishOrange, ELangNone, ELangNone, ELangNone}, + {ELangEnglishOrange, ELangEnglish, ELangNone}}, + {{ELangAmericanSprint, ELangNone, ELangNone, ELangNone}, + {ELangAmericanSprint, ELangAmerican, ELangEnglish, ELangNone}}, + {{ELangFrench, ELangNone, ELangNone, ELangNone}, + {ELangFrench, ELangNone}}, + {{ELangSwissFrench, ELangNone, ELangNone, ELangNone}, + {ELangSwissFrench, ELangFrench, ELangNone}}, + {{ELangCanadianEnglish, ELangNone, ELangNone, ELangNone}, + {ELangCanadianEnglish, ELangAmerican, ELangEnglish, ELangNone}}, + {{ELangSwissFrench, ELangNone, ELangFrench, ELangNone}, + {ELangSwissFrench, ELangFrench, ELangNone}}, + {{ELangCanadianEnglish, ELangEnglish, ELangNone, ELangAmerican}, + {ELangCanadianEnglish, ELangEnglish, ELangAmerican, ELangNone}}, + {{ELangCanadianEnglish, ELangNone, ELangNone, ELangSwissFrench}, + {ELangCanadianEnglish, ELangSwissFrench, ELangAmerican, ELangEnglish, ELangNone}}, + {{ELangCanadianEnglish, ELangFrench, ELangAmerican, ELangSwissFrench}, + {ELangCanadianEnglish, ELangFrench, ELangAmerican, ELangSwissFrench, ELangEnglish, ELangNone}}, + {{ELangCanadianEnglish, ELangNone, ELangGerman, ELangSwissFrench}, + {ELangCanadianEnglish, ELangGerman, ELangSwissFrench, ELangAmerican, ELangEnglish, ELangNone}}, + {{ELangCanadianEnglish, ELangFinlandSwedish, ELangGerman, ELangSwissFrench}, + {ELangCanadianEnglish, ELangFinlandSwedish, ELangGerman, ELangSwissFrench, ELangAmerican, ELangEnglish, ELangNone}}, + {{ELangFinlandSwedish, ELangFinlandSwedish, ELangFinlandSwedish, ELangFinlandSwedish}, + {ELangFinlandSwedish, ELangSwedish, ELangNone}}, + }; + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0445 +@SYMTestCaseDesc Tests for language downgrades +@SYMTestPriority High +@SYMTestActions Call up downgrade path test function +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestMakeLanguageDowngradePath() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0445 ")); + for (int i = 0; i != sizeof(DowngradeData)/sizeof(DowngradeData[0]); ++i) + TestDowngrade(DowngradeData[i]); + } + +void SetUpFinderForLanguageAndDriveSearchL( + TTestNearestLanguageFileFinder& aFinder) + { + aFinder.iDrives = _L("ZAG"); + aFinder.iFilesSearchedFor = new(ELeave) CDesCArraySeg(10); + aFinder.iFilesSearchedFor->AppendL(_L("z:\\dir\\name.e02")); + aFinder.iFilesSearchedFor->AppendL(_L("a:\\dir\\name.e02")); + aFinder.iFilesSearchedFor->AppendL(_L("g:\\dir\\name.e02")); + aFinder.iFilesSearchedFor->AppendL(_L("z:\\dir\\name.e15702")); //Extended lang + aFinder.iFilesSearchedFor->AppendL(_L("a:\\dir\\name.e15702")); + aFinder.iFilesSearchedFor->AppendL(_L("g:\\dir\\name.e15702")); + aFinder.iFilesSearchedFor->AppendL(_L("z:\\dir\\name.e01")); + aFinder.iFilesSearchedFor->AppendL(_L("a:\\dir\\name.e01")); + aFinder.iFilesSearchedFor->AppendL(_L("g:\\dir\\name.e01")); + aFinder.iFilesSearchedFor->AppendL(_L("z:\\dir\\name.ext")); + aFinder.iFilesSearchedFor->AppendL(_L("a:\\dir\\name.ext")); + aFinder.iFilesSearchedFor->AppendL(_L("g:\\dir\\name.ext")); + aFinder.iDrivesChecked = _L("zagzagzagzagzag"); + } + +_LIT(KTestFileName1, "z:\\dir\\name.ext"); +//_LIT(KTestFileName2, "z:\\dir\\náme.ext"); +_LIT(KTestFileName2, "z:\\dir\\n\u00c1me.ext"); +_LIT(KTestFileName3, "a:\\dir\\name.ext"); +_LIT(KTestFileName4, "c:\\dir\\name.ext"); +_LIT(KTestFileName5, "d:\\dir\\name.ext"); +_LIT(KTestFileName6, "y:\\dir\\name.ext"); +_LIT(KTestFileName7, "A:\\dir\\name.ext"); +_LIT(KTestFileName8, "C:\\dir\\name.ext"); +_LIT(KTestFileName9, "Y:\\dir\\name.ext"); +_LIT(KTestFileName11, "\\abc\\defg.hijkl"); +_LIT(KTestFileName256Chars, "\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz01234\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz01234\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz01234\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz0.ext"); + +_LIT(KExpectedFileName256Chars, "?:\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz01234\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz01234\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz01234\ +\\abcdefghijklmnopqrstuvwxyz01234\\abcdefghijklmnopqrstuvwxyz0.e"); +_LIT(KExpectedFileName1, "?:\\dir\\name.e"); +_LIT(KExpectedSuffix1, "xt"); +_LIT(KExpectedFileName2, "?:\\abc\\defg.hij"); +_LIT(KExpectedSuffix2, "kl"); +_LIT(KTestFileName1French, "z:\\dir\\name.e02"); +_LIT(KTestFileName1Japanese, "z:\\dir\\name.e32"); +_LIT(KTestFileName1Mongolian, "z:\\dir\\name.e54321"); +_LIT(KTestFileName1AmericanSprint, "z:\\dir\\name.e1034"); //American=0x0A, Sprint=0x0400. 0x040A=1034. +_LIT(KCheckedForFrench, "?:\\dir\\name.e02"); + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0446 +@SYMTestCaseDesc Nearest language finder test +@SYMTestPriority High +@SYMTestActions Test drive sequence construction + Test addition of language number + Test searching each drive for the specified file + Test searching language and drive down the language path + Test filename matching + Test searching for any language file within a drive + Test searching all drives for any language +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestNearestLanguageFinder() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0446 ")); + RFs dummy; + TTestNearestLanguageFileFinder finder(dummy); + + // Test file name setting and disecting + // SetFileName + // RepairFileName + TFileName fileName(KTestFileName1); + finder.SetFileName(fileName); + test(0 <= finder.iFileName->MatchF(KExpectedFileName1)); + test(0 == finder.iSuffix.Compare(KExpectedSuffix1)); + test('z' == finder.iInitialDriveLetter); + finder.RepairFileName(); + test(0 == finder.iFileName->Compare(KTestFileName1)); + fileName = KTestFileName11; + finder.SetFileName(fileName); + test(0 <= finder.iFileName->MatchF(KExpectedFileName2)); + test(0 == finder.iSuffix.Compare(KExpectedSuffix2)); + test(-1 == finder.iInitialDriveLetter); + finder.RepairFileName(); + test(0 == finder.iFileName->Compare(KTestFileName11)); + fileName = KTestFileName256Chars; + finder.SetFileName(fileName); + test(0 <= finder.iFileName->MatchF(KExpectedFileName256Chars)); + test(0 == finder.iSuffix.Compare(KExpectedSuffix1)); + test(-1 == finder.iInitialDriveLetter); + finder.RepairFileName(); + test(0 == finder.iFileName->Compare(KTestFileName256Chars)); + + // Test drive sequence construction + // AddCustomResourceDrive + finder.iCustomRscDrive = static_cast(EDriveC); // drive c: + fileName = KTestFileName1; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrNone); + test(0 == finder.iDrives.CompareF(_L("CZ"))); + fileName = KTestFileName3; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrNone); + test(0 == finder.iDrives.CompareF(_L("CA"))); + fileName = KTestFileName4; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrAlreadyExists); + test(0 == finder.iDrives.CompareF(_L("C"))); + fileName = KTestFileName5; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrNone); + test(0 == finder.iDrives.CompareF(_L("CD"))); + fileName = KTestFileName6; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrNone); + test(0 == finder.iDrives.CompareF(_L("CY"))); + fileName = KTestFileName7; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrNone); + test(0 == finder.iDrives.CompareF(_L("CA"))); + fileName = KTestFileName8; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrAlreadyExists); + test(0 == finder.iDrives.CompareF(_L("C"))); + fileName = KTestFileName9; + finder.SetFileName(fileName); + test(finder.AddCustomResourceDrive() == KErrNone); + test(0 == finder.iDrives.CompareF(_L("CY"))); + // AddAllDrives + fileName = KTestFileName1; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("ZYXWVUTSRQPONMLKJIHGFEDCBA"))); + fileName = KTestFileName3; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("AYXWVUTSRQPONMLKJIHGFEDCBZ"))); + fileName = KTestFileName4; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("CYXWVUTSRQPONMLKJIHGFEDBAZ"))); + fileName = KTestFileName5; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("DYXWVUTSRQPONMLKJIHGFECBAZ"))); + fileName = KTestFileName6; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("YXWVUTSRQPONMLKJIHGFEDCBAZ"))); + fileName = KTestFileName7; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("AYXWVUTSRQPONMLKJIHGFEDCBZ"))); + fileName = KTestFileName8; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("CYXWVUTSRQPONMLKJIHGFEDBAZ"))); + fileName = KTestFileName9; + finder.SetFileName(fileName); + finder.AddAllDrives(); + test(0 == finder.iDrives.CompareF(_L("YXWVUTSRQPONMLKJIHGFEDCBAZ"))); + + // Test addition of language number + // AppendLanguageCode + fileName = KTestFileName1; + finder.SetFileName(fileName); + finder.AppendLanguageCode(ELangFrench); + test(0 == finder.iFileName->CompareF(KTestFileName1French)); + finder.SetFileName(fileName); + finder.AppendLanguageCode(ELangJapanese); + test(0 == finder.iFileName->CompareF(KTestFileName1Japanese)); + finder.SetFileName(fileName); + finder.AppendLanguageCode(ELangAmericanSprint); + test(0 == finder.iFileName->CompareF(KTestFileName1AmericanSprint)); + + fileName = KTestFileName1; + finder.SetFileName(fileName); + finder.AppendLanguageCode(static_cast(54321)); + test(0 == finder.iFileName->CompareF(KTestFileName1Mongolian)); + fileName = KTestFileName256Chars; + finder.SetFileName(fileName); + test(!finder.AppendLanguageCode(ELangFrench)); + + // Test searching each drive for the specified file + // FindDrive + finder.iFileCheckedFor = KCheckedForFrench; + finder.iDrivesChecked = _L("D"); + fileName = KTestFileName5; + finder.SetFileName(fileName); + finder.AppendLanguageCode(ELangFrench); + finder.FindDrive(); + test(finder.iDrivesChecked.Length() == 0); + finder.SetFileName(fileName); + finder.AddAllDrives(); + finder.iDrivesChecked = _L("dyxwvutsrqponmlkjihgfecbaz"); + finder.AppendLanguageCode(ELangFrench); + finder.FindDrive(); + test(finder.iDrivesChecked.Length() == 0); + fileName = KTestFileName5; + finder.SetFileName(fileName); + finder.AddAllDrives(); + finder.iDrivesChecked = _L("dyxwvutsrqponmlkjihgfecbaz"); + finder.AppendLanguageCode(ELangFrench); + finder.iFilesThatExist = new (ELeave) CDesCArraySeg(10); + finder.iFilesThatExist->AppendL(_L("o:\\dIR\\NAmE.E02")); + test(finder.FindDrive()); + test(0 == finder.iFileName->CompareF(_L("O:\\dir\\name.e02"))); + fileName = KTestFileName2; + finder.SetFileName(fileName); + finder.AppendLanguageCode(ELangFrench); + finder.AddAllDrives(); + finder.iDrivesChecked = _L("zyxwvutsrqponmlkjihgfedcba"); + finder.iFilesThatExist->AppendL(_L("v:\\dIR\\NA\x301mE.E02")); + //finder.iFileCheckedFor = _L("?:\\dir\\nÁme.e02"); + finder.iFileCheckedFor = _L("?:\\dir\\n\u00c1me.e02"); + test(finder.FindDrive()); + //test(0 == finder.iFileName->CompareF(_L("v:\\dir\\nÁme.e02"))); + test(0 == finder.iFileName->CompareF(_L("v:\\dir\\n\u00c1me.e02"))); + delete finder.iFilesThatExist; + finder.iFilesThatExist = 0; + + // Test searching language and drive down the language path + // FindLanguageAndDrive + finder.iPath[0] = static_cast(2); + finder.iPath[1] = static_cast(15702); + finder.iPath[2] = static_cast(1); + finder.iPath[3] = ELangNone; + fileName = KTestFileName1; + finder.SetFileName(fileName); + SetUpFinderForLanguageAndDriveSearchL(finder); + finder.iFileCheckedFor = _L("?:\\dir\\name.e*"); + test(!finder.FindLanguageAndDrive()); + // check that iFileName is undamaged + finder.RepairFileName(); + test(0 == finder.iFileName->CompareF(KTestFileName1)); + delete finder.iFilesSearchedFor; + finder.iFilesThatExist = new (ELeave) CDesCArraySeg(10); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.e15702")); + fileName = KTestFileName1; + finder.SetFileName(fileName); + SetUpFinderForLanguageAndDriveSearchL(finder); + test(finder.FindLanguageAndDrive()); + test(0 == finder.iFileName->CompareF(_L("a:\\dir\\name.e15702"))); + delete finder.iFilesSearchedFor; + finder.iFilesSearchedFor = 0; + + finder.iPath[0] = static_cast(7); + finder.iPath[1] = ELangNone; + finder.iFilesThatExist->AppendL(_L("g:\\dir\\name.ext")); + fileName = KTestFileName1; + finder.SetFileName(fileName); + finder.iDrives = _L("ZAG"); + finder.iDrivesChecked = _L("ZAGZAG"); + test(finder.FindLanguageAndDrive()); + test(0 == finder.iFileName->CompareF(_L("g:\\dir\\name.ext"))); + delete finder.iFilesThatExist; + finder.iFilesThatExist = 0; + + // Test filename matching + // LanguageNumberFromFile + test(4 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb04"), _L("AVB"))); + //test(4 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("ávb04"), _L("A\x301VB"))); + //test(4 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("a\x301vb04"), _L("ÁVB"))); + test(4 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("\u00e1vb04"), _L("A\x301VB"))); + test(4 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("a\x301vb04"), _L("\u00c1VB"))); + test(5254 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb5254"), _L("aVb"))); + test(KErrNotFound == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb04"), _L("avb04"))); + test(KErrNotFound == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb04"), _L("av"))); + test(KErrNotFound == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb04"), _L(""))); + test(0 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb0000000"), _L("AVB00000"))); + test(4 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb000000004"), _L("AVB0000000"))); + test(100004 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb000100004"), _L("AVB000"))); + test(111114 == TNearestLanguageFileFinder::LanguageNumberFromFile(_L("avb0111114"), _L("AVB0"))); + + // Test searching for any language file within a drive + // FindFirstLanguageFile + fileName = KTestFileName3; + finder.SetFileName(fileName); + finder.iFilesThatExist = new (ELeave) CDesCArraySeg(10); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.e107")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.e07")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.e02")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.ee01")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.01")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name01")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name01.e01")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.e15108")); + finder.iFilesThatExist->AppendL(_L("a:\\dir\\name.e03")); + finder.iTestScanner.iDriveError[0] = KErrNoMemory; + fileName = KTestFileName3; + finder.SetFileName(fileName); + test(KErrNotFound == finder.FindFirstLanguageFile(dummy)); + finder.iTestScanner.iDriveError[0] = KErrAbort; + fileName = KTestFileName3; + finder.SetFileName(fileName); + test(KErrNotFound == finder.FindFirstLanguageFile(dummy)); + finder.iTestScanner.iDriveError[0] = KErrNone; + fileName = KTestFileName3; + finder.SetFileName(fileName); + test(0 <= finder.FindFirstLanguageFile(dummy)); + test(0 == finder.iFileName->CompareF(_L("a:\\dir\\name.e02"))); + + finder.iFilesThatExist->AppendL(_L("a:\\abaffafg.100")); + finder.iFilesThatExist->AppendL(_L("a:\\abcdefg.9539")); + finder.iFilesThatExist->AppendL(_L("a:\\abcdefg.19539")); + finder.iFilesThatExist->AppendL(_L("a:\\abcdefg.1000")); + finder.iFilesThatExist->AppendL(_L("a:\\abaffafg.102")); + fileName = _L("a:\\abcdefg.xx"); + finder.SetFileName(fileName); + test(0 <= finder.FindFirstLanguageFile(dummy)); + test(0 == finder.iFileName->CompareF(_L("a:\\abcdefg.1000"))); + finder.iFilesThatExist->AppendL(_L("a:\\abaffafg.aaa100")); + finder.iFilesThatExist->AppendL(_L("a:\\abcdefg.0523")); // not well-formed. Will not count. + finder.iFilesThatExist->AppendL(_L("a:\\abcdefg.1001")); + fileName = _L("a:\\abcdefg.xx"); + finder.SetFileName(fileName); + test(0 <= finder.FindFirstLanguageFile(dummy)); + test(0 == finder.iFileName->CompareF(_L("a:\\abcdefg.1000"))); + fileName = _L("a:\\abaffafg.xx"); + finder.SetFileName(fileName); + test(0 <= finder.FindFirstLanguageFile(dummy)); + test(0 == finder.iFileName->CompareF(_L("a:\\abaffafg.100"))); + finder.iFilesThatExist->AppendL(_L("a:\\abaffafg.09")); + fileName = _L("a:\\abaffafg.xx"); + finder.SetFileName(fileName); + test(0 <= finder.FindFirstLanguageFile(dummy)); + test(0 == finder.iFileName->CompareF(_L("a:\\abaffafg.09"))); + + // Test searching all drives for any language + // FindFirstLanguageFileAndDrive + finder.iFilesThatExist->AppendL(_L("z:\\abcdefg.05")); + fileName = _L("c:\\abcdefg.xx"); + finder.SetFileName(fileName); + finder.iDrives = _L("az"); + test(0 <= finder.FindFirstLanguageFileAndDrive()); + test(0 == finder.iFileName->CompareF(_L("a:\\abcdefg.1000"))); + fileName = _L("c:\\abaffafg.xx"); + finder.SetFileName(fileName); + finder.iDrives = _L("az"); + test(0 <= finder.FindFirstLanguageFileAndDrive()); + test(0 == finder.iFileName->CompareF(_L("a:\\abaffafg.09"))); + fileName = _L("c:\\abcdefg.xx"); + finder.SetFileName(fileName); + finder.iDrives = _L("za"); + test(0 <= finder.FindFirstLanguageFileAndDrive()); + test(0 == finder.iFileName->CompareF(_L("z:\\abcdefg.05"))); + fileName = _L("c:\\xxx.xx"); + finder.SetFileName(fileName); + finder.iDrives = _L("za"); + test(KErrNotFound == finder.FindFirstLanguageFileAndDrive()); + finder.iTestScanner.iDriveError[25] = KErrAbort; + fileName = _L("c:\\abcdefg.xx"); + finder.SetFileName(fileName); + finder.iDrives = _L("za"); + test(0 <= finder.FindFirstLanguageFileAndDrive()); + test(0 == finder.iFileName->CompareF(_L("a:\\abcdefg.1000"))); + fileName = _L("c:\\abcdefg.xx"); + finder.SetFileName(fileName); + finder.iDrives = _L("za"); + finder.iTestScanner.iDriveError[0] = KErrNoMemory; + test(KErrNotFound == finder.FindFirstLanguageFileAndDrive()); + fileName = _L("c:\\abcdefg.xx"); + finder.SetFileName(fileName); + finder.iDrives = _L("za"); + finder.iTestScanner.iDriveError[0] = KErrAbort; + test(KErrNotFound == finder.FindFirstLanguageFileAndDrive()); + + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0447 +@SYMTestCaseDesc Tests for defect number DEF039977 +@SYMTestPriority High +@SYMTestActions Test for Panic in BaflUtils::DiskIsReadOnly() + when unexpected parameter supplied +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestforDEF039977() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0447 ")); + TFileName filename; + TBool readOnly; + TInt theRes; + RFs fileserver; + TInt err=fileserver.Connect(); + test(err==KErrNone); + + filename=_L("c"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrBadName); + + filename=_L(" z:"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrBadName); + + filename=_L("z\\"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrBadName); + + filename=_L("b:"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrNotReady); + + filename=_L("c:"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrNone); + test(!readOnly); + + filename=_L("z:"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrNone); + test(readOnly); + + filename=_L("z:\\"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrNone); + + filename=_L("z:\\system\\data\\"); + theRes=BaflUtils::DiskIsReadOnly(fileserver,filename,readOnly); + test(theRes==KErrNone); + + fileserver.Close(); + } + +/* +@SYMTestCaseID SYSLIB-BAFL-CT-1284 +@SYMTestCaseDesc Tests for invalid character +@SYMTestPriority High +@SYMTestActions Test for panic when an invalid character when + supplied to BaflUtils::RootFolderPath's parameter as drive letter +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +TInt TestforInvalidCharacter(TAny* /*aData*/) +/** + This is a root thread function which runs as part of the TestforDEF040198(). + It tests a panic is produced when an invalid non alphabet character is supplied + in the aDriveLetter argument in BaflUtils::RootFolderPath(const TBuf<1> aDriveLetter) +*/ + { + TBuf<1> buf1=_L("?"); + TFileName retValue; + retValue=BaflUtils::RootFolderPath(buf1); + + // Line above panics if working OK, so should never get here. + test(0); + return 0; + } + +/** +This method is a test case to demonstrate the fix for DEF040198 by supplying an invalid +input aDriveLetter argument (e.g "?") to BaflUtils::RootFolderPath(aDriveLetter). + +@SYMTestCaseID SYSLIB-BAFL-CT-0448 +@SYMTestCaseDesc Tests for defect number DEF040198 +@SYMTestPriority High +@SYMTestActions Check by giving an invalid aDriveLetter argument +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestforDEF040198() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0448 ")); +//Check invalid aDriveLetter argument panics with panic code EBaflPanicBadOpenArg +#if defined(_DEBUG) + TRequestStatus threadStatus; + RThread thread; + _LIT(KThreadName,"ThreadTest"); + TInt rc; + TBool jit; + jit=User::JustInTime(); + User::SetJustInTime(EFalse); + + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-1284 ")); + rc=thread.Create(KThreadName,TestforInvalidCharacter,KDefaultStackSize,KMinHeapSize,KMinHeapSize*4,NULL); + test(rc==KErrNone); + thread.Logon(threadStatus); + thread.Resume(); + User::WaitForRequest(threadStatus); + test (thread.ExitType()==EExitPanic); + test (thread.ExitReason()==EBafPanicBadOpenArg); + thread.Close(); + User::SetJustInTime(jit); +#endif + } + +/* +@SYMTestCaseID SYSLIB-BAFL-CT-1285 +@SYMTestCaseDesc Tests for invalid path name +@SYMTestPriority High +@SYMTestActions Test for panic when an invalid character supplied to BaflUtils::RootFolderPath's parameter as drive letter +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +TInt TestforInvalidPathName(TAny* /*aData*/) +/** + This is a root thread function which runs as part of the TestforDEF040299(). + It tests a panic is produced when an invalid name is supplied + in the aFullName argument in BaflUtils::FolderNameFromFullName(const TDesC& aFullName) +*/ + { + TBuf<1> buf1=_L("?"); + TFileName retValue; + retValue=BaflUtils::FolderNameFromFullName(buf1); + + // Line above panics if working OK, so should never get here. + test(0); + return 0; + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0449 +@SYMTestCaseDesc Tests for defect number DEF047305 +@SYMTestPriority High +@SYMTestActions Test for correct syntax +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestForDEF047305() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0449 ")); + RFs aFs; + CleanupClosePushL(aFs); + User::LeaveIfError(aFs.Connect()); + + TFileName newFolderFullName = KCurrentPath; + + test(User::LeaveIfError(BaflUtils::ValidateFolderNameTypedByUserL(aFs, KValFolderName, KCurrentPath, newFolderFullName)==KErrNone)); + test(User::LeaveIfError(BaflUtils::ValidateFolderNameTypedByUserL(aFs, KNoFolderName, KCurrentPath, newFolderFullName)==KErrArgument)); + test(User::LeaveIfError(BaflUtils::ValidateFolderNameTypedByUserL(aFs, KInValidFolderName, KCurrentPath, newFolderFullName)==KErrBadName)); + + CleanupStack::PopAndDestroy(&aFs); + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0450 +@SYMTestCaseDesc Tests for defect number DEF040299 +@SYMTestPriority High +@SYMTestActions Test by supplying an invalid input aFullName argument to BaflUtils::FolderNameFromFullName(aFullName) +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void TestforDEF040299() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0450 ")); + TBuf<30> buf; + TFileName fileName; + + //Path name="c:" + buf=_L("c:"); + fileName=BaflUtils::FolderNameFromFullName(buf); + test(buf==fileName); + + //Path name="c:\\" + buf=_L("c:\\"); + fileName=BaflUtils::FolderNameFromFullName(buf); + test(fileName==buf); + + //Path name="c:\\file.txt" + buf=_L("c:\\file.txt"); + fileName=BaflUtils::FolderNameFromFullName(buf); + test(fileName==_L("c:\\")); + + //Path name="c:\\system\\file.txt" + buf=_L("c:\\system\\file.txt"); + fileName=BaflUtils::FolderNameFromFullName(buf); + test(fileName==_L("system")); + + /** + This method is a test case to demonstrate the fix for DEF040299 by supplying an invalid + input aFullName argument (e.g "?") to BaflUtils::FolderNameFromFullName(aFullName). + */ + //Check invalid aFullName argument panics with panic code EBaflPanicBadOpenArg +#if defined(_DEBUG) + TRequestStatus threadStatus; + RThread thread; + //Tread name is changed due to test failing on slow machine + //Using "TreadTest" here are causing KErrAlreadyExist at tread creating stage. + //This is because the previous tread maybe still being closed when this thread is created. + _LIT(KThreadName,"ThreadTest1"); + TInt rc; + TBool jit; + jit=User::JustInTime(); + User::SetJustInTime(EFalse); + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-1285 ")); +rc=thread.Create(KThreadName,TestforInvalidPathName,KDefaultStackSize,KMinHeapSize,KMinHeapSize*4,NULL); + test(rc==KErrNone); + thread.Logon(threadStatus); + thread.Resume(); + User::WaitForRequest(threadStatus); + test (thread.ExitType()==EExitPanic); + test (thread.ExitReason()==EBafPanicBadOpenArg); + thread.Close(); + User::SetJustInTime(jit); +#endif + + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-3416 +@SYMTestCaseDesc Tests for defect number DEF101927 +@SYMTestPriority High +@SYMTestActions Test the simulated Tls functionalities Dll::Tls, Dll::SetTls and Dll::FreeTls + which is needed for BAUtils.cpp to be complied as part of an .exe. + Dll::Tls - Recalls the value currently referred to by the Tls pointer + Dll::SetTls - Sets the the values referred to by the Tls pointer + Dll::FreeTls - Sets the Tls pointer to NULL +@SYMTestExpectedResults Pass if the TLanguage values is returned as expected after calls to IdealLanguage, + SetIdealLanguage and ReleaseIdealLanguage. +@SYMDEF DEF101927 +*/ +void TestForDEF101927() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-3416 ")); + TLanguage test_language(ELangAmerican); + + test(BaflUtils::IdealLanguage()==ELangNone); + + BaflUtils::SetIdealLanguage(ELangAmerican); + test(test_language == ELangAmerican); + + test_language = ELangNone; + test_language = BaflUtils::IdealLanguage(); + test(test_language == ELangAmerican); + + BaflUtils::ReleaseIdealLanguage(); + test_language = BaflUtils::IdealLanguage(); + test(test_language == ELangNone); + } + +/** +@SYMTestCaseID SYSLIB-BAFL-UT-3667 +@SYMTestCaseDesc Tests for defect number DEF109928 +@SYMTestPriority Normal +@SYMTestActions Test for the extended NextLanguage(). Check if the MakeLanguageDowngradePath() + can now return the correct default fallback for the languages which are newly + added into the NextLanguage(). +@SYMTestExpectedResults Test must not fail +@SYMDEF DEF109928 +*/ +void TestForDEF109928() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-UT-3667 ")); + TLanguage testDeviceLangs[8] = {ELangEnglish_Japan, ELangSwissFrench, ELangSwissGerman, + ELangLatinAmericanSpanish, ELangSwissItalian, ELangFinlandSwedish, + ELangMalay_Apac, ELangBrazilianPortuguese}; + TLanguagePath testOutputPath[8] = {{ELangEnglish_Japan, ELangEnglish}, {ELangSwissFrench, ELangFrench}, + {ELangSwissGerman, ELangGerman}, {ELangLatinAmericanSpanish, ELangSpanish}, + {ELangSwissItalian, ELangItalian}, {ELangFinlandSwedish, ELangSwedish}, + {ELangMalay_Apac, ELangMalay}, {ELangBrazilianPortuguese, ELangPortuguese}}; + TLocale loc; + loc.SetLanguageDowngrade(0, ELangNone); + loc.SetLanguageDowngrade(1, ELangNone); + loc.SetLanguageDowngrade(2, ELangNone); + TLanguagePath path; + TLanguage testlang; + + for(TInt i = 0; i < 8 ; i++) + { + testlang = testDeviceLangs[i]; + MakeLanguageDowngradePath(path, testlang, ELangNone, loc); + test(path[0] == testOutputPath[i][0]); + test(path[1] == testOutputPath[i][1]); + test(path[2] == ELangNone); + } + } + +/* The following 3 function is defined so that the functions IdealLanguage, +SetIdealLanguage, ReleaseIdealLanguage will compile as part as an .exe +These functions use a global TAny* to store the data that would have been +stored in the TLS under normal compilation (ie If the BaUtils was compilled +as part of a DLL). +*/ + +TAny* ptr(NULL); + +TAny* Dll::Tls() + { + return ptr; + } + +TInt Dll::SetTls(TAny* aPtr) + { + ptr = aPtr; + return KErrNone; + } + +void Dll::FreeTls() + { + ptr = NULL; + } + +void RunTestsL() + { + __UHEAP_MARK; + + test.Title(); + test.Start(_L("BaflUtils Internal Tests: ")); + + TestAddLanguage(); + TestMakeLanguageDowngradePath(); + TestNearestLanguageFinder(); + TestforDEF039977(); + TestforDEF040198(); + TestforDEF040299(); + TestForDEF047305(); + TestForDEF101927(); + TestForDEF109928(); + test.End(); + test.Close(); + + __UHEAP_MARKENDC(0); + } + +TInt E32Main() + { + TrapCleanup = CTrapCleanup::New(); + TRAPD(err, RunTestsL()); + test(err == KErrNone); + delete TrapCleanup; + return 0; + }