Source code

Revision control

Other Tools

Test Info: Warnings

  • This test was skipped 1157 times in the preceding 7 days.
  • This test has a WPT meta file that expects 28 subtest issues.
<!DOCTYPE html>
<script src="/resources/testharness.js" ></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support/helper.sub.js"></script>
<body>
<script>
//HTML tests
function createHTMLTest(policyName, policy, expectedHTML, t) {
let p = window.trustedTypes.createPolicy(policyName, policy);
let html = p.createHTML('whatever');
assert_true(html instanceof TrustedHTML);
assert_true(trustedTypes.isHTML(html));
assert_equals(html + "", expectedHTML);
}
test(t => {
createHTMLTest('TestPolicyHTML1', { createHTML: s => s }, 'whatever', t);
}, "html = identity function");
test(t => {
createHTMLTest('TestPolicyHTML2', { createHTML: s => null }, "", t);
}, "html = null");
var HTMLstr = 'well, ';
test(t => {
createHTMLTest('TestPolicyHTML3', { createHTML: s => HTMLstr + s }, HTMLstr + 'whatever', t);
}, "html = string + global string");
var HTMLx = 'global';
test(t => {
createHTMLTest('TestPolicyHTML4', { createHTML: s => { HTMLx = s; return s; } }, 'whatever', t);
assert_equals(HTMLx, 'whatever');
}, "html = identity function, global string changed");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyHTML5', { createHTML: s => { throw new Error(); }});
assert_throws_js(Error, _ => {
p.createHTML('whatever');
});
}, "html = callback that throws");
var obj = {
"foo": "well,"
}
function getHTML(s) {
return this.foo + " " + s;
}
test(t => {
createHTMLTest('TestPolicyHTML6', { createHTML: getHTML.bind(obj) }, 'well, whatever', t);
}, "html = this bound to an object");
var foo = "well,";
test(t => {
createHTMLTest('TestPolicyHTML7', { createHTML: s => getHTML(s) }, 'well, whatever', t);
}, "html = this without bind");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyHTML8', null);
assert_throws_js(TypeError, _ => {
p.createHTML('whatever');
});
}, "html - calling undefined callback throws");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyHTML9', { createHTML: createHTMLJS });
assert_throws_js(TypeError, _ => {
p.createScript(INPUTS.SCRIPT);
});
assert_throws_js(TypeError, _ => {
p.createScriptURL(INPUTS.SCRIPTURL);
});
assert_throws_js(TypeError, _ => {
p.createURL(INPUTS.URL);
});
}, "createHTML defined - calling undefined callbacks throws");
//Script tests
function createScriptTest(policyName, policy, expectedScript, t) {
let p = window.trustedTypes.createPolicy(policyName, policy);
let script = p.createScript('whatever');
assert_true(script instanceof TrustedScript);
assert_true(trustedTypes.isScript(script));
assert_equals(script + "", expectedScript);
}
test(t => {
createScriptTest('TestPolicyScript1', { createScript: s => s }, 'whatever', t);
}, "script = identity function");
test(t => {
createScriptTest('TestPolicyScript2', { createScript: s => null }, "", t);
}, "script = null");
var Scriptstr = 'well, ';
test(t => {
createScriptTest('TestPolicyScript3', { createScript: s => Scriptstr + s }, Scriptstr + 'whatever', t);
}, "script = string + global string");
var Scriptx = 'global';
test(t => {
createScriptTest('TestPolicyScript4', { createScript: s => { Scriptx = s; return s; } }, 'whatever', t);
assert_equals(Scriptx, 'whatever');
}, "script = identity function, global string changed");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyScript5', {
createScript: s => { throw new Error(); }
});
assert_throws_js(Error, _ => {
p.createScript('whatever');
});
}, "script = callback that throws");
var obj = {
"foo": "well,"
}
function getScript(s) {
return this.foo + " " + s;
}
test(t => {
createScriptTest('TestPolicyScript6', { createScript: getScript.bind(obj) }, 'well, whatever', t);
}, "script = this bound to an object");
var foo = "well,";
test(t => {
createScriptTest('TestPolicyScript7', { createScript: s => getScript(s) }, 'well, whatever', t);
}, "script = this without bind");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyScript8', null);
assert_throws_js(TypeError, _ => {
p.createScript('whatever');
});
}, "script - calling undefined callback throws");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyScript9', { createScript: createScriptJS });
assert_throws_js(TypeError, _ => {
p.createHTML(INPUTS.HTML);
});
assert_throws_js(TypeError, _ => {
p.createScriptURL(INPUTS.SCRIPTURL);
});
assert_throws_js(TypeError, _ => {
p.createURL(INPUTS.URL);
});
}, "createScript defined - calling undefined callbacks throws");
//ScriptURL tests
function createScriptURLTest(policyName, policy, expectedScriptURL, t) {
let p = window.trustedTypes.createPolicy(policyName, policy);
let scriptUrl = p.createScriptURL(INPUTS.SCRIPTURL);
assert_true(scriptUrl instanceof TrustedScriptURL);
assert_true(trustedTypes.isScriptURL(scriptUrl));
assert_equals(scriptUrl + "", expectedScriptURL);
}
test(t => {
createScriptURLTest('TestPolicyScriptURL1', { createScriptURL: s => s }, INPUTS.SCRIPTURL, t);
}, "script_url = identity function");
test(t => {
createScriptURLTest('TestPolicyScriptURL2', { createScriptURL: s => null }, "", t);
}, "script_url = null");
var scriptURLstr = '#duck';
test(t => {
createScriptURLTest('TestPolicyScriptURL3', { createScriptURL: s => s + scriptURLstr }, INPUTS.SCRIPTURL + scriptURLstr, t);
}, "script_url = string + global string");
var scriptURLx = 'global';
test(t => {
createScriptURLTest('TestPolicyScriptURL4', { createScriptURL: s => { ScriptURLx = s; return s; } }, INPUTS.SCRIPTURL, t);
assert_equals(ScriptURLx, INPUTS.SCRIPTURL);
}, "script_url = identity function, global string changed");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyScriptURL5', {
createScriptURL: s => { throw new Error(); }
});
assert_throws_js(Error, _ => {
p.createScriptURL(INPUTS.SCRIPTURL);
});
}, "script_url = callback that throws");
function getScriptURL(s) {
return s + this.baz;
}
var obj = {
"baz": "#duck"
}
test(t => {
createScriptURLTest('TestPolicyScriptURL6', { createScriptURL: getScriptURL.bind(obj) }, INPUTS.SCRIPTURL + "#duck", t);
}, "script_url = this bound to an object");
var baz = "#duck";
test(t => {
createScriptURLTest('TestPolicyScriptURL7', { createScriptURL: s => getScriptURL(s) }, INPUTS.SCRIPTURL + baz, t);
}, "script_url = this without bind");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyScriptURL8', null);
assert_throws_js(TypeError, _ => {
p.createScriptURL(INPUTS.SCRIPTURL);
});
}, "script_url - calling undefined callback throws");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyScriptURL9', { createScriptURL: createScriptURLJS });
assert_throws_js(TypeError, _ => {
p.createHTML(INPUTS.HTML);
});
assert_throws_js(TypeError, _ => {
p.createScript(INPUTS.SCRIPT);
});
assert_throws_js(TypeError, _ => {
p.createURL(INPUTS.URL);
});
}, "createScriptURL defined - calling undefined callbacks throws");
test(t => {
let p = window.trustedTypes.createPolicy('TestPolicyScriptURL10', {
createHTML: createHTMLJSWithThreeArguments,
createScript: createScriptJSWithThreeArguments,
createScriptURL: createScriptURLJSWithThreeArguments
});
assert_equals("abc", p.createHTML("a", "b", "c").toString());
assert_equals("abc", p.createScript("a", "b", "c").toString());
assert_equals("abc", p.createScriptURL("a", "b", "c").toString());
assert_equals("abundefined", p.createHTML("a", "b").toString());
assert_equals("a123null", p.createScript("a", 123, null).toString());
assert_equals("a[object Object]3.14", p.createScriptURL("a", {}, 3.14).toString());
}, "Arbitrary number of arguments");
</script>