tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_localeService.js (10547B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 const osPrefs = Cc["@mozilla.org/intl/ospreferences;1"].getService(
      6  Ci.mozIOSPreferences
      7 );
      8 
      9 const localeService = Services.locale;
     10 
     11 /**
     12 * Make sure the locale service can be instantiated.
     13 */
     14 
     15 add_test(function test_defaultLocale() {
     16  const defaultLocale = localeService.defaultLocale;
     17  Assert.notStrictEqual(defaultLocale.length, 0, "Default locale is not empty");
     18  run_next_test();
     19 });
     20 
     21 add_test(function test_lastFallbackLocale() {
     22  const lastFallbackLocale = localeService.lastFallbackLocale;
     23  Assert.strictEqual(
     24    lastFallbackLocale,
     25    "en-US",
     26    "Last fallback locale is en-US"
     27  );
     28  run_next_test();
     29 });
     30 
     31 add_test(function test_appLocalesAsLangTags() {
     32  const appLocale = localeService.appLocaleAsLangTag;
     33  Assert.notEqual(appLocale, "", "appLocale is non-empty");
     34 
     35  const appLocales = localeService.appLocalesAsLangTags;
     36  Assert.ok(Array.isArray(appLocales), "appLocales returns an array");
     37 
     38  Assert.equal(
     39    appLocale,
     40    appLocales[0],
     41    "appLocale matches first entry in appLocales"
     42  );
     43 
     44  const enUSLocales = appLocales.filter(loc => loc === "en-US");
     45  Assert.equal(enUSLocales.length, 1, "en-US is present exactly one time");
     46 
     47  run_next_test();
     48 });
     49 
     50 const PREF_REQUESTED_LOCALES = "intl.locale.requested";
     51 const REQ_LOC_CHANGE_EVENT = "intl:requested-locales-changed";
     52 
     53 add_test(function test_requestedLocales() {
     54  const requestedLocales = localeService.requestedLocales;
     55  Assert.ok(
     56    Array.isArray(requestedLocales),
     57    "requestedLocales returns an array"
     58  );
     59 
     60  run_next_test();
     61 });
     62 
     63 /**
     64 * In this test we verify that after we set an observer on the LocaleService
     65 * event for requested locales change, it will be fired when the
     66 * pref for matchOS is set to true.
     67 *
     68 * Then, we test that when the matchOS is set to true, we will retrieve
     69 * OS locale from requestedLocales.
     70 */
     71 add_test(function test_requestedLocales_matchOS() {
     72  do_test_pending();
     73 
     74  Services.prefs.setCharPref(PREF_REQUESTED_LOCALES, "ar-IR");
     75 
     76  const observer = {
     77    observe(aSubject, aTopic) {
     78      switch (aTopic) {
     79        case REQ_LOC_CHANGE_EVENT: {
     80          const reqLocs = localeService.requestedLocales;
     81          Assert.strictEqual(reqLocs[0], osPrefs.systemLocale);
     82          Services.obs.removeObserver(observer, REQ_LOC_CHANGE_EVENT);
     83          do_test_finished();
     84        }
     85      }
     86    },
     87  };
     88 
     89  Services.obs.addObserver(observer, REQ_LOC_CHANGE_EVENT);
     90  Services.prefs.setCharPref(PREF_REQUESTED_LOCALES, "");
     91 
     92  run_next_test();
     93 });
     94 
     95 /**
     96 * In this test we verify that after we set an observer on the LocaleService
     97 * event for requested locales change, it will be fired when the
     98 * pref for browser UI locale changes.
     99 */
    100 add_test(function test_requestedLocales_onChange() {
    101  do_test_pending();
    102 
    103  Services.prefs.setCharPref(PREF_REQUESTED_LOCALES, "ar-IR");
    104 
    105  const observer = {
    106    observe(aSubject, aTopic) {
    107      switch (aTopic) {
    108        case REQ_LOC_CHANGE_EVENT: {
    109          const reqLocs = localeService.requestedLocales;
    110          Assert.strictEqual(reqLocs[0], "sr-RU");
    111          Services.obs.removeObserver(observer, REQ_LOC_CHANGE_EVENT);
    112          do_test_finished();
    113        }
    114      }
    115    },
    116  };
    117 
    118  Services.obs.addObserver(observer, REQ_LOC_CHANGE_EVENT);
    119  Services.prefs.setCharPref(PREF_REQUESTED_LOCALES, "sr-RU");
    120 
    121  run_next_test();
    122 });
    123 
    124 add_test(function test_requestedLocale() {
    125  Services.prefs.setCharPref(PREF_REQUESTED_LOCALES, "tlh");
    126 
    127  let requestedLocale = localeService.requestedLocale;
    128  Assert.strictEqual(
    129    requestedLocale,
    130    "tlh",
    131    "requestedLocale returns the right value"
    132  );
    133 
    134  Services.prefs.clearUserPref(PREF_REQUESTED_LOCALES);
    135 
    136  run_next_test();
    137 });
    138 
    139 add_test(function test_requestedLocales() {
    140  localeService.requestedLocales = ["de-AT", "de-DE", "de-CH"];
    141 
    142  let locales = localeService.requestedLocales;
    143  Assert.strictEqual(locales[0], "de-AT");
    144  Assert.strictEqual(locales[1], "de-DE");
    145  Assert.strictEqual(locales[2], "de-CH");
    146 
    147  run_next_test();
    148 });
    149 
    150 add_test(function test_isAppLocaleRTL() {
    151  Assert.strictEqual(typeof localeService.isAppLocaleRTL, "boolean");
    152 
    153  run_next_test();
    154 });
    155 
    156 add_test(function test_isAppLocaleRTL_pseudo() {
    157  let avLocales = localeService.availableLocales;
    158  let reqLocales = localeService.requestedLocales;
    159 
    160  localeService.availableLocales = ["en-US"];
    161  localeService.requestedLocales = ["en-US"];
    162  Services.prefs.setCharPref("intl.l10n.pseudo", "");
    163 
    164  Assert.strictEqual(localeService.isAppLocaleRTL, false);
    165 
    166  Services.prefs.setCharPref("intl.l10n.pseudo", "bidi");
    167  Assert.strictEqual(localeService.isAppLocaleRTL, true);
    168 
    169  Services.prefs.setCharPref("intl.l10n.pseudo", "accented");
    170  Assert.strictEqual(localeService.isAppLocaleRTL, false);
    171 
    172  // Clean up
    173  localeService.availableLocales = avLocales;
    174  localeService.requestedLocales = reqLocales;
    175  Services.prefs.clearUserPref("intl.l10n.pseudo");
    176 
    177  run_next_test();
    178 });
    179 
    180 add_test(function test_packagedLocales() {
    181  const locales = localeService.packagedLocales;
    182  Assert.notStrictEqual(locales.length, 0, "Packaged locales are empty");
    183  run_next_test();
    184 });
    185 
    186 add_test(function test_availableLocales() {
    187  const avLocales = localeService.availableLocales;
    188  localeService.availableLocales = ["und", "ar-IR"];
    189 
    190  let locales = localeService.availableLocales;
    191  Assert.equal(locales.length, 2);
    192  Assert.strictEqual(locales[0], "und");
    193  Assert.strictEqual(locales[1], "ar-IR");
    194 
    195  localeService.availableLocales = avLocales;
    196 
    197  run_next_test();
    198 });
    199 
    200 /**
    201 * This test verifies that all values coming from the pref are sanitized.
    202 */
    203 add_test(function test_requestedLocales_sanitize() {
    204  Services.prefs.setStringPref(
    205    PREF_REQUESTED_LOCALES,
    206    "de,2,#$@#,pl,ąó,!a2,DE-at,,;"
    207  );
    208 
    209  let locales = localeService.requestedLocales;
    210  Assert.equal(locales[0], "de");
    211  Assert.equal(locales[1], "pl");
    212  Assert.equal(locales[2], "de-AT");
    213  Assert.equal(locales.length, 3);
    214 
    215  Services.prefs.clearUserPref(PREF_REQUESTED_LOCALES);
    216 
    217  run_next_test();
    218 });
    219 
    220 add_test(function test_handle_ja_JP_mac() {
    221  const bkpAvLocales = localeService.availableLocales;
    222 
    223  localeService.availableLocales = ["ja-JP-mac", "en-US"];
    224 
    225  localeService.requestedLocales = ["ja-JP-mac"];
    226 
    227  let reqLocales = localeService.requestedLocales;
    228  Assert.equal(reqLocales[0], "ja-JP-macos");
    229 
    230  let avLocales = localeService.availableLocales;
    231  Assert.equal(avLocales[0], "ja-JP-macos");
    232 
    233  let appLocales = localeService.appLocalesAsBCP47;
    234  Assert.equal(appLocales[0], "ja-JP-macos");
    235 
    236  let appLocalesAsLT = localeService.appLocalesAsLangTags;
    237  Assert.equal(appLocalesAsLT[0], "ja-JP-mac");
    238 
    239  Assert.equal(localeService.appLocaleAsLangTag, "ja-JP-mac");
    240 
    241  localeService.availableLocales = bkpAvLocales;
    242 
    243  run_next_test();
    244 });
    245 
    246 add_test(function test_locale_service_glue() {
    247  // On Android, intl.accept_languages is set with a user pref value,
    248  // so we clear that in order to test the default value handling.
    249  let origAcceptLanguages = null;
    250  if (Services.prefs.prefHasUserValue("intl.accept_languages")) {
    251    origAcceptLanguages = Services.prefs.getCharPref("intl.accept_languages");
    252    Services.prefs.clearUserPref("intl.accept_languages");
    253  }
    254  const origAvLocales = localeService.availableLocales;
    255 
    256  localeService.availableLocales = ["en-US"];
    257  localeService.requestedLocales = ["en-US"];
    258  Assert.equal(localeService.acceptLanguages, "en-US, en");
    259  Assert.equal(localeService.ellipsis, "…");
    260  Assert.equal(localeService.alwaysAppendAccesskeys, false);
    261  Assert.equal(localeService.insertSeparatorBeforeAccesskeys, true);
    262 
    263  localeService.availableLocales = ["ca-valencia", "en-US"];
    264  localeService.requestedLocales = ["ca-valencia"];
    265  Assert.equal(localeService.acceptLanguages, "ca-valencia, ca, en-US, en");
    266 
    267  localeService.availableLocales = ["hi-IN", "en-US"];
    268  localeService.requestedLocales = ["hi-IN"];
    269  Assert.equal(localeService.acceptLanguages, "hi-IN, hi, en-US, en");
    270 
    271  localeService.availableLocales = ["ja-JP-mac", "en-US"];
    272  localeService.requestedLocales = ["ja-JP-mac"];
    273  Assert.equal(localeService.acceptLanguages, "ja, en-US, en");
    274  Assert.equal(localeService.ellipsis, "...");
    275  Assert.equal(localeService.alwaysAppendAccesskeys, true);
    276  Assert.equal(localeService.insertSeparatorBeforeAccesskeys, false);
    277 
    278  localeService.availableLocales = ["zh-CN", "en-US"];
    279  localeService.requestedLocales = ["zh-CN"];
    280  Assert.equal(
    281    localeService.acceptLanguages,
    282    "zh-CN, zh, zh-TW, zh-HK, en-US, en"
    283  );
    284  Assert.equal(localeService.ellipsis, "…");
    285  Assert.equal(localeService.alwaysAppendAccesskeys, false);
    286  Assert.equal(localeService.insertSeparatorBeforeAccesskeys, false);
    287 
    288  localeService.availableLocales = ["zh-TW", "en-US"];
    289  localeService.requestedLocales = ["zh-TW"];
    290  Assert.equal(localeService.acceptLanguages, "zh-TW, zh, en-US, en");
    291  Assert.equal(localeService.ellipsis, "…");
    292  Assert.equal(localeService.alwaysAppendAccesskeys, true);
    293  Assert.equal(localeService.insertSeparatorBeforeAccesskeys, true);
    294 
    295  if (origAcceptLanguages) {
    296    Services.prefs.setCharPref("intl.accept_languages", origAcceptLanguages);
    297  }
    298  localeService.availableLocales = origAvLocales;
    299 
    300  run_next_test();
    301 });
    302 
    303 add_test(function test_font_langauge_group() {
    304  const origAvLocales = localeService.availableLocales;
    305 
    306  for (const [locales, expGroup] of [
    307    [["ar", "ckb", "fa", "ks", "skr"], "ar"],
    308    [["az", "mai", "sat", "vi"], "x-unicode"],
    309    [["be", "bg", "kk", "mk", "ru", "sah", "sr", "tg", "uk"], "x-cyrillic"],
    310    [["bn"], "x-beng"],
    311    [["bo"], "x-tibt"],
    312    [["brx", "hi", "mr", "ne"], "x-devanagari"],
    313    [["el"], "el"],
    314    [["gu-IN"], "x-gujr"],
    315    [["he"], "he"],
    316    [["hy", "hye", "xcl"], "x-armn"],
    317    [["ja"], "ja"],
    318    [["kn"], "x-knda"],
    319    [["ko"], "ko"],
    320    [["lo", "th"], "th"],
    321    [["ml"], "x-mlym"],
    322    [["si"], "x-sinh"],
    323    [["son"], "x-western"],
    324    [["te"], "x-telu"],
    325    [["th"], "th"],
    326    [["zh-CN"], "zh-CN"],
    327    [["zh-TW"], "zh-TW"],
    328  ]) {
    329    for (const locale of locales) {
    330      localeService.availableLocales = [locale, "en-US"];
    331      localeService.requestedLocales = [locale];
    332      Assert.equal(localeService.fontLanguageGroup, expGroup, locale);
    333    }
    334  }
    335 
    336  localeService.availableLocales = origAvLocales;
    337 
    338  run_next_test();
    339 });
    340 
    341 registerCleanupFunction(() => {
    342  Services.prefs.clearUserPref(PREF_REQUESTED_LOCALES);
    343 });