// 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;
}