// Copyright (c) 1997-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:
//

#include "t_langutilsimp.h"


#define test(cond)                                          \
    {                                                       \
    TBool __bb = (cond);                                    \
    TEST(__bb);                                             \
    if (!__bb)                                              \
        {                                                   \
        ERR_PRINTF1(_L("ERROR: Test Failed"));              \
        User::Leave(1);                                     \
        }                                                   \
    }



void CT_LANGUTILSIMP::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 CT_LANGUTILSIMP::TestAddLanguage()
    {
    INFO_PRINTF1(_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);
    }



/**
@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 CT_LANGUTILSIMP::TestDowngrade(SDowngradeTest& aTest)
    {
    INFO_PRINTF1(_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;
        }
    
    MakeLanguageDowngradePath(path, ELangAustralian, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangNewZealand, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangSouthAfricanEnglish, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangInternationalEnglish, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangAmerican, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangEnglish_Apac, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangEnglish_Taiwan, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangEnglish_HongKong, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangEnglish_Prc, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangEnglish_Japan, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangEnglish_Thailand, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangSwissFrench, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangBelgianFrench, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangInternationalFrench, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangCanadianFrench, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangSwissGerman, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangAustrian, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangInternationalSpanish, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangLatinAmericanSpanish, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangSwissItalian, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangFinlandSwedish, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangCyprusTurkish, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangBelgianFlemish, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangHongKongChinese, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangCyprusGreek, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangMalay_Apac, ELangNone, loc);
    MakeLanguageDowngradePath(path, ELangBrazilianPortuguese, ELangNone, loc);
    
    }


// 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<TLanguage>(ELangEnglish|EDialectOrange);
const TLanguage ELangAmericanSprint = static_cast<TLanguage>(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 CT_LANGUTILSIMP::TestMakeLanguageDowngradePath()
    {
    INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0445 "));
    for (int i = 0; i != sizeof(DowngradeData)/sizeof(DowngradeData[0]); ++i)
        TestDowngrade(DowngradeData[i]);
    }

void CT_LANGUTILSIMP::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 CT_LANGUTILSIMP::TestNearestLanguageFinder()
    {
    INFO_PRINTF1(_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<TInt>(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<TLanguage>(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<TLanguage>(2);
    finder.iPath[1] = static_cast<TLanguage>(15702);
    finder.iPath[2] = static_cast<TLanguage>(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<TLanguage>(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());

    }





void CT_LANGUTILSIMP::TestLANGUTILSIMP()
    {
    __UHEAP_MARK;

    INFO_PRINTF1(_L("LangUtils Internal Tests: "));

    TestAddLanguage();
    TestMakeLanguageDowngradePath();
    TestNearestLanguageFinder();



    __UHEAP_MARKENDC(0);
    }

CT_LANGUTILSIMP::CT_LANGUTILSIMP()
    {
    SetTestStepName(KTestStep_T_LANGUTILSIMP);
    }

TVerdict CT_LANGUTILSIMP::doTestStepL()
    {
    SetTestStepResult(EFail);

    __UHEAP_MARK;

    TRAPD(error1, TestLANGUTILSIMP());

    __UHEAP_MARKEND;

    if(error1 == KErrNone )
        {
        SetTestStepResult(EPass);
        }

    return TestStepResult();
    }