/**
 * @file lldir_test.cpp
 * @date 2008-05
 * @brief LLDir test cases.
 *
 * $LicenseInfo:firstyear=2008&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"

#include <filesystem>
#include "llstring.h"
#include "tests/StringVec.h"
#include "../lldir.h"
#include "../lldiriterator.h"

#include "../test/lltut.h"
#include "../test/namedtempfile.h"
#include "stringize.h"
#include <boost/assign/list_of.hpp>

using boost::assign::list_of;

// We use ensure_equals(..., vec(list_of(...))) not because it's functionally
// required, but because ensure_equals() knows how to format a StringVec.
// Turns out that when ensure_equals() displays a test failure with just
// list_of("string")("another"), you see 'stringanother' vs. '("string",
// "another")'.
StringVec vec(const StringVec& v)
{
    return v;
}

// For some tests, use a dummy LLDir that uses memory data instead of touching
// the filesystem
struct LLDir_Dummy: public LLDir
{
    /*----------------------------- LLDir API ------------------------------*/
    LLDir_Dummy()
    {
        // Initialize important LLDir data members based on the filesystem
        // data below.
        mDirDelimiter = "/";
        mExecutableDir = "install";
        mExecutableFilename = "test";
        mExecutablePathAndName = add(mExecutableDir, mExecutableFilename);
        mWorkingDir = mExecutableDir;
        mAppRODataDir = "install";
        mSkinBaseDir = add(mAppRODataDir, "skins");
        mOSUserDir = "user";
        mOSUserAppDir = mOSUserDir;
        mLindenUserDir = "";

        // Make the dummy filesystem look more or less like what we expect in
        // the real one.
        static const char* preload[] =
        {
            // We group these fixture-data pathnames by basename, rather than
            // sorting by full path as you might expect, because the outcome
            // of each test strongly depends on which skins/languages provide
            // a given basename.
            "install/skins/default/colors.xml",
            "install/skins/steam/colors.xml",
            "user/skins/default/colors.xml",
            "user/skins/steam/colors.xml",

            "install/skins/default/xui/en/strings.xml",
            "install/skins/default/xui/fr/strings.xml",
            "install/skins/steam/xui/en/strings.xml",
            "install/skins/steam/xui/fr/strings.xml",
            "user/skins/default/xui/en/strings.xml",
            "user/skins/default/xui/fr/strings.xml",
            "user/skins/steam/xui/en/strings.xml",
            "user/skins/steam/xui/fr/strings.xml",

            "install/skins/default/xui/en/floater.xml",
            "install/skins/default/xui/fr/floater.xml",
            "user/skins/default/xui/fr/floater.xml",

            "install/skins/default/xui/en/newfile.xml",
            "install/skins/default/xui/fr/newfile.xml",
            "user/skins/default/xui/en/newfile.xml",

            "install/skins/default/html/en-us/welcome.html",
            "install/skins/default/html/fr/welcome.html",

            "install/skins/default/textures/only_default.jpeg",
            "install/skins/steam/textures/only_steam.jpeg",
            "user/skins/default/textures/only_user_default.jpeg",
            "user/skins/steam/textures/only_user_steam.jpeg",

            "install/skins/default/future/somefile.txt"
        };
        for (const char* path : preload)
        {
            buildFilesystem(path);
        }
    }

    virtual ~LLDir_Dummy() {}

    virtual void initAppDirs(const std::string& app_name, const std::string& app_read_only_data_dir)
    {
        // Implement this when we write a test that needs it
    }

    virtual std::string getCurPath()
    {
        // Implement this when we write a test that needs it
        return "";
    }

    virtual U32 countFilesInDir(const std::string& dirname, const std::string& mask)
    {
        // Implement this when we write a test that needs it
        return 0;
    }

    virtual bool fileExists(const std::string& pathname) const
    {
        // Record fileExists() calls so we can check whether caching is
        // working right. Certain LLDir calls should be able to make decisions
        // without calling fileExists() again, having already checked existence.
        mChecked.insert(pathname);
        // For our simple flat set of strings, see whether the identical
        // pathname exists in our set.
        return (mFilesystem.find(pathname) != mFilesystem.end());
    }

    virtual std::string getLLPluginLauncher()
    {
        // Implement this when we write a test that needs it
        return "";
    }

    virtual std::string getLLPluginFilename(std::string base_name)
    {
        // Implement this when we write a test that needs it
        return "";
    }

    /*----------------------------- Dummy data -----------------------------*/
    void clearFilesystem() { mFilesystem.clear(); }
    void buildFilesystem(const std::string& path)
    {
        // Split the pathname on slashes, ignoring leading, trailing, doubles
        StringVec components;
        LLStringUtil::getTokens(path, components, "/");
        // Ensure we have an entry representing every level of this path
        std::string partial;
        for (std::string component : components)
        {
            append(partial, component);
            mFilesystem.insert(partial);
        }
    }

    void clear_checked() { mChecked.clear(); }
    void ensure_checked(const std::string& pathname) const
    {
        tut::ensure(STRINGIZE(pathname << " was not checked but should have been"),
                    mChecked.find(pathname) != mChecked.end());
    }
    void ensure_not_checked(const std::string& pathname) const
    {
        tut::ensure(STRINGIZE(pathname << " was checked but should not have been"),
                    mChecked.find(pathname) == mChecked.end());
    }

    std::set<std::string> mFilesystem;
    mutable std::set<std::string> mChecked;
};

