The Tor Browser / file revision

 // Copyright 2011-2012 Norbert Lindenberg. All rights reserved.

 // Copyright 2012-2013 Mozilla Corporation. All rights reserved.

 // This code is governed by the BSD license found in the LICENSE file.

 /**

  * This file contains shared functions for the tests in the conformance test

  * suite for the ECMAScript Internationalization API.

  * @author Norbert Lindenberg

  */

 /**

  * @description Calls the provided function for every service constructor in

  * the Intl object, until f returns a falsy value. It returns the result of the

  * last call to f, mapped to a boolean.

  * @param {Function} f the function to call for each service constructor in

  *     the Intl object.

  *     @param {Function} Constructor the constructor object to test with.

  * @result {Boolean} whether the test succeeded.

  */

 function testWithIntlConstructors(f) {

     var constructors = ["Collator", "NumberFormat", "DateTimeFormat"];

     return constructors.every(function (constructor) {

         var Constructor = Intl[constructor];

         var result;

         try {

             result = f(Constructor);

         } catch (e) {

             e.message += " (Testing with " + constructor + ".)";

             throw e;

         }

         return result;

     });

 }

 /**

  * Returns the name of the given constructor object, which must be one of

  * Intl.Collator, Intl.NumberFormat, or Intl.DateTimeFormat.

  * @param {object} Constructor a constructor

  * @return {string} the name of the constructor

  */

 function getConstructorName(Constructor) {

     switch (Constructor) {

         case Intl.Collator:

             return "Collator";

         case Intl.NumberFormat:

             return "NumberFormat";

         case Intl.DateTimeFormat:

             return "DateTimeFormat";

         default:

             $ERROR("test internal error: unknown Constructor");

     }

 }

 /**

  * Taints a named data property of the given object by installing

  * a setter that throws an exception.

  * @param {object} obj the object whose data property to taint

  * @param {string} property the property to taint

  */

 function taintDataProperty(obj, property) {

     Object.defineProperty(obj, property, {

         set: function(value) {

             $ERROR("Client code can adversely affect behavior: setter for " + property + ".");

         },

         enumerable: false,

         configurable: true

     });

 }

 /**

  * Taints a named method of the given object by replacing it with a function

  * that throws an exception.

  * @param {object} obj the object whose method to taint

  * @param {string} property the name of the method to taint

  */

 function taintMethod(obj, property) {

     Object.defineProperty(obj, property, {

         value: function() {

             $ERROR("Client code can adversely affect behavior: method " + property + ".");

         },

         writable: true,

         enumerable: false,

         configurable: true

     });

 }

 /**

  * Taints the given properties (and similarly named properties) by installing

  * setters on Object.prototype that throw exceptions.

  * @param {Array} properties an array of property names to taint

  */

 function taintProperties(properties) {

     properties.forEach(function (property) {

         var adaptedProperties = [property, "__" + property, "_" + property, property + "_", property + "__"];

         adaptedProperties.forEach(function (property) {

             taintDataProperty(Object.prototype, property);

         });

     });

 }

 /**

  * Taints the Array object by creating a setter for the property "0" and

  * replacing some key methods with functions that throw exceptions.

  */

 function taintArray() {

     taintDataProperty(Array.prototype, "0");

     taintMethod(Array.prototype, "indexOf");

     taintMethod(Array.prototype, "join");

     taintMethod(Array.prototype, "push");

     taintMethod(Array.prototype, "slice");

     taintMethod(Array.prototype, "sort");

 }

 // auxiliary data for getLocaleSupportInfo

 var languages = ["zh", "es", "en", "hi", "ur", "ar", "ja", "pa"];

 var scripts = ["Latn", "Hans", "Deva", "Arab", "Jpan", "Hant"];

 var countries = ["CN", "IN", "US", "PK", "JP", "TW", "HK", "SG"];

 var localeSupportInfo = {};

 /**

  * Gets locale support info for the given constructor object, which must be one

  * of Intl.Collator, Intl.NumberFormat, Intl.DateTimeFormat.

  * @param {object} Constructor the constructor for which to get locale support info

  * @return {object} locale support info with the following properties:

  *     supported: array of fully supported language tags

  *     byFallback: array of language tags that are supported through fallbacks

  *     unsupported: array of unsupported language tags

  */

 function getLocaleSupportInfo(Constructor) {

     var constructorName = getConstructorName(Constructor);

     if (localeSupportInfo[constructorName] !== undefined) {

         return localeSupportInfo[constructorName];

     }

     var allTags = [];

     var i, j, k;

     var language, script, country;

     for (i = 0; i < languages.length; i++) {

         language = languages[i];

         allTags.push(language);

         for (j = 0; j < scripts.length; j++) {

             script = scripts[j];

             allTags.push(language + "-" + script);

             for (k = 0; k < countries.length; k++) {

                 country = countries[k];

                 allTags.push(language + "-" + script + "-" + country);

             }

         }

         for (k = 0; k < countries.length; k++) {

             country = countries[k];

             allTags.push(language + "-" + country);

         }

     }

     var supported = [];

     var byFallback = [];

     var unsupported = [];

     for (i = 0; i < allTags.length; i++) {

         var request = allTags[i];

         var result = new Constructor([request], {localeMatcher: "lookup"}).resolvedOptions().locale;

          if (request === result) {

             supported.push(request);

         } else if (request.indexOf(result) === 0) {

             byFallback.push(request);

         } else {

             unsupported.push(request);

         }

     }

     localeSupportInfo[constructorName] = {

         supported: supported,

         byFallback: byFallback,

         unsupported: unsupported

     };

     return localeSupportInfo[constructorName];

 }

 /**

  * @description Tests whether locale is a String value representing a

  * structurally valid and canonicalized BCP 47 language tag, as defined in

  * sections 6.2.2 and 6.2.3 of the ECMAScript Internationalization API

  * Specification.

  * @param {String} locale the string to be tested.

  * @result {Boolean} whether the test succeeded.

  */

 function isCanonicalizedStructurallyValidLanguageTag(locale) {

     /**

      * Regular expression defining BCP 47 language tags.

      *

      * Spec: RFC 5646 section 2.1.

      */

     var alpha = "[a-zA-Z]",

         digit = "[0-9]",

         alphanum = "(" + alpha + "|" + digit + ")",

         regular = "(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)",

         irregular = "(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)",

         grandfathered = "(" + irregular + "|" + regular + ")",

         privateuse = "(x(-[a-z0-9]{1,8})+)",

         singleton = "(" + digit + "|[A-WY-Za-wy-z])",

         extension = "(" + singleton + "(-" + alphanum + "{2,8})+)",

         variant = "(" + alphanum + "{5,8}|(" + digit + alphanum + "{3}))",

         region = "(" + alpha + "{2}|" + digit + "{3})",

         script = "(" + alpha + "{4})",

         extlang = "(" + alpha + "{3}(-" + alpha + "{3}){0,2})",

         language = "(" + alpha + "{2,3}(-" + extlang + ")?|" + alpha + "{4}|" + alpha + "{5,8})",

         langtag = language + "(-" + script + ")?(-" + region + ")?(-" + variant + ")*(-" + extension + ")*(-" + privateuse + ")?",

         languageTag = "^(" + langtag + "|" + privateuse + "|" + grandfathered + ")$",

         languageTagRE = new RegExp(languageTag, "i");

     var duplicateSingleton = "-" + singleton + "-(.*-)?\\1(?!" + alphanum + ")",

         duplicateSingletonRE = new RegExp(duplicateSingleton, "i"),

         duplicateVariant = "(" + alphanum + "{2,8}-)+" + variant + "-(" + alphanum + "{2,8}-)*\\3(?!" + alphanum + ")",

         duplicateVariantRE = new RegExp(duplicateVariant, "i");

     /**

      * Verifies that the given string is a well-formed BCP 47 language tag

      * with no duplicate variant or singleton subtags.

      *

      * Spec: ECMAScript Internationalization API Specification, draft, 6.2.2.

      */

     function isStructurallyValidLanguageTag(locale) {

         if (!languageTagRE.test(locale)) {

             return false;

         }

         locale = locale.split(/-x-/)[0];

         return !duplicateSingletonRE.test(locale) && !duplicateVariantRE.test(locale);

     }

     /**

      * Mappings from complete tags to preferred values.

      *

      * Spec: IANA Language Subtag Registry.

      */

     var __tagMappings = {

         // property names must be in lower case; values in canonical form

         // grandfathered tags from IANA language subtag registry, file date 2011-08-25

         "art-lojban": "jbo",

         "cel-gaulish": "cel-gaulish",

         "en-gb-oed": "en-GB-oed",

         "i-ami": "ami",

         "i-bnn": "bnn",

         "i-default": "i-default",

         "i-enochian": "i-enochian",

         "i-hak": "hak",

         "i-klingon": "tlh",

         "i-lux": "lb",

         "i-mingo": "i-mingo",

         "i-navajo": "nv",

         "i-pwn": "pwn",

         "i-tao": "tao",

         "i-tay": "tay",

         "i-tsu": "tsu",

         "no-bok": "nb",

         "no-nyn": "nn",

         "sgn-be-fr": "sfb",

         "sgn-be-nl": "vgt",

         "sgn-ch-de": "sgg",

         "zh-guoyu": "cmn",

         "zh-hakka": "hak",

         "zh-min": "zh-min",

         "zh-min-nan": "nan",

         "zh-xiang": "hsn",

         // deprecated redundant tags from IANA language subtag registry, file date 2011-08-25

         "sgn-br": "bzs",

         "sgn-co": "csn",

         "sgn-de": "gsg",

         "sgn-dk": "dsl",

         "sgn-es": "ssp",

         "sgn-fr": "fsl",

         "sgn-gb": "bfi",

         "sgn-gr": "gss",

         "sgn-ie": "isg",

         "sgn-it": "ise",

         "sgn-jp": "jsl",

         "sgn-mx": "mfs",

         "sgn-ni": "ncs",

         "sgn-nl": "dse",

         "sgn-no": "nsl",

         "sgn-pt": "psr",

         "sgn-se": "swl",

         "sgn-us": "ase",

         "sgn-za": "sfs",

         "zh-cmn": "cmn",

         "zh-cmn-hans": "cmn-Hans",

         "zh-cmn-hant": "cmn-Hant",

         "zh-gan": "gan",

         "zh-wuu": "wuu",

         "zh-yue": "yue",

         // deprecated variant with prefix from IANA language subtag registry, file date 2011-08-25

         "ja-latn-hepburn-heploc": "ja-Latn-alalc97"

     };

     /**

      * Mappings from non-extlang subtags to preferred values.

      *

      * Spec: IANA Language Subtag Registry.

      */

     var __subtagMappings = {

         // property names and values must be in canonical case

         // language subtags with Preferred-Value mappings from IANA language subtag registry, file date 2011-08-25

         "in": "id",

         "iw": "he",

         "ji": "yi",

         "jw": "jv",

         "mo": "ro",

         "ayx": "nun",

         "cjr": "mom",

         "cmk": "xch",

         "drh": "khk",

         "drw": "prs",

         "gav": "dev",

         "mst": "mry",

         "myt": "mry",

         "tie": "ras",

         "tkk": "twm",

         "tnf": "prs",

         // region subtags with Preferred-Value mappings from IANA language subtag registry, file date 2011-08-25

         "BU": "MM",

         "DD": "DE",

         "FX": "FR",

         "TP": "TL",

         "YD": "YE",

         "ZR": "CD"

     };

     /**

      * Mappings from extlang subtags to preferred values.

      *

      * Spec: IANA Language Subtag Registry.

      */

     var __extlangMappings = {

         // extlang subtags with Preferred-Value mappings from IANA language subtag registry, file date 2011-08-25

         // values are arrays with [0] the replacement value, [1] (if present) the prefix to be removed

         "aao": ["aao", "ar"],

         "abh": ["abh", "ar"],

         "abv": ["abv", "ar"],

         "acm": ["acm", "ar"],

         "acq": ["acq", "ar"],

         "acw": ["acw", "ar"],

         "acx": ["acx", "ar"],

         "acy": ["acy", "ar"],

         "adf": ["adf", "ar"],

         "ads": ["ads", "sgn"],

         "aeb": ["aeb", "ar"],

         "aec": ["aec", "ar"],

         "aed": ["aed", "sgn"],

         "aen": ["aen", "sgn"],

         "afb": ["afb", "ar"],

         "afg": ["afg", "sgn"],

         "ajp": ["ajp", "ar"],

         "apc": ["apc", "ar"],

         "apd": ["apd", "ar"],

         "arb": ["arb", "ar"],

         "arq": ["arq", "ar"],

         "ars": ["ars", "ar"],

         "ary": ["ary", "ar"],

         "arz": ["arz", "ar"],

         "ase": ["ase", "sgn"],

         "asf": ["asf", "sgn"],

         "asp": ["asp", "sgn"],

         "asq": ["asq", "sgn"],

         "asw": ["asw", "sgn"],

         "auz": ["auz", "ar"],

         "avl": ["avl", "ar"],

         "ayh": ["ayh", "ar"],

         "ayl": ["ayl", "ar"],

         "ayn": ["ayn", "ar"],

         "ayp": ["ayp", "ar"],

         "bbz": ["bbz", "ar"],

         "bfi": ["bfi", "sgn"],

         "bfk": ["bfk", "sgn"],

         "bjn": ["bjn", "ms"],

         "bog": ["bog", "sgn"],

         "bqn": ["bqn", "sgn"],

         "bqy": ["bqy", "sgn"],

         "btj": ["btj", "ms"],

         "bve": ["bve", "ms"],

         "bvl": ["bvl", "sgn"],

         "bvu": ["bvu", "ms"],

         "bzs": ["bzs", "sgn"],

         "cdo": ["cdo", "zh"],

         "cds": ["cds", "sgn"],

         "cjy": ["cjy", "zh"],

         "cmn": ["cmn", "zh"],

         "coa": ["coa", "ms"],

         "cpx": ["cpx", "zh"],

         "csc": ["csc", "sgn"],

         "csd": ["csd", "sgn"],

         "cse": ["cse", "sgn"],

         "csf": ["csf", "sgn"],

         "csg": ["csg", "sgn"],

         "csl": ["csl", "sgn"],

         "csn": ["csn", "sgn"],

         "csq": ["csq", "sgn"],

         "csr": ["csr", "sgn"],

         "czh": ["czh", "zh"],

         "czo": ["czo", "zh"],

         "doq": ["doq", "sgn"],

         "dse": ["dse", "sgn"],

         "dsl": ["dsl", "sgn"],

         "dup": ["dup", "ms"],

         "ecs": ["ecs", "sgn"],

         "esl": ["esl", "sgn"],

         "esn": ["esn", "sgn"],

         "eso": ["eso", "sgn"],

         "eth": ["eth", "sgn"],

         "fcs": ["fcs", "sgn"],

         "fse": ["fse", "sgn"],

         "fsl": ["fsl", "sgn"],

         "fss": ["fss", "sgn"],

         "gan": ["gan", "zh"],

         "gom": ["gom", "kok"],

         "gse": ["gse", "sgn"],

         "gsg": ["gsg", "sgn"],

         "gsm": ["gsm", "sgn"],

         "gss": ["gss", "sgn"],

         "gus": ["gus", "sgn"],

         "hab": ["hab", "sgn"],

         "haf": ["haf", "sgn"],

         "hak": ["hak", "zh"],

         "hds": ["hds", "sgn"],

         "hji": ["hji", "ms"],

         "hks": ["hks", "sgn"],

         "hos": ["hos", "sgn"],

         "hps": ["hps", "sgn"],

         "hsh": ["hsh", "sgn"],

         "hsl": ["hsl", "sgn"],

         "hsn": ["hsn", "zh"],

         "icl": ["icl", "sgn"],

         "ils": ["ils", "sgn"],

         "inl": ["inl", "sgn"],

         "ins": ["ins", "sgn"],

         "ise": ["ise", "sgn"],

         "isg": ["isg", "sgn"],

         "isr": ["isr", "sgn"],

         "jak": ["jak", "ms"],

         "jax": ["jax", "ms"],

         "jcs": ["jcs", "sgn"],

         "jhs": ["jhs", "sgn"],

         "jls": ["jls", "sgn"],

         "jos": ["jos", "sgn"],

         "jsl": ["jsl", "sgn"],

         "jus": ["jus", "sgn"],

         "kgi": ["kgi", "sgn"],

         "knn": ["knn", "kok"],

         "kvb": ["kvb", "ms"],

         "kvk": ["kvk", "sgn"],

         "kvr": ["kvr", "ms"],

         "kxd": ["kxd", "ms"],

         "lbs": ["lbs", "sgn"],

         "lce": ["lce", "ms"],

         "lcf": ["lcf", "ms"],

         "liw": ["liw", "ms"],

         "lls": ["lls", "sgn"],

         "lsg": ["lsg", "sgn"],

         "lsl": ["lsl", "sgn"],

         "lso": ["lso", "sgn"],

         "lsp": ["lsp", "sgn"],

         "lst": ["lst", "sgn"],

         "lsy": ["lsy", "sgn"],

         "ltg": ["ltg", "lv"],

         "lvs": ["lvs", "lv"],

         "lzh": ["lzh", "zh"],

         "max": ["max", "ms"],

         "mdl": ["mdl", "sgn"],

         "meo": ["meo", "ms"],

         "mfa": ["mfa", "ms"],

         "mfb": ["mfb", "ms"],

         "mfs": ["mfs", "sgn"],

         "min": ["min", "ms"],

         "mnp": ["mnp", "zh"],

         "mqg": ["mqg", "ms"],

         "mre": ["mre", "sgn"],

         "msd": ["msd", "sgn"],

         "msi": ["msi", "ms"],

         "msr": ["msr", "sgn"],

         "mui": ["mui", "ms"],

         "mzc": ["mzc", "sgn"],

         "mzg": ["mzg", "sgn"],

         "mzy": ["mzy", "sgn"],

         "nan": ["nan", "zh"],

         "nbs": ["nbs", "sgn"],

         "ncs": ["ncs", "sgn"],

         "nsi": ["nsi", "sgn"],

         "nsl": ["nsl", "sgn"],

         "nsp": ["nsp", "sgn"],

         "nsr": ["nsr", "sgn"],

         "nzs": ["nzs", "sgn"],

         "okl": ["okl", "sgn"],

         "orn": ["orn", "ms"],

         "ors": ["ors", "ms"],

         "pel": ["pel", "ms"],

         "pga": ["pga", "ar"],

         "pks": ["pks", "sgn"],

         "prl": ["prl", "sgn"],

         "prz": ["prz", "sgn"],

         "psc": ["psc", "sgn"],

         "psd": ["psd", "sgn"],

         "pse": ["pse", "ms"],

         "psg": ["psg", "sgn"],

         "psl": ["psl", "sgn"],

         "pso": ["pso", "sgn"],

         "psp": ["psp", "sgn"],

         "psr": ["psr", "sgn"],

         "pys": ["pys", "sgn"],

         "rms": ["rms", "sgn"],

         "rsi": ["rsi", "sgn"],

         "rsl": ["rsl", "sgn"],

         "sdl": ["sdl", "sgn"],

         "sfb": ["sfb", "sgn"],

         "sfs": ["sfs", "sgn"],

         "sgg": ["sgg", "sgn"],

         "sgx": ["sgx", "sgn"],

         "shu": ["shu", "ar"],

         "slf": ["slf", "sgn"],

         "sls": ["sls", "sgn"],

         "sqs": ["sqs", "sgn"],

         "ssh": ["ssh", "ar"],

         "ssp": ["ssp", "sgn"],

         "ssr": ["ssr", "sgn"],

         "svk": ["svk", "sgn"],

         "swc": ["swc", "sw"],

         "swh": ["swh", "sw"],

         "swl": ["swl", "sgn"],

         "syy": ["syy", "sgn"],

         "tmw": ["tmw", "ms"],

         "tse": ["tse", "sgn"],

         "tsm": ["tsm", "sgn"],

         "tsq": ["tsq", "sgn"],

         "tss": ["tss", "sgn"],

         "tsy": ["tsy", "sgn"],

         "tza": ["tza", "sgn"],

         "ugn": ["ugn", "sgn"],

         "ugy": ["ugy", "sgn"],

         "ukl": ["ukl", "sgn"],

         "uks": ["uks", "sgn"],

         "urk": ["urk", "ms"],

         "uzn": ["uzn", "uz"],

         "uzs": ["uzs", "uz"],

         "vgt": ["vgt", "sgn"],

         "vkk": ["vkk", "ms"],

         "vkt": ["vkt", "ms"],

         "vsi": ["vsi", "sgn"],

         "vsl": ["vsl", "sgn"],

         "vsv": ["vsv", "sgn"],

         "wuu": ["wuu", "zh"],

         "xki": ["xki", "sgn"],

         "xml": ["xml", "sgn"],

         "xmm": ["xmm", "ms"],

         "xms": ["xms", "sgn"],

         "yds": ["yds", "sgn"],

         "ysl": ["ysl", "sgn"],

         "yue": ["yue", "zh"],

         "zib": ["zib", "sgn"],

         "zlm": ["zlm", "ms"],

         "zmi": ["zmi", "ms"],

         "zsl": ["zsl", "sgn"],

         "zsm": ["zsm", "ms"]

     };

     /**

      * Canonicalizes the given well-formed BCP 47 language tag, including regularized case of subtags.

      *

      * Spec: ECMAScript Internationalization API Specification, draft, 6.2.3.

      * Spec: RFC 5646, section 4.5.

      */

     function canonicalizeLanguageTag(locale) {

         // start with lower case for easier processing, and because most subtags will need to be lower case anyway

         locale = locale.toLowerCase();

         // handle mappings for complete tags

         if (__tagMappings.hasOwnProperty(locale)) {

             return __tagMappings[locale];

         }

         var subtags = locale.split("-");

         var i = 0;

         // handle standard part: all subtags before first singleton or "x"

         while (i < subtags.length) {

             var subtag = subtags[i];

             if (subtag.length === 1 && (i > 0 || subtag === "x")) {

                 break;

             } else if (i !== 0 && subtag.length === 2) {

                 subtag = subtag.toUpperCase();

             } else if (subtag.length === 4) {

                 subtag = subtag[0].toUpperCase() + subtag.substring(1).toLowerCase();

             }

             if (__subtagMappings.hasOwnProperty(subtag)) {

                 subtag = __subtagMappings[subtag];

             } else if (__extlangMappings.hasOwnProperty(subtag)) {

                 subtag = __extlangMappings[subtag][0];

                 if (i === 1 && __extlangMappings[subtag][1] === subtags[0]) {

                     subtags.shift();

                     i--;

                 }

             }

             subtags[i] = subtag;

             i++;

         }

         var normal = subtags.slice(0, i).join("-");

         // handle extensions

         var extensions = [];

         while (i < subtags.length && subtags[i] !== "x") {

             var extensionStart = i;

             i++;

             while (i < subtags.length && subtags[i].length > 1) {

                 i++;

             }

             var extension = subtags.slice(extensionStart, i).join("-");

             extensions.push(extension);

         }

         extensions.sort();

         // handle private use

         var privateUse;

         if (i < subtags.length) {

             privateUse = subtags.slice(i).join("-");

         }

         // put everything back together

         var canonical = normal;

         if (extensions.length > 0) {

             canonical += "-" + extensions.join("-");

         }

         if (privateUse !== undefined) {

             if (canonical.length > 0) {

                 canonical += "-" + privateUse;

             } else {

                 canonical = privateUse;

             }

         }

         return canonical;

     }

     return typeof locale === "string" && isStructurallyValidLanguageTag(locale) &&

             canonicalizeLanguageTag(locale) === locale;

 }

 /**

  * Tests whether the named options property is correctly handled by the given constructor.

  * @param {object} Constructor the constructor to test.

  * @param {string} property the name of the options property to test.

  * @param {string} type the type that values of the property are expected to have

  * @param {Array} [values] an array of allowed values for the property. Not needed for boolean.

  * @param {any} fallback the fallback value that the property assumes if not provided.

  * @param {object} testOptions additional options:

  *     @param {boolean} isOptional whether support for this property is optional for implementations.

  *     @param {boolean} noReturn whether the resulting value of the property is not returned.

  *     @param {boolean} isILD whether the resulting value of the property is implementation and locale dependent.

  *     @param {object} extra additional option to pass along, properties are value -> {option: value}.

  * @return {boolean} whether the test succeeded.

  */

 function testOption(Constructor, property, type, values, fallback, testOptions) {

     var isOptional = testOptions !== undefined && testOptions.isOptional === true;

     var noReturn = testOptions !== undefined && testOptions.noReturn === true;

     var isILD = testOptions !== undefined && testOptions.isILD === true;

     function addExtraOptions(options, value, testOptions) {

         if (testOptions !== undefined && testOptions.extra !== undefined) {

             var extra;

             if (value !== undefined && testOptions.extra[value] !== undefined) {

                 extra = testOptions.extra[value];

             } else if (testOptions.extra.any !== undefined) {

                 extra = testOptions.extra.any;

             }

             if (extra !== undefined) {

                 Object.getOwnPropertyNames(extra).forEach(function (prop) {

                     options[prop] = extra[prop];

                 });

             }

         }

     }

     var testValues, options, obj, expected, actual, error;

     // test that the specified values are accepted. Also add values that convert to specified values.

     if (type === "boolean") {

         if (values === undefined) {

             values = [true, false];

         }

         testValues = values.slice(0);

         testValues.push(888);

         testValues.push(0);

     } else if (type === "string") {

         testValues = values.slice(0);

         testValues.push({toString: function () { return values[0]; }});

     }

     testValues.forEach(function (value) {

         options = {};

         options[property] = value;

         addExtraOptions(options, value, testOptions);

         obj = new Constructor(undefined, options);

         if (noReturn) {

             if (obj.resolvedOptions().hasOwnProperty(property)) {

                 $ERROR("Option property " + property + " is returned, but shouldn't be.");

             }

         } else {

             actual = obj.resolvedOptions()[property];

             if (isILD) {

                 if (actual !== undefined && values.indexOf(actual) === -1) {

                     $ERROR("Invalid value " + actual + " returned for property " + property + ".");

                 }

             } else {

                 if (type === "boolean") {

                     expected = Boolean(value);

                 } else if (type === "string") {

                     expected = String(value);

                 }

                 if (actual !== expected && !(isOptional && actual === undefined)) {

                     $ERROR("Option value " + value + " for property " + property +

                         " was not accepted; got " + actual + " instead.");

                 }

             }

         }

     });

     // test that invalid values are rejected

     if (type === "string") {

         var invalidValues = ["invalidValue", -1, null];

         // assume that we won't have values in caseless scripts

         if (values[0].toUpperCase() !== values[0]) {

             invalidValues.push(values[0].toUpperCase());

         } else {

             invalidValues.push(values[0].toLowerCase());

         }

         invalidValues.forEach(function (value) {

             options = {};

             options[property] = value;

             addExtraOptions(options, value, testOptions);

             error = undefined;

             try {

                 obj = new Constructor(undefined, options);

             } catch (e) {

                 error = e;

             }

             if (error === undefined) {

                 $ERROR("Invalid option value " + value + " for property " + property + " was not rejected.");

             } else if (error.name !== "RangeError") {

                 $ERROR("Invalid option value " + value + " for property " + property + " was rejected with wrong error " + error.name + ".");

             }

         });

     }

     // test that fallback value or another valid value is used if no options value is provided

     if (!noReturn) {

         options = {};

         addExtraOptions(options, undefined, testOptions);

         obj = new Constructor(undefined, options);

         actual = obj.resolvedOptions()[property];

         if (!(isOptional && actual === undefined)) {

             if (fallback !== undefined) {

                 if (actual !== fallback) {

                     $ERROR("Option fallback value " + fallback + " for property " + property +

                         " was not used; got " + actual + " instead.");

                 }

             } else {

                 if (values.indexOf(actual) === -1 && !(isILD && actual === undefined)) {

                     $ERROR("Invalid value " + actual + " returned for property " + property + ".");

                 }

             }

         }

     }

     return true;

 }

 /**

  * Tests whether the named property of the given object has a valid value

  * and the default attributes of the properties of an object literal.

  * @param {Object} obj the object to be tested.

  * @param {string} property the name of the property

  * @param {Function|Array} valid either a function that tests value for validity and returns a boolean,

  *     an array of valid values.

  * @exception if the property has an invalid value.

  */

 function testProperty(obj, property, valid) {

     var desc = Object.getOwnPropertyDescriptor(obj, property);

     if (!desc.writable) {

         $ERROR("Property " + property + " must be writable.");

     }

     if (!desc.enumerable) {

         $ERROR("Property " + property + " must be enumerable.");

     }

     if (!desc.configurable) {

         $ERROR("Property " + property + " must be configurable.");

     }

     var value = desc.value;

     var isValid = (typeof valid === "function") ? valid(value) : (valid.indexOf(value) !== -1);

     if (!isValid) {

         $ERROR("Property value " + value + " is not allowed for property " + property + ".");

     }

 }

 /**

  * Tests whether the named property of the given object, if present at all, has a valid value

  * and the default attributes of the properties of an object literal.

  * @param {Object} obj the object to be tested.

  * @param {string} property the name of the property

  * @param {Function|Array} valid either a function that tests value for validity and returns a boolean,

  *     an array of valid values.

  * @exception if the property is present and has an invalid value.

  */

 function mayHaveProperty(obj, property, valid) {

     if (obj.hasOwnProperty(property)) {

         testProperty(obj, property, valid);

     }

 }

 /**

  * Tests whether the given object has the named property with a valid value

  * and the default attributes of the properties of an object literal.

  * @param {Object} obj the object to be tested.

  * @param {string} property the name of the property

  * @param {Function|Array} valid either a function that tests value for validity and returns a boolean,

  *     an array of valid values.

  * @exception if the property is missing or has an invalid value.

  */

 function mustHaveProperty(obj, property, valid) {

     if (!obj.hasOwnProperty(property)) {

         $ERROR("Object is missing property " + property + ".");

     }

     testProperty(obj, property, valid);

 }

 /**

  * Tests whether the given object does not have the named property.

  * @param {Object} obj the object to be tested.

  * @param {string} property the name of the property

  * @exception if the property is present.

  */

 function mustNotHaveProperty(obj, property) {

     if (obj.hasOwnProperty(property)) {

         $ERROR("Object has property it mustn't have: " + property + ".");

     }

 }

 /**

  * Properties of the RegExp constructor that may be affected by use of regular

  * expressions, and the default values of these properties. Properties are from

  * https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Deprecated_and_obsolete_features#RegExp_Properties

  */

 var regExpProperties = ["$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9",

     "$_", "$*", "$&", "$+", "$`", "$'",

     "input", "lastMatch", "lastParen", "leftContext", "rightContext"

 ];

 var regExpPropertiesDefaultValues = (function () {

     var values = Object.create(null);

     regExpProperties.forEach(function (property) {

         values[property] = RegExp[property];

     });

     return values;

 }());

 /**

  * Tests that executing the provided function (which may use regular expressions

  * in its implementation) does not create or modify unwanted properties on the

  * RegExp constructor.

  */

 function testForUnwantedRegExpChanges(testFunc) {

     regExpProperties.forEach(function (property) {

         RegExp[property] = regExpPropertiesDefaultValues[property];

     });

     testFunc();

     regExpProperties.forEach(function (property) {

         if (RegExp[property] !== regExpPropertiesDefaultValues[property]) {

             $ERROR("RegExp has unexpected property " + property + " with value " +

                 RegExp[property] + ".");

         }

     });

 }

 /**

  * Tests whether name is a valid BCP 47 numbering system name

  * and not excluded from use in the ECMAScript Internationalization API.

  * @param {string} name the name to be tested.

  * @return {boolean} whether name is a valid BCP 47 numbering system name and

  *     allowed for use in the ECMAScript Internationalization API.

  */

 function isValidNumberingSystem(name) {

     // source: CLDR file common/bcp47/number.xml; version CLDR 21.

     var numberingSystems = [

         "arab",

         "arabext",

         "armn",

         "armnlow",

         "bali",

         "beng",

         "brah",

         "cakm",

         "cham",

         "deva",

         "ethi",

         "finance",

         "fullwide",

         "geor",

         "grek",

         "greklow",

         "gujr",

         "guru",

         "hanidec",

         "hans",

         "hansfin",

         "hant",

         "hantfin",

         "hebr",

         "java",

         "jpan",

         "jpanfin",

         "kali",

         "khmr",

         "knda",

         "osma",            

         "lana",

         "lanatham",

         "laoo",

         "latn",

         "lepc",

         "limb",

         "mlym",

         "mong",

         "mtei",

         "mymr",

         "mymrshan",

         "native",

         "nkoo",

         "olck",

         "orya",

         "roman",

         "romanlow",

         "saur",

         "shrd",

         "sora",

         "sund",

         "talu",

         "takr",

         "taml",

         "tamldec",

         "telu",

         "thai",

         "tibt",

         "traditio",

         "vaii"

     ];

     var excluded = [

         "finance",

         "native",

         "traditio"

     ];

     return numberingSystems.indexOf(name) !== -1 && excluded.indexOf(name) === -1;

 }

 /**

  * Provides the digits of numbering systems with simple digit mappings,

  * as specified in 11.3.2.

  */

 var numberingSystemDigits = {

     arab: "٠١٢٣٤٥٦٧٨٩",

     arabext: "۰۱۲۳۴۵۶۷۸۹",

     beng: "০১২৩৪৫৬৭৮৯",

     deva: "०१२३४५६७८९",

     fullwide: "０１２３４５６７８９",

     gujr: "૦૧૨૩૪૫૬૭૮૯",

     guru: "੦੧੨੩੪੫੬੭੮੯",

     hanidec: "〇一二三四五六七八九",

     khmr: "០១២៣៤៥៦៧៨៩",

     knda: "೦೧೨೩೪೫೬೭೮೯",

     laoo: "໐໑໒໓໔໕໖໗໘໙",

     latn: "0123456789",

     mlym: "൦൧൨൩൪൫൬൭൮൯",

     mong: "᠐᠑᠒᠓᠔᠕᠖᠗᠘᠙",

     mymr: "၀၁၂၃၄၅၆၇၈၉",

     orya: "୦୧୨୩୪୫୬୭୮୯",

     tamldec: "௦௧௨௩௪௫௬௭௮௯",

     telu: "౦౧౨౩౪౫౬౭౮౯",

     thai: "๐๑๒๓๔๕๖๗๘๙",

     tibt: "༠༡༢༣༤༥༦༧༨༩"

 };

 /**

  * Tests that number formatting is handled correctly. The function checks that the

  * digit sequences in formatted output are as specified, converted to the

  * selected numbering system, and embedded in consistent localized patterns.

  * @param {Array} locales the locales to be tested.

  * @param {Array} numberingSystems the numbering systems to be tested.

  * @param {Object} options the options to pass to Intl.NumberFormat. Options

  *     must include {useGrouping: false}, and must cause 1.1 to be formatted

  *     pre- and post-decimal digits.

  * @param {Object} testData maps input data (in ES5 9.3.1 format) to expected output strings

  *     in unlocalized format with Western digits.

  */

 function testNumberFormat(locales, numberingSystems, options, testData) {

     locales.forEach(function (locale) {

         numberingSystems.forEach(function (numbering) {

             var digits = numberingSystemDigits[numbering];

             var format = new Intl.NumberFormat([locale + "-u-nu-" + numbering], options);

             function getPatternParts(positive) {

                 var n = positive ? 1.1 : -1.1;

                 var formatted = format.format(n);

                 var oneoneRE = "([^" + digits + "]*)[" + digits + "]+([^" + digits + "]+)[" + digits + "]+([^" + digits + "]*)";

                 var match = formatted.match(new RegExp(oneoneRE));

                 if (match === null) {

                     $ERROR("Unexpected formatted " + n + " for " +

                         format.resolvedOptions().locale + " and options " +

                         JSON.stringify(options) + ": " + formatted);

                 }

                 return match;

             }

             function toNumbering(raw) {

                 return raw.replace(/[0-9]/g, function (digit) {

                     return digits[digit.charCodeAt(0) - "0".charCodeAt(0)];

                 });

             }

             function buildExpected(raw, patternParts) {

                 var period = raw.indexOf(".");

                 if (period === -1) {

                     return patternParts[1] + toNumbering(raw) + patternParts[3];

                 } else {

                     return patternParts[1] + 

                         toNumbering(raw.substring(0, period)) +

                         patternParts[2] +

                         toNumbering(raw.substring(period + 1)) +

                         patternParts[3];

                 }

             }

             if (format.resolvedOptions().numberingSystem === numbering) {

                 // figure out prefixes, infixes, suffixes for positive and negative values

                 var posPatternParts = getPatternParts(true);

                 var negPatternParts = getPatternParts(false);

                 Object.getOwnPropertyNames(testData).forEach(function (input) {

                     var rawExpected = testData[input];

                     var patternParts;

                     if (rawExpected[0] === "-") {

                         patternParts = negPatternParts;

                         rawExpected = rawExpected.substring(1);

                     } else {

                         patternParts = posPatternParts;

                     }

                     var expected = buildExpected(rawExpected, patternParts);

                     var actual = format.format(input);

                     if (actual !== expected) {

                         $ERROR("Formatted value for " + input + ", " +

                         format.resolvedOptions().locale + " and options " +

                         JSON.stringify(options) + " is " + actual + "; expected " + expected + ".");

                     }

                 });

             }

         });

     });

 }

 /**

  * Return the components of date-time formats.

  * @return {Array} an array with all date-time components.

  */

 function getDateTimeComponents() {

     return ["weekday", "era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"];

 }

 /**

  * Return the valid values for the given date-time component, as specified

  * by the table in section 12.1.1.

  * @param {string} component a date-time component.

  * @return {Array} an array with the valid values for the component.

  */

 function getDateTimeComponentValues(component) {

     var components = {

         weekday: ["narrow", "short", "long"],

         era: ["narrow", "short", "long"],

         year: ["2-digit", "numeric"],

         month: ["2-digit", "numeric", "narrow", "short", "long"],

         day: ["2-digit", "numeric"],

         hour: ["2-digit", "numeric"],

         minute: ["2-digit", "numeric"],

         second: ["2-digit", "numeric"],

         timeZoneName: ["short", "long"]

     };

     var result = components[component];

     if (result === undefined) {

         $ERROR("Internal error: No values defined for date-time component " + component + ".");

     }

     return result;

 }

 /**

  * Tests that the given value is valid for the given date-time component.

  * @param {string} component a date-time component.

  * @param {string} value the value to be tested.

  * @return {boolean} true if the test succeeds.

  * @exception if the test fails.

  */

 function testValidDateTimeComponentValue(component, value) {

     if (getDateTimeComponentValues(component).indexOf(value) === -1) {

         $ERROR("Invalid value " + value + " for date-time component " + component + ".");

     }

     return true;

 }

 /**

  * Verifies that the actual array matches the expected one in length, elements,

  * and element order.

  * @param {Array} expected the expected array.

  * @param {Array} actual the actual array.

  * @return {boolean} true if the test succeeds.

  * @exception if the test fails.

  */

 function testArraysAreSame(expected, actual) {

     for (i = 0; i < Math.max(actual.length, expected.length); i++) {

         if (actual[i] !== expected[i]) {

             $ERROR("Result array element at index " + i + " should be \"" +

                 expected[i] + "\" but is \"" + actual[i] + "\".");

         }

     }

     return true;

 }