1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include <stddef.h>
6 
7 #include <memory>
8 
9 #include "base/environment.h"
10 #include "base/files/file_util.h"
11 #include "base/i18n/case_conversion.h"
12 #include "base/i18n/rtl.h"
13 #include "base/i18n/time_formatting.h"
14 #include "base/path_service.h"
15 #include "base/stl_util.h"
16 #include "base/strings/pattern.h"
17 #include "base/strings/string_util.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "base/test/icu_test_util.h"
20 #include "base/test/scoped_path_override.h"
21 #include "build/build_config.h"
22 #include "testing/gtest/include/gtest/gtest.h"
23 #include "testing/platform_test.h"
24 #include "third_party/icu/source/common/unicode/locid.h"
25 #include "ui/base/grit/ui_base_test_resources.h"
26 #include "ui/base/l10n/l10n_util.h"
27 #include "ui/base/l10n/l10n_util_collator.h"
28 #include "ui/base/ui_base_paths.h"
29 
30 #if defined(OS_POSIX) && !defined(OS_MACOSX)
31 #include <cstdlib>
32 #endif
33 
34 using base::ASCIIToUTF16;
35 using base::UTF8ToUTF16;
36 
37 namespace {
38 
39 class StringWrapper {
40  public:
StringWrapper(const base::string16 & string)41   explicit StringWrapper(const base::string16& string) : string_(string) {}
string() const42   const base::string16& string() const { return string_; }
43 
44  private:
45   base::string16 string_;
46 
47   DISALLOW_COPY_AND_ASSIGN(StringWrapper);
48 };
49 
50 }  // namespace
51 
52 class L10nUtilTest : public PlatformTest {
53 };
54 
TEST_F(L10nUtilTest,GetString)55 TEST_F(L10nUtilTest, GetString) {
56   std::string s = l10n_util::GetStringUTF8(IDS_SIMPLE);
57   EXPECT_EQ(std::string("Hello World!"), s);
58 
59   s = l10n_util::GetStringFUTF8(IDS_PLACEHOLDERS,
60                                 UTF8ToUTF16("chrome"),
61                                 UTF8ToUTF16("10"));
62   EXPECT_EQ(std::string("Hello, chrome. Your number is 10."), s);
63 
64   base::string16 s16 = l10n_util::GetStringFUTF16Int(IDS_PLACEHOLDERS_2, 20);
65 
66   // Consecutive '$' characters override any placeholder functionality.
67   // See //base/strings/string_util.h ReplaceStringPlaceholders().
68   EXPECT_EQ(UTF8ToUTF16("You owe me $$1."), s16);
69 }
70 
71 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
72 // On Mac, we are disabling this test because GetApplicationLocale() as an
73 // API isn't something that we'll easily be able to unit test in this manner.
74 // The meaning of that API, on the Mac, is "the locale used by Cocoa's main
75 // nib file", which clearly can't be stubbed by a test app that doesn't use
76 // Cocoa.
77 
78 // On Android, we are disabling this test since GetApplicationLocale() just
79 // returns the system's locale, which, similarly, is not easily unit tested.
80 
81 #if defined(OS_POSIX) && defined(USE_GLIB) && !defined(OS_CHROMEOS)
82 const bool kPlatformHasDefaultLocale = 1;
83 const bool kUseLocaleFromEnvironment = 1;
84 const bool kSupportsLocalePreference = 0;
85 #elif defined(OS_WIN)
86 const bool kPlatformHasDefaultLocale = 1;
87 const bool kUseLocaleFromEnvironment = 0;
88 const bool kSupportsLocalePreference = 1;
89 #else
90 const bool kPlatformHasDefaultLocale = 0;
91 const bool kUseLocaleFromEnvironment = 0;
92 const bool kSupportsLocalePreference = 1;
93 #endif
94 
SetDefaultLocaleForTest(const std::string & tag,base::Environment * env)95 void SetDefaultLocaleForTest(const std::string& tag, base::Environment* env) {
96   if (kUseLocaleFromEnvironment)
97     env->SetVar("LANGUAGE", tag);
98   else
99     base::i18n::SetICUDefaultLocale(tag);
100 }
101 
TEST_F(L10nUtilTest,GetAppLocale)102 TEST_F(L10nUtilTest, GetAppLocale) {
103   std::unique_ptr<base::Environment> env;
104   // Use a temporary locale dir so we don't have to actually build the locale
105   // pak files for this test.
106   base::ScopedPathOverride locale_dir_override(ui::DIR_LOCALES);
107   base::FilePath new_locale_dir;
108   ASSERT_TRUE(base::PathService::Get(ui::DIR_LOCALES, &new_locale_dir));
109   // Make fake locale files.
110   std::string filenames[] = {
111       "am", "ca", "ca@valencia", "en-GB", "en-US", "es",    "es-419", "fil",
112       "fr", "he", "nb",          "pt-BR", "pt-PT", "zh-CN", "zh-TW",
113   };
114 
115   for (size_t i = 0; i < base::size(filenames); ++i) {
116     base::FilePath filename = new_locale_dir.AppendASCII(
117         filenames[i] + ".pak");
118     base::WriteFile(filename, "", 0);
119   }
120 
121   // Keep a copy of ICU's default locale before we overwrite it.
122   const std::string original_locale = base::i18n::GetConfiguredLocale();
123 
124   if (kPlatformHasDefaultLocale && kUseLocaleFromEnvironment) {
125     env = base::Environment::Create();
126 
127     // Test the support of LANGUAGE environment variable.
128     base::i18n::SetICUDefaultLocale("en-US");
129     env->SetVar("LANGUAGE", "xx:fr_CA");
130     EXPECT_EQ("fr", l10n_util::GetApplicationLocale(std::string()));
131     EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
132 
133     env->SetVar("LANGUAGE", "xx:yy:en_gb.utf-8@quot");
134     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale(std::string()));
135     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
136 
137     env->SetVar("LANGUAGE", "xx:zh-hk");
138     EXPECT_EQ("zh-TW", l10n_util::GetApplicationLocale(std::string()));
139     EXPECT_STREQ("zh", icu::Locale::getDefault().getLanguage());
140 
141     // We emulate gettext's behavior here, which ignores LANG/LC_MESSAGES/LC_ALL
142     // when LANGUAGE is specified. If no language specified in LANGUAGE is
143     // valid,
144     // then just fallback to the default language, which is en-US for us.
145     base::i18n::SetICUDefaultLocale("fr-FR");
146     env->SetVar("LANGUAGE", "xx:yy");
147     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale(std::string()));
148     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
149 
150     env->SetVar("LANGUAGE", "/fr:zh_CN");
151     EXPECT_EQ("zh-CN", l10n_util::GetApplicationLocale(std::string()));
152     EXPECT_STREQ("zh", icu::Locale::getDefault().getLanguage());
153 
154     // Test prioritization of the different environment variables.
155     env->SetVar("LANGUAGE", "fr");
156     env->SetVar("LC_ALL", "es");
157     env->SetVar("LC_MESSAGES", "he");
158     env->SetVar("LANG", "nb");
159     EXPECT_EQ("fr", l10n_util::GetApplicationLocale(std::string()));
160     EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
161     env->UnSetVar("LANGUAGE");
162     EXPECT_EQ("es", l10n_util::GetApplicationLocale(std::string()));
163     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
164     env->UnSetVar("LC_ALL");
165     EXPECT_EQ("he", l10n_util::GetApplicationLocale(std::string()));
166     EXPECT_STREQ("he", icu::Locale::getDefault().getLanguage());
167     env->UnSetVar("LC_MESSAGES");
168     EXPECT_EQ("nb", l10n_util::GetApplicationLocale(std::string()));
169     EXPECT_STREQ("nb", icu::Locale::getDefault().getLanguage());
170     env->UnSetVar("LANG");
171 
172     SetDefaultLocaleForTest("ca", env.get());
173     EXPECT_EQ("ca", l10n_util::GetApplicationLocale(std::string()));
174     EXPECT_STREQ("ca", icu::Locale::getDefault().getLanguage());
175 
176     SetDefaultLocaleForTest("ca-ES", env.get());
177     EXPECT_EQ("ca", l10n_util::GetApplicationLocale(std::string()));
178     EXPECT_STREQ("ca", icu::Locale::getDefault().getLanguage());
179 
180     SetDefaultLocaleForTest("ca@valencia", env.get());
181     EXPECT_EQ("ca@valencia", l10n_util::GetApplicationLocale(std::string()));
182     EXPECT_STREQ("ca", icu::Locale::getDefault().getLanguage());
183 
184     SetDefaultLocaleForTest("ca_ES@valencia", env.get());
185     EXPECT_EQ("ca@valencia", l10n_util::GetApplicationLocale(std::string()));
186     EXPECT_STREQ("ca", icu::Locale::getDefault().getLanguage());
187 
188     SetDefaultLocaleForTest("ca_ES.UTF8@valencia", env.get());
189     EXPECT_EQ("ca@valencia", l10n_util::GetApplicationLocale(std::string()));
190     EXPECT_STREQ("ca", icu::Locale::getDefault().getLanguage());
191   }
192 
193   SetDefaultLocaleForTest("en-US", env.get());
194   EXPECT_EQ("en-US", l10n_util::GetApplicationLocale(std::string()));
195   EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
196 
197   SetDefaultLocaleForTest("xx", env.get());
198   EXPECT_EQ("en-US", l10n_util::GetApplicationLocale(std::string()));
199   EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
200 
201   if (!kPlatformHasDefaultLocale) {
202     // ChromeOS & embedded use only browser prefs in GetApplicationLocale(),
203     // ignoring the environment, and default to en-US. Other platforms honor
204     // the default locale from the OS or environment.
205     SetDefaultLocaleForTest("en-GB", env.get());
206     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale(""));
207     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
208 
209     SetDefaultLocaleForTest("en-US", env.get());
210     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale("en-GB"));
211     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
212 
213     SetDefaultLocaleForTest("en-US", env.get());
214     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale("en-AU"));
215     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
216 
217     SetDefaultLocaleForTest("en-US", env.get());
218     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale("en-NZ"));
219     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
220 
221     SetDefaultLocaleForTest("en-US", env.get());
222     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale("en-CA"));
223     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
224 
225     SetDefaultLocaleForTest("en-US", env.get());
226     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale("en-ZA"));
227     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
228   } else {
229     // Most platforms have an OS-provided locale. This locale is preferred.
230     SetDefaultLocaleForTest("en-GB", env.get());
231     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale(std::string()));
232     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
233 
234     SetDefaultLocaleForTest("fr-CA", env.get());
235     EXPECT_EQ("fr", l10n_util::GetApplicationLocale(std::string()));
236     EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
237 
238     SetDefaultLocaleForTest("es-MX", env.get());
239     EXPECT_EQ("es-419", l10n_util::GetApplicationLocale(std::string()));
240     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
241 
242     SetDefaultLocaleForTest("es-AR", env.get());
243     EXPECT_EQ("es-419", l10n_util::GetApplicationLocale(std::string()));
244     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
245 
246     SetDefaultLocaleForTest("es-ES", env.get());
247     EXPECT_EQ("es", l10n_util::GetApplicationLocale(std::string()));
248     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
249 
250     SetDefaultLocaleForTest("es", env.get());
251     EXPECT_EQ("es", l10n_util::GetApplicationLocale(std::string()));
252     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
253 
254     SetDefaultLocaleForTest("pt-PT", env.get());
255     EXPECT_EQ("pt-PT", l10n_util::GetApplicationLocale(std::string()));
256     EXPECT_STREQ("pt", icu::Locale::getDefault().getLanguage());
257 
258     SetDefaultLocaleForTest("pt-BR", env.get());
259     EXPECT_EQ("pt-BR", l10n_util::GetApplicationLocale(std::string()));
260     EXPECT_STREQ("pt", icu::Locale::getDefault().getLanguage());
261 
262     SetDefaultLocaleForTest("pt-AO", env.get());
263     EXPECT_EQ("pt-PT", l10n_util::GetApplicationLocale(std::string()));
264     EXPECT_STREQ("pt", icu::Locale::getDefault().getLanguage());
265 
266     SetDefaultLocaleForTest("pt", env.get());
267     EXPECT_EQ("pt-BR", l10n_util::GetApplicationLocale(std::string()));
268     EXPECT_STREQ("pt", icu::Locale::getDefault().getLanguage());
269 
270     SetDefaultLocaleForTest("zh-HK", env.get());
271     EXPECT_EQ("zh-TW", l10n_util::GetApplicationLocale(std::string()));
272     EXPECT_STREQ("zh", icu::Locale::getDefault().getLanguage());
273 
274     SetDefaultLocaleForTest("zh-MO", env.get());
275     EXPECT_EQ("zh-TW", l10n_util::GetApplicationLocale(std::string()));
276     EXPECT_STREQ("zh", icu::Locale::getDefault().getLanguage());
277 
278     SetDefaultLocaleForTest("zh-SG", env.get());
279     EXPECT_EQ("zh-CN", l10n_util::GetApplicationLocale(std::string()));
280     EXPECT_STREQ("zh", icu::Locale::getDefault().getLanguage());
281 
282     SetDefaultLocaleForTest("zh", env.get());
283     EXPECT_EQ("zh-CN", l10n_util::GetApplicationLocale(std::string()));
284     EXPECT_STREQ("zh", icu::Locale::getDefault().getLanguage());
285 
286     SetDefaultLocaleForTest("en-CA", env.get());
287     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale(std::string()));
288     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
289 
290     SetDefaultLocaleForTest("en-AU", env.get());
291     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale(std::string()));
292     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
293 
294     SetDefaultLocaleForTest("en-NZ", env.get());
295     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale(std::string()));
296     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
297 
298     SetDefaultLocaleForTest("en-ZA", env.get());
299     EXPECT_EQ("en-GB", l10n_util::GetApplicationLocale(std::string()));
300     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
301   }
302 
303   SetDefaultLocaleForTest("en-US", env.get());
304 
305   if (kSupportsLocalePreference) {
306     // On windows, the user can override the locale in preferences.
307     base::i18n::SetICUDefaultLocale("en-US");
308     EXPECT_EQ("fr", l10n_util::GetApplicationLocale("fr"));
309     EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
310     EXPECT_EQ("fr", l10n_util::GetApplicationLocale("fr-CA"));
311     EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
312 
313     base::i18n::SetICUDefaultLocale("en-US");
314     // Aliases iw, no, tl to he, nb, fil.
315     EXPECT_EQ("he", l10n_util::GetApplicationLocale("iw"));
316     EXPECT_STREQ("he", icu::Locale::getDefault().getLanguage());
317     EXPECT_EQ("nb", l10n_util::GetApplicationLocale("no"));
318     EXPECT_STREQ("nb", icu::Locale::getDefault().getLanguage());
319     EXPECT_EQ("fil", l10n_util::GetApplicationLocale("tl"));
320     EXPECT_STREQ("fil", icu::Locale::getDefault().getLanguage());
321     // es-419 and es-XX (where XX is not Spain) should be
322     // mapped to es-419 (Latin American Spanish).
323     EXPECT_EQ("es-419", l10n_util::GetApplicationLocale("es-419"));
324     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
325     EXPECT_EQ("es", l10n_util::GetApplicationLocale("es-ES"));
326     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
327     EXPECT_EQ("es-419", l10n_util::GetApplicationLocale("es-AR"));
328     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
329 
330     base::i18n::SetICUDefaultLocale("es-AR");
331     EXPECT_EQ("es", l10n_util::GetApplicationLocale("es"));
332     EXPECT_STREQ("es", icu::Locale::getDefault().getLanguage());
333 
334     base::i18n::SetICUDefaultLocale("zh-HK");
335     EXPECT_EQ("zh-CN", l10n_util::GetApplicationLocale("zh-CN"));
336     EXPECT_STREQ("zh", icu::Locale::getDefault().getLanguage());
337 
338     base::i18n::SetICUDefaultLocale("he");
339     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale("en"));
340     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
341 
342     base::i18n::SetICUDefaultLocale("he");
343     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale("en", false));
344     EXPECT_STREQ("he", icu::Locale::getDefault().getLanguage());
345 
346     base::i18n::SetICUDefaultLocale("de");
347     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale("xx", false));
348     EXPECT_STREQ("de", icu::Locale::getDefault().getLanguage());
349 
350     base::i18n::SetICUDefaultLocale("de");
351     EXPECT_EQ("fr", l10n_util::GetApplicationLocale("fr", false));
352     EXPECT_STREQ("de", icu::Locale::getDefault().getLanguage());
353 
354     base::i18n::SetICUDefaultLocale("de");
355     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale("en", false));
356     EXPECT_STREQ("de", icu::Locale::getDefault().getLanguage());
357 
358     base::i18n::SetICUDefaultLocale("de");
359     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale("en-US", true));
360     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
361   } else {
362     base::i18n::SetICUDefaultLocale("de");
363     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale(std::string(), false));
364     EXPECT_STREQ("de", icu::Locale::getDefault().getLanguage());
365 
366     base::i18n::SetICUDefaultLocale("de");
367     EXPECT_EQ("en-US", l10n_util::GetApplicationLocale(std::string(), true));
368     EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
369   }
370 
371 #if defined(OS_WIN)
372   base::i18n::SetICUDefaultLocale("am");
373   EXPECT_EQ("am", l10n_util::GetApplicationLocale(""));
374   EXPECT_STREQ("am", icu::Locale::getDefault().getLanguage());
375   base::i18n::SetICUDefaultLocale("en-GB");
376   EXPECT_EQ("am", l10n_util::GetApplicationLocale("am"));
377   EXPECT_STREQ("am", icu::Locale::getDefault().getLanguage());
378 #endif  // defined(OS_WIN)
379 
380   // Clean up.
381   base::i18n::SetICUDefaultLocale(original_locale);
382 }
383 #endif  // !defined(OS_MACOSX)
384 
TEST_F(L10nUtilTest,SortStringsUsingFunction)385 TEST_F(L10nUtilTest, SortStringsUsingFunction) {
386   std::vector<std::unique_ptr<StringWrapper>> strings;
387   strings.push_back(std::make_unique<StringWrapper>(UTF8ToUTF16("C")));
388   strings.push_back(std::make_unique<StringWrapper>(UTF8ToUTF16("d")));
389   strings.push_back(std::make_unique<StringWrapper>(UTF8ToUTF16("b")));
390   strings.push_back(std::make_unique<StringWrapper>(UTF8ToUTF16("a")));
391   l10n_util::SortStringsUsingMethod("en-US",
392                                     &strings,
393                                     &StringWrapper::string);
394   ASSERT_TRUE(UTF8ToUTF16("a") == strings[0]->string());
395   ASSERT_TRUE(UTF8ToUTF16("b") == strings[1]->string());
396   ASSERT_TRUE(UTF8ToUTF16("C") == strings[2]->string());
397   ASSERT_TRUE(UTF8ToUTF16("d") == strings[3]->string());
398 }
399 
400 /**
401  * Helper method for validating strings that require direcitonal markup.
402  * Checks that parentheses are enclosed in appropriate direcitonal markers.
403  */
CheckUiDisplayNameForLocale(const std::string & locale,const std::string & display_locale,bool is_rtl)404 void CheckUiDisplayNameForLocale(const std::string& locale,
405                                  const std::string& display_locale,
406                                  bool is_rtl) {
407   EXPECT_EQ(true, base::i18n::IsRTL());
408   base::string16 result = l10n_util::GetDisplayNameForLocale(locale,
409                                                        display_locale,
410                                                        /* is_for_ui */ true);
411 
412   bool rtl_direction = true;
413   for (size_t i = 0; i < result.length() - 1; i++) {
414     base::char16 ch = result.at(i);
415     switch (ch) {
416     case base::i18n::kLeftToRightMark:
417     case base::i18n::kLeftToRightEmbeddingMark:
418       rtl_direction = false;
419       break;
420     case base::i18n::kRightToLeftMark:
421     case base::i18n::kRightToLeftEmbeddingMark:
422       rtl_direction = true;
423       break;
424     case '(':
425     case ')':
426       EXPECT_EQ(is_rtl, rtl_direction);
427     }
428   }
429 }
430 
TEST_F(L10nUtilTest,GetDisplayNameForLocale)431 TEST_F(L10nUtilTest, GetDisplayNameForLocale) {
432   // TODO(jungshik): Make this test more extensive.
433   // Test zh-CN and zh-TW are treated as zh-Hans and zh-Hant.
434   // Displays as "Chinese, Simplified" on iOS 13+ and as "Chinese (Simplified)"
435   // on other platforms.
436   base::string16 result =
437       l10n_util::GetDisplayNameForLocale("zh-CN", "en", false);
438   EXPECT_TRUE(
439       base::MatchPattern(base::UTF16ToUTF8(result), "Chinese*Simplified*"));
440 
441   // Displays as "Chinese, Traditional" on iOS 13+ and as
442   // "Chinese (Traditional)" on other platforms.
443   result = l10n_util::GetDisplayNameForLocale("zh-TW", "en", false);
444   EXPECT_TRUE(
445       base::MatchPattern(base::UTF16ToUTF8(result), "Chinese*Traditional*"));
446 
447   // tl and fil are not identical to be strict, but we treat them as
448   // synonyms.
449   result = l10n_util::GetDisplayNameForLocale("tl", "en", false);
450   EXPECT_EQ(l10n_util::GetDisplayNameForLocale("fil", "en", false), result);
451 
452   result = l10n_util::GetDisplayNameForLocale("pt-BR", "en", false);
453   EXPECT_EQ(ASCIIToUTF16("Portuguese (Brazil)"), result);
454 
455   result = l10n_util::GetDisplayNameForLocale("es-419", "en", false);
456   EXPECT_EQ(ASCIIToUTF16("Spanish (Latin America)"), result);
457 
458   result = l10n_util::GetDisplayNameForLocale("mo", "en", false);
459   EXPECT_EQ(l10n_util::GetDisplayNameForLocale("ro-MD", "en", false), result);
460 
461   result = l10n_util::GetDisplayNameForLocale("-BR", "en", false);
462   EXPECT_EQ(ASCIIToUTF16("Brazil"), result);
463 
464   result = l10n_util::GetDisplayNameForLocale("xyz-xyz", "en", false);
465   EXPECT_EQ(ASCIIToUTF16("xyz (XYZ)"), result);
466 
467   // Make sure that en-GB locale has the corect display names.
468   result = l10n_util::GetDisplayNameForLocale("en", "en-GB", false);
469   EXPECT_EQ(ASCIIToUTF16("English"), result);
470   result = l10n_util::GetDisplayNameForLocale("es-419", "en-GB", false);
471   EXPECT_EQ(ASCIIToUTF16("Spanish (Latin America)"), result);
472 
473   // Check for directional markers when using RTL languages to ensure that
474   // direction neutral characters such as parentheses are properly formatted.
475 
476   // Keep a copy of ICU's default locale before we overwrite it.
477   const std::string original_locale = base::i18n::GetConfiguredLocale();
478 
479   base::i18n::SetICUDefaultLocale("he");
480   CheckUiDisplayNameForLocale("en-US", "en", false);
481   CheckUiDisplayNameForLocale("en-US", "he", true);
482 
483   // Clean up.
484   base::i18n::SetICUDefaultLocale(original_locale);
485 
486   // ToUpper and ToLower should work with embedded NULLs.
487   const size_t length_with_null = 4;
488   base::char16 buf_with_null[length_with_null] = { 0, 'a', 0, 'b' };
489   base::string16 string16_with_null(buf_with_null, length_with_null);
490 
491   base::string16 upper_with_null = base::i18n::ToUpper(string16_with_null);
492   ASSERT_EQ(length_with_null, upper_with_null.size());
493   EXPECT_TRUE(upper_with_null[0] == 0 && upper_with_null[1] == 'A' &&
494               upper_with_null[2] == 0 && upper_with_null[3] == 'B');
495 
496   base::string16 lower_with_null = base::i18n::ToLower(upper_with_null);
497   ASSERT_EQ(length_with_null, upper_with_null.size());
498   EXPECT_TRUE(lower_with_null[0] == 0 && lower_with_null[1] == 'a' &&
499               lower_with_null[2] == 0 && lower_with_null[3] == 'b');
500 }
501 
TEST_F(L10nUtilTest,GetDisplayNameForCountry)502 TEST_F(L10nUtilTest, GetDisplayNameForCountry) {
503   base::string16 result = l10n_util::GetDisplayNameForCountry("BR", "en");
504   EXPECT_EQ(ASCIIToUTF16("Brazil"), result);
505 
506   result = l10n_util::GetDisplayNameForCountry("419", "en");
507   EXPECT_EQ(ASCIIToUTF16("Latin America"), result);
508 
509   result = l10n_util::GetDisplayNameForCountry("xyz", "en");
510   EXPECT_EQ(ASCIIToUTF16("XYZ"), result);
511 }
512 
TEST_F(L10nUtilTest,GetParentLocales)513 TEST_F(L10nUtilTest, GetParentLocales) {
514   std::vector<std::string> locales;
515   const std::string top_locale("sr_Cyrl_RS");
516   l10n_util::GetParentLocales(top_locale, &locales);
517 
518   ASSERT_EQ(3U, locales.size());
519   EXPECT_EQ("sr_Cyrl_RS", locales[0]);
520   EXPECT_EQ("sr_Cyrl", locales[1]);
521   EXPECT_EQ("sr", locales[2]);
522 }
523 
TEST_F(L10nUtilTest,IsValidLocaleSyntax)524 TEST_F(L10nUtilTest, IsValidLocaleSyntax) {
525   // Test valid locales.
526   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("en"));
527   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("fr"));
528   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("de"));
529   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("pt"));
530   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("zh"));
531   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("fil"));
532   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("haw"));
533   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("en-US"));
534   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("en_US"));
535   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("en_GB"));
536   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("pt-BR"));
537   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("zh_CN"));
538   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("zh_Hans"));
539   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("zh_Hans_CN"));
540   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("zh_Hant"));
541   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("zh_Hant_TW"));
542   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("fr_CA"));
543   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("i-klingon"));
544   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("es-419"));
545   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("en_IE_PREEURO"));
546   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("en_IE_u_cu_IEP"));
547   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("en_IE@currency=IEP"));
548   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("fr@x=y"));
549   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax("zn_CN@foo=bar"));
550   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax(
551       "fr@collation=phonebook;calendar=islamic-civil"));
552   EXPECT_TRUE(l10n_util::IsValidLocaleSyntax(
553       "sr_Latn_RS_REVISED@currency=USD"));
554 
555   // Test invalid locales.
556   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax(std::string()));
557   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("x"));
558   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("12"));
559   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("456"));
560   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("a1"));
561   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("enUS"));
562   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("zhcn"));
563   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("en.US"));
564   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("en#US"));
565   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("-en-US"));
566   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("en-US-"));
567   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("123-en-US"));
568   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("Latin"));
569   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("German"));
570   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("pt--BR"));
571   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("sl-macedonia"));
572   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("@"));
573   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("en-US@"));
574   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("en-US@x"));
575   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("en-US@x="));
576   EXPECT_FALSE(l10n_util::IsValidLocaleSyntax("en-US@=y"));
577 }
578 
TEST_F(L10nUtilTest,TimeDurationFormatAllLocales)579 TEST_F(L10nUtilTest, TimeDurationFormatAllLocales) {
580   base::test::ScopedRestoreICUDefaultLocale restore_locale;
581 
582   // Verify that base::TimeDurationFormat() works for all available locales:
583   // http://crbug.com/707515
584   base::TimeDelta kDelta = base::TimeDelta::FromMinutes(15 * 60 + 42);
585   for (const std::string& locale : l10n_util::GetAvailableLocales()) {
586     base::i18n::SetICUDefaultLocale(locale);
587     base::string16 str;
588     const bool result =
589         base::TimeDurationFormat(kDelta, base::DURATION_WIDTH_NUMERIC, &str);
590     EXPECT_TRUE(result) << "Failed to format duration for " << locale;
591     if (result)
592       EXPECT_FALSE(str.empty()) << "Got empty string for " << locale;
593   }
594 }
595