namespace tut
{
    struct LLDirTest
        {
        };
        typedef test_group<LLDirTest> LLDirTest_t;
        typedef LLDirTest_t::object LLDirTest_object_t;
        tut::LLDirTest_t tut_LLDirTest("LLDir");

    template<> template<>
    void LLDirTest_object_t::test<1>()
        // getDirDelimiter
    {
        ensure("getDirDelimiter", !gDirUtilp->getDirDelimiter().empty());
    }

    template<> template<>
    void LLDirTest_object_t::test<2>()
        // getBaseFileName
    {
        std::string delim = gDirUtilp->getDirDelimiter();
        std::string rawFile = "foo";
        std::string rawFileExt = "foo.bAr";
        std::string rawFileNullExt = "foo.";
        std::string rawExt = ".bAr";
        std::string rawDot = ".";
        std::string pathNoExt = "aa" + delim + "bb" + delim + "cc" + delim + "dd" + delim + "ee";
        std::string pathExt = pathNoExt + ".eXt";
        std::string dottedPathNoExt = "aa" + delim + "bb" + delim + "cc.dd" + delim + "ee";
        std::string dottedPathExt = dottedPathNoExt + ".eXt";

        // foo[.bAr]

        ensure_equals("getBaseFileName/r-no-ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(rawFile, false),
                  "foo");

        ensure_equals("getBaseFileName/r-no-ext/strip-exten",
                  gDirUtilp->getBaseFileName(rawFile, true),
                  "foo");

        ensure_equals("getBaseFileName/r-ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(rawFileExt, false),
                  "foo.bAr");

        ensure_equals("getBaseFileName/r-ext/strip-exten",
                  gDirUtilp->getBaseFileName(rawFileExt, true),
                  "foo");

        // foo.

        ensure_equals("getBaseFileName/rn-no-ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(rawFileNullExt, false),
                  "foo.");

        ensure_equals("getBaseFileName/rn-no-ext/strip-exten",
                  gDirUtilp->getBaseFileName(rawFileNullExt, true),
                  "foo");

        // .bAr
        // interesting case - with no basename, this IS the basename, not the extension.

        ensure_equals("getBaseFileName/e-ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(rawExt, false),
                  ".bAr");

        ensure_equals("getBaseFileName/e-ext/strip-exten",
                  gDirUtilp->getBaseFileName(rawExt, true),
                  ".bAr");

        // .

        ensure_equals("getBaseFileName/d/no-strip-exten",
                  gDirUtilp->getBaseFileName(rawDot, false),
                  ".");

        ensure_equals("getBaseFileName/d/strip-exten",
                  gDirUtilp->getBaseFileName(rawDot, true),
                  ".");

        // aa/bb/cc/dd/ee[.eXt]

        ensure_equals("getBaseFileName/no-ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(pathNoExt, false),
                  "ee");

        ensure_equals("getBaseFileName/no-ext/strip-exten",
                  gDirUtilp->getBaseFileName(pathNoExt, true),
                  "ee");

        ensure_equals("getBaseFileName/ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(pathExt, false),
                  "ee.eXt");

        ensure_equals("getBaseFileName/ext/strip-exten",
                  gDirUtilp->getBaseFileName(pathExt, true),
                  "ee");

        // aa/bb/cc.dd/ee[.eXt]

        ensure_equals("getBaseFileName/d-no-ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(dottedPathNoExt, false),
                  "ee");

        ensure_equals("getBaseFileName/d-no-ext/strip-exten",
                  gDirUtilp->getBaseFileName(dottedPathNoExt, true),
                  "ee");

        ensure_equals("getBaseFileName/d-ext/no-strip-exten",
                  gDirUtilp->getBaseFileName(dottedPathExt, false),
                  "ee.eXt");

        ensure_equals("getBaseFileName/d-ext/strip-exten",
                  gDirUtilp->getBaseFileName(dottedPathExt, true),
                  "ee");
    }

    template<> template<>
    void LLDirTest_object_t::test<3>()
        // getDirName
    {
        std::string delim = gDirUtilp->getDirDelimiter();
        std::string rawFile = "foo";
        std::string rawFileExt = "foo.bAr";
        std::string pathNoExt = "aa" + delim + "bb" + delim + "cc" + delim + "dd" + delim + "ee";
        std::string pathExt = pathNoExt + ".eXt";
        std::string dottedPathNoExt = "aa" + delim + "bb" + delim + "cc.dd" + delim + "ee";
        std::string dottedPathExt = dottedPathNoExt + ".eXt";

        // foo[.bAr]

        ensure_equals("getDirName/r-no-ext",
                  gDirUtilp->getDirName(rawFile),
                  "");

        ensure_equals("getDirName/r-ext",
                  gDirUtilp->getDirName(rawFileExt),
                  "");

        // aa/bb/cc/dd/ee[.eXt]

        ensure_equals("getDirName/no-ext",
                  gDirUtilp->getDirName(pathNoExt),
                  "aa" + delim + "bb" + delim + "cc" + delim + "dd");

        ensure_equals("getDirName/ext",
                  gDirUtilp->getDirName(pathExt),
                  "aa" + delim + "bb" + delim + "cc" + delim + "dd");

        // aa/bb/cc.dd/ee[.eXt]

        ensure_equals("getDirName/d-no-ext",
                  gDirUtilp->getDirName(dottedPathNoExt),
                  "aa" + delim + "bb" + delim + "cc.dd");

        ensure_equals("getDirName/d-ext",
                  gDirUtilp->getDirName(dottedPathExt),
                  "aa" + delim + "bb" + delim + "cc.dd");
    }

    template<> template<>
    void LLDirTest_object_t::test<4>()
        // getExtension
    {
        std::string delim = gDirUtilp->getDirDelimiter();
        std::string rawFile = "foo";
        std::string rawFileExt = "foo.bAr";
        std::string rawFileNullExt = "foo.";
        std::string rawExt = ".bAr";
        std::string rawDot = ".";
        std::string pathNoExt = "aa" + delim + "bb" + delim + "cc" + delim + "dd" + delim + "ee";
        std::string pathExt = pathNoExt + ".eXt";
        std::string dottedPathNoExt = "aa" + delim + "bb" + delim + "cc.dd" + delim + "ee";
        std::string dottedPathExt = dottedPathNoExt + ".eXt";

        // foo[.bAr]

        ensure_equals("getExtension/r-no-ext",
                  gDirUtilp->getExtension(rawFile),
                  "");

        ensure_equals("getExtension/r-ext",
                  gDirUtilp->getExtension(rawFileExt),
                  "bar");

        // foo.

        ensure_equals("getExtension/rn-no-ext",
                  gDirUtilp->getExtension(rawFileNullExt),
                  "");

        // .bAr
        // interesting case - with no basename, this IS the basename, not the extension.

        ensure_equals("getExtension/e-ext",
                  gDirUtilp->getExtension(rawExt),
                  "");

        // .

        ensure_equals("getExtension/d",
                  gDirUtilp->getExtension(rawDot),
                  "");

        // aa/bb/cc/dd/ee[.eXt]

        ensure_equals("getExtension/no-ext",
                  gDirUtilp->getExtension(pathNoExt),
                  "");

        ensure_equals("getExtension/ext",
                  gDirUtilp->getExtension(pathExt),
                  "ext");

        // aa/bb/cc.dd/ee[.eXt]

        ensure_equals("getExtension/d-no-ext",
                  gDirUtilp->getExtension(dottedPathNoExt),
                  "");

        ensure_equals("getExtension/d-ext",
                  gDirUtilp->getExtension(dottedPathExt),
                  "ext");
    }

   std::string makeTestFile( const std::string& dir, const std::string& file )
   {
      std::string path = dir + file;
      LLFILE* handle = LLFile::fopen( path, "w" );
      ensure("failed to open test file '"+path+"'", handle != NULL );
      // Harbison & Steele, 4th ed., p. 366: "If an error occurs, fputs
      // returns EOF; otherwise, it returns some other, nonnegative value."
      ensure("failed to write to test file '"+path+"'", EOF != fputs("test file", handle) );
      fclose(handle);
      return path;
   }

   std::string makeTestDir(  )
   {
      auto p = NamedTempFile::temp_path();
      std::filesystem::create_directories(p.native());

      auto ret { p.native() };

      // There's an implicit assumtion all over this code that the returned path ends with "/" (or "\")

      if(ret.size() >= 1 && ret[ ret.size()-1 ] != std::filesystem::path::preferred_separator )
          ret += std::filesystem::path::preferred_separator;

      return ret;
   }

   static const char* DirScanFilename[5] = { "file1.abc", "file2.abc", "file1.xyz", "file2.xyz", "file1.mno" };

   void scanTest(const std::string& directory, const std::string& pattern, bool correctResult[5])
   {

      // Scan directory and see if any file1.* files are found
      std::string scanResult;
      int   found = 0;
      bool  filesFound[5] = { false, false, false, false, false };
      //std::cerr << "searching '"+directory+"' for '"+pattern+"'\n";

      LLDirIterator iter(directory, pattern);
      while ( found <= 5 && iter.next(scanResult) )
      {
         found++;
         //std::cerr << "  found '"+scanResult+"'\n";
         int check;
         for (check=0; check < 5 && ! ( scanResult == DirScanFilename[check] ); check++)
         {
         }
         // check is now either 5 (not found) or the index of the matching name
         if (check < 5)
         {
            ensure( "found file '"+(std::string)DirScanFilename[check]+"' twice", ! filesFound[check] );
            filesFound[check] = true;
         }
         else // check is 5 - should not happen
         {
            fail( "found unknown file '"+scanResult+"'");
         }
      }
      for (int i=0; i<5; i++)
      {
         if (correctResult[i])
         {
            ensure("scan of '"+directory+"' using '"+pattern+"' did not return '"+DirScanFilename[i]+"'", filesFound[i]);
         }
         else
         {
            ensure("scan of '"+directory+"' using '"+pattern+"' incorrectly returned '"+DirScanFilename[i]+"'", !filesFound[i]);
         }
      }
   }

   template<> template<>
   void LLDirTest_object_t::test<5>()
      // LLDirIterator::next
   {
      std::string delim = gDirUtilp->getDirDelimiter();
      std::string dirTemp = LLFile::tmpdir();

      // Create the same 5 file names of the two directories

      std::string dir1 = makeTestDir();
      std::string dir2 = makeTestDir();

      std::string dir1files[5];
      std::string dir2files[5];
      for (int i=0; i<5; i++)
      {
         dir1files[i] = makeTestFile(dir1, DirScanFilename[i]);
         dir2files[i] = makeTestFile(dir2, DirScanFilename[i]);
      }

      // Scan dir1 and see if each of the 5 files is found exactly once
      bool expected1[5] = { true, true, true, true, true };
      scanTest(dir1, "*", expected1);

      // Scan dir2 and see if only the 2 *.xyz files are found
      bool  expected2[5] = { false, false, true, true, false };
      scanTest(dir1, "*.xyz", expected2);

      // Scan dir2 and see if only the 1 *.mno file is found
      bool  expected3[5] = { false, false, false, false, true };
      scanTest(dir2, "*.mno", expected3);

      // Scan dir1 and see if any *.foo files are found
      bool  expected4[5] = { false, false, false, false, false };
      scanTest(dir1, "*.foo", expected4);

      // Scan dir1 and see if any file1.* files are found
      bool  expected5[5] = { true, false, true, false, true };
      scanTest(dir1, "file1.*", expected5);

      // Scan dir1 and see if any file1.* files are found
      bool  expected6[5] = { true, true, false, false, false };
      scanTest(dir1, "file?.abc", expected6);

      // Scan dir2 and see if any file?.x?z files are found
      bool  expected7[5] = { false, false, true, true, false };
      scanTest(dir2, "file?.x?z", expected7);

      // Scan dir2 and see if any file?.??c files are found
      bool  expected8[5] = { true, true, false, false, false };
      scanTest(dir2, "file?.??c", expected8);
      scanTest(dir2, "*.??c", expected8);

      // Scan dir1 and see if any *.?n? files are found
      bool  expected9[5] = { false, false, false, false, true };
      scanTest(dir1, "*.?n?", expected9);

      // Scan dir1 and see if any *.???? files are found
      bool  expected10[5] = { false, false, false, false, false };
      scanTest(dir1, "*.????", expected10);

      // Scan dir1 and see if any ?????.* files are found
      bool  expected11[5] = { true, true, true, true, true };
      scanTest(dir1, "?????.*", expected11);

      // Scan dir1 and see if any ??l??.xyz files are found
      bool  expected12[5] = { false, false, true, true, false };
      scanTest(dir1, "??l??.xyz", expected12);

      bool expected13[5] = { true, false, true, false, false };
      scanTest(dir1, "file1.{abc,xyz}", expected13);

      bool expected14[5] = { true, true, false, false, false };
      scanTest(dir1, "file[0-9].abc", expected14);

      bool expected15[5] = { true, true, false, false, false };
      scanTest(dir1, "file[!a-z].abc", expected15);

      // clean up all test files and directories
      for (int i=0; i<5; i++)
      {
         LLFile::remove(dir1files[i]);
         LLFile::remove(dir2files[i]);
      }
      LLFile::rmdir(dir1);
      LLFile::rmdir(dir2);
   }

    template<> template<>
    void LLDirTest_object_t::test<6>()
    {
        set_test_name("findSkinnedFilenames()");
        LLDir_Dummy lldir;
        /*------------------------ "default", "en" -------------------------*/
        // Setting "default" means we shouldn't consider any "*/skins/steam"
        // directories; setting "en" means we shouldn't consider any "xui/fr"
        // directories.
        lldir.setSkinFolder("default", "en");
        ensure_equals(lldir.getSkinFolder(), "default");
        ensure_equals(lldir.getLanguage(), "en");

        // top-level directory of a skin isn't localized
        ensure_equals(lldir.findSkinnedFilenames(LLDir::SKINBASE, "colors.xml", LLDir::ALL_SKINS),
                      vec(list_of("install/skins/default/colors.xml")
                                 ("user/skins/default/colors.xml")));
        // We should not have needed to check for skins/default/en. We should
        // just "know" that SKINBASE is not localized.
        lldir.ensure_not_checked("install/skins/default/en");

        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_default.jpeg"),
                      vec(list_of("install/skins/default/textures/only_default.jpeg")));
        // Nor should we have needed to check skins/default/textures/en
        // because textures is known not to be localized.
        lldir.ensure_not_checked("install/skins/default/textures/en");

        StringVec expected(vec(list_of("install/skins/default/xui/en/strings.xml")
                               ("user/skins/default/xui/en/strings.xml")));
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", LLDir::ALL_SKINS),
                      expected);
        // The first time, we had to probe to find out whether xui was localized.
        lldir.ensure_checked("install/skins/default/xui/en");
        lldir.clear_checked();
        // Now make the same call again -- should return same result --
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", LLDir::ALL_SKINS),
                      expected);
        // but this time it should remember that xui is localized.
        lldir.ensure_not_checked("install/skins/default/xui/en");

        // localized subdir with "en-us" instead of "en"
        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
                      vec(list_of("install/skins/default/html/en-us/welcome.html")));
        lldir.ensure_checked("install/skins/default/html/en");
        lldir.ensure_checked("install/skins/default/html/en-us");
        lldir.clear_checked();
        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
                      vec(list_of("install/skins/default/html/en-us/welcome.html")));
        lldir.ensure_not_checked("install/skins/default/html/en");
        lldir.ensure_not_checked("install/skins/default/html/en-us");

        ensure_equals(lldir.findSkinnedFilenames("future", "somefile.txt"),
                      vec(list_of("install/skins/default/future/somefile.txt")));
        // Test probing for an unrecognized unlocalized future subdir.
        lldir.ensure_checked("install/skins/default/future/en");
        lldir.clear_checked();
        ensure_equals(lldir.findSkinnedFilenames("future", "somefile.txt"),
                      vec(list_of("install/skins/default/future/somefile.txt")));
        // Second time it should remember that future is unlocalized.
        lldir.ensure_not_checked("install/skins/default/future/en");

        // When language is set to "en", requesting an html file pulls up the
        // "en-us" version -- not because it magically matches those strings,
        // but because there's no "en" localization and it falls back on the
        // default "en-us"! Note that it would probably still be better to
        // make the default localization be "en" and allow "en-gb" (or
        // whatever) localizations, which would work much more the way you'd
        // expect.
        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
                      vec(list_of("install/skins/default/html/en-us/welcome.html")));

        /*------------------------ "default", "fr" -------------------------*/
        // We start being able to distinguish localized subdirs from
        // unlocalized when we ask for a non-English language.
        lldir.setSkinFolder("default", "fr");
        ensure_equals(lldir.getLanguage(), "fr");

        // pass merge=true to request this filename in all relevant skins
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", LLDir::ALL_SKINS),
                      vec(list_of
                          ("install/skins/default/xui/en/strings.xml")
                          ("install/skins/default/xui/fr/strings.xml")
                          ("user/skins/default/xui/en/strings.xml")
                          ("user/skins/default/xui/fr/strings.xml")));

        // pass (or default) merge=false to request only most specific skin
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
                      vec(list_of
                          ("user/skins/default/xui/en/strings.xml")
                          ("user/skins/default/xui/fr/strings.xml")));

        // Our dummy floater.xml has a user localization (for "fr") but no
        // English override. This is a case in which CURRENT_SKIN nonetheless
        // returns paths from two different skins.
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "floater.xml"),
                      vec(list_of
                          ("install/skins/default/xui/en/floater.xml")
                          ("user/skins/default/xui/fr/floater.xml")));

        // Our dummy newfile.xml has an English override but no user
        // localization. This is another case in which CURRENT_SKIN
        // nonetheless returns paths from two different skins.
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "newfile.xml"),
                      vec(list_of
                          ("user/skins/default/xui/en/newfile.xml")
                          ("install/skins/default/xui/fr/newfile.xml")));

        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
                      vec(list_of
                          ("install/skins/default/html/en-us/welcome.html")
                          ("install/skins/default/html/fr/welcome.html")));

        /*------------------------ "default", "zh" -------------------------*/
        lldir.setSkinFolder("default", "zh");
        // Because strings.xml has only a "fr" override but no "zh" override
        // in any skin, the most localized version we can find is "en".
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
                      vec(list_of("user/skins/default/xui/en/strings.xml")));

        /*------------------------- "steam", "en" --------------------------*/
        lldir.setSkinFolder("steam", "en");

        ensure_equals(lldir.findSkinnedFilenames(LLDir::SKINBASE, "colors.xml", LLDir::ALL_SKINS),
                      vec(list_of
                          ("install/skins/default/colors.xml")
                          ("install/skins/steam/colors.xml")
                          ("user/skins/default/colors.xml")
                          ("user/skins/steam/colors.xml")));

        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_default.jpeg"),
                      vec(list_of("install/skins/default/textures/only_default.jpeg")));

        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_steam.jpeg"),
                      vec(list_of("install/skins/steam/textures/only_steam.jpeg")));

        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_user_default.jpeg"),
                      vec(list_of("user/skins/default/textures/only_user_default.jpeg")));

        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_user_steam.jpeg"),
                      vec(list_of("user/skins/steam/textures/only_user_steam.jpeg")));

        // CURRENT_SKIN
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
                      vec(list_of("user/skins/steam/xui/en/strings.xml")));

        // pass constraint=ALL_SKINS to request this filename in all relevant skins
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", LLDir::ALL_SKINS),
                      vec(list_of
                          ("install/skins/default/xui/en/strings.xml")
                          ("install/skins/steam/xui/en/strings.xml")
                          ("user/skins/default/xui/en/strings.xml")
                          ("user/skins/steam/xui/en/strings.xml")));

        /*------------------------- "steam", "fr" --------------------------*/
        lldir.setSkinFolder("steam", "fr");

        // pass CURRENT_SKIN to request only the most specialized files
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
                      vec(list_of
                          ("user/skins/steam/xui/en/strings.xml")
                          ("user/skins/steam/xui/fr/strings.xml")));

        // pass ALL_SKINS to request this filename in all relevant skins
        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", LLDir::ALL_SKINS),
                      vec(list_of
                          ("install/skins/default/xui/en/strings.xml")
                          ("install/skins/default/xui/fr/strings.xml")
                          ("install/skins/steam/xui/en/strings.xml")
                          ("install/skins/steam/xui/fr/strings.xml")
                          ("user/skins/default/xui/en/strings.xml")
                          ("user/skins/default/xui/fr/strings.xml")
                          ("user/skins/steam/xui/en/strings.xml")
                          ("user/skins/steam/xui/fr/strings.xml")));
    }

    template<> template<>
    void LLDirTest_object_t::test<7>()
    {
        set_test_name("add()");
        LLDir_Dummy lldir;
        ensure_equals("both empty", lldir.add("", ""), "");
        ensure_equals("path empty", lldir.add("", "b"), "b");
        ensure_equals("name empty", lldir.add("a", ""), "a");
        ensure_equals("both simple", lldir.add("a", "b"), "a/b");
        ensure_equals("name leading slash", lldir.add("a", "/b"), "a/b");
        ensure_equals("path trailing slash", lldir.add("a/", "b"), "a/b");
        ensure_equals("both bring slashes", lldir.add("a/", "/b"), "a/b");
    }
}