767 lines
30 KiB
C++
767 lines
30 KiB
C++
/**
|
|
* @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 "llstring.h"
|
|
#include "tests/StringVec.h"
|
|
#include "../lldir.h"
|
|
#include "../lldiriterator.h"
|
|
|
|
#include "../test/lltut.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( const std::string& dirbase )
|
|
{
|
|
int counter;
|
|
std::string uniqueDir;
|
|
bool foundUnused;
|
|
std::string delim = gDirUtilp->getDirDelimiter();
|
|
|
|
for (counter=0, foundUnused=false; !foundUnused; counter++ )
|
|
{
|
|
char counterStr[3];
|
|
snprintf(counterStr, sizeof(counterStr), "%02d", counter);
|
|
uniqueDir = dirbase + counterStr;
|
|
foundUnused = ! ( LLFile::isdir(uniqueDir) || LLFile::isfile(uniqueDir) );
|
|
}
|
|
ensure("test directory '" + uniqueDir + "' creation failed", !LLFile::mkdir(uniqueDir));
|
|
|
|
return uniqueDir + delim; // HACK - apparently, the trailing delimiter is needed...
|
|
}
|
|
|
|
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(dirTemp + "LLDirIterator");
|
|
std::string dir2 = makeTestDir(dirTemp + "LLDirIterator");
|
|
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");
|
|
}
|
|
}
|