trusted-types/TrustedTypePolicyFactory-createPolicy.tentative.html - external/w3c/web-platform-tests - Git at Google

 <!DOCTYPE html>
 <script src="/resources/testharness.js" ></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="support/helper.sub.js"></script>
 <body>
 <script>
   //Policy name test
   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', { createHTML: s => s } )
         .then(t.step_func_done(policy => {
             assert_true(policy instanceof TrustedTypePolicy);
             assert_equals(policy.name, 'SomeName');
     }));
   }, "policy.name = name");

   //HTML tests
   function createHTMLTest(policy, expectedHTML, t) {
     window.trustedTypes.createPolicy('SomeName', policy)
         .then(t.step_func_done(p => {
             assert_true(p.createHTML('whatever') instanceof TrustedHTML);
             assert_equals(p.createHTML('whatever') + "", expectedHTML);
     }));
   }

   async_test(t => {
     createHTMLTest( { createHTML: s => s }, 'whatever', t);
   }, "html = identity function");

   async_test(t => {
     createHTMLTest( { createHTML: s => null }, "null", t);
   }, "html = null");

   var HTMLstr = 'well, ';
   async_test(t => {
     createHTMLTest( { createHTML: s => HTMLstr + s }, HTMLstr + 'whatever', t);
   }, "html = string + global string");

   var HTMLx = 'global';
   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', {
         createHTML: s => { HTMLx = s; return s; }
       })
       .then(t.step_func_done(p => {
         assert_true(p.createHTML('whatever') instanceof TrustedHTML);
         assert_equals(p.createHTML('whatever') + "", 'whatever');
         assert_equals(HTMLx, 'whatever');
     }));
   }, "html = identity function, global string changed");

   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', {
         createHTML: s => { throw new Error(); }
       })
       .then(t.step_func_done(p => {
         assert_throws(new Error(), _ => {
           p.createHTML('whatever');
         });
     }));
   }, "html = callback that throws");

   var obj = {
     "foo": "well,"
   }

   function getHTML(s) {
     return this.foo + " " + s;
   }

   async_test(t => {
     createHTMLTest( {
       createHTML: getHTML.bind(obj)},
       'well, whatever', t);
   }, "html = this bound to an object");

   var foo = "well,";
   async_test(t => {
     createHTMLTest( { createHTML: s => getHTML(s) }, 'well, whatever', t);
   }, "html = this without bind");

   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', null)
         .then(t.step_func_done(p => {
             assert_equals(p.createHTML('whatever'), null);
     }));
   }, "html - calling undefined callback");

   //Script tests
   function createScriptTest(policy, expectedScript, t) {
     let p = window.trustedTypes.createPolicy('SomeName', policy)
         .then(t.step_func_done(p => {
             assert_true(p.createScript('whatever') instanceof TrustedScript);
             assert_equals(p.createScript('whatever') + "", expectedScript);
     }));
   }

   async_test(t => {
     createScriptTest( { createScript: s => s }, 'whatever', t);
   }, "script = identity function");

   async_test(t => {
     createScriptTest( { createScript: s => null }, "null", t);
   }, "script = null");

   var Scriptstr = 'well, ';
   async_test(t => {
     createScriptTest( { createScript: s => Scriptstr + s }, Scriptstr + 'whatever', t);
   }, "script = string + global string");

   var Scriptx = 'global';
   async_test(t => {
     let p = window.trustedTypes.createPolicy('SomeName', {
         createScript: s => { Scriptx = s; return s; }
       })
       .then(t.step_func_done(p => {
         assert_true(p.createScript('whatever') instanceof TrustedScript);
         assert_equals(p.createScript('whatever') + "", 'whatever');
         assert_equals(Scriptx, 'whatever');
     }));
   }, "script = identity function, global string changed");

   async_test(t => {
     let p = window.trustedTypes.createPolicy('SomeName', {
         createScript: s => { throw new Error(); }
       })
       .then(t.step_func_done(p => {
         assert_throws(new Error(), _ => {
           p.createScript('whatever');
         });
     }));
   }, "script = callback that throws");

   var obj = {
     "foo": "well,"
   }

   function getScript(s) {
     return this.foo + " " + s;
   }

   async_test(t => {
     createScriptTest( {
       createScript: getScript.bind(obj)},
       'well, whatever', t);
   }, "script = this bound to an object");

   var foo = "well,";
   async_test(t => {
     createScriptTest( { createScript: s => getScript(s) }, 'well, whatever', t);
   }, "script = this without bind");

   async_test(t => {
     let p = window.trustedTypes.createPolicy('SomeName', null)
         .then(t.step_func_done(p => {
             assert_equals(p.createScript('whatever'), null);
     }));
   }, "script - calling undefined callback");

   //ScriptURL tests
   function createScriptURLTest(policy, expectedScriptURL, t) {
     window.trustedTypes.createPolicy('SomeName', policy)
         .then(t.step_func_done(p => {
             assert_true(p.createScriptURL(INPUTS.SCRIPTURL) instanceof TrustedScriptURL);
             assert_equals(p.createScriptURL(INPUTS.SCRIPTURL) + "", expectedScriptURL);
     }));
   }

   async_test(t => {
     createScriptURLTest( { createScriptURL: s => s }, INPUTS.SCRIPTURL, t);
   }, "script_url = identity function");

   async_test(t => {
     createScriptURLTest( { createScriptURL: s => null }, "", t);
   }, "script_url = null");

   var scriptURLstr = '#duck';
   async_test(t => {
     createScriptURLTest( { createScriptURL: s => s + scriptURLstr }, INPUTS.SCRIPTURL + scriptURLstr, t);
   }, "script_url = string + global string");

   var scriptURLx = 'global';
   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', {
         createScriptURL: s => { ScriptURLx = s; return s; }
       })
       .then(t.step_func_done(p => {
         assert_true(p.createScriptURL(INPUTS.SCRIPTURL) instanceof TrustedScriptURL);
         assert_equals(p.createScriptURL(INPUTS.SCRIPTURL) + "", INPUTS.SCRIPTURL);
         assert_equals(ScriptURLx, INPUTS.SCRIPTURL);
     }));
   }, "script_url = identity function, global string changed");

   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', {
         createScriptURL: s => { throw new Error(); }
       })
       .then(t.step_func_done(p => {
         assert_throws(new Error(), _ => {
           p.createScriptURL(INPUTS.SCRIPTURL);
         });
     }));
   }, "script_url = callback that throws");

   function getScriptURL(s) {
     return s + this.baz;
   }

   var obj = {
     "baz": "#duck"
   }

   async_test(t => {
     createScriptURLTest( {
       createScriptURL: getScriptURL.bind(obj)},
       INPUTS.SCRIPTURL + "#duck", t);
   }, "script_url = this bound to an object");

   var baz = "#duck";
   async_test(t => {
     createScriptURLTest( { createScriptURL: s => getScriptURL(s) }, INPUTS.SCRIPTURL + baz, t);
   }, "script_url = this without bind");

   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', null)
         .then(t.step_func_done(p => {
             assert_equals(p.createScriptURL(INPUTS.SCRIPTURL), null);
     }));
   }, "script_url - calling undefined callback");

   //URL tests
   function createURLTest(policy, expectedURL, t) {
     window.trustedTypes.createPolicy('SomeName', policy)
         .then(t.step_func_done(p => {
             assert_true(p.createURL(INPUTS.URL) instanceof TrustedURL);
             assert_equals(p.createURL(INPUTS.URL) + "", expectedURL);
     }));
   }

   async_test(t => {
     createURLTest( { createURL: s => s }, INPUTS.URL, t);
   }, "url = identity function");

   async_test(t => {
     createURLTest( { createURL: s => null }, "", t);
   }, "url = null");

   var URLstr = '#x';
   async_test(t => {
     createURLTest( { createURL: s => s + URLstr }, INPUTS.URL + URLstr, t);
   }, "url = string + global string");

   var URLx = 'global';
   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', {
         createURL: s => { URLx = s; return s; }
       })
       .then(t.step_func_done(p => {
         assert_true(p.createURL(INPUTS.URL) instanceof TrustedURL);
         assert_equals(p.createURL(INPUTS.URL) + "", INPUTS.URL);
         assert_equals(URLx, INPUTS.URL);
     }));
   }, "url = identity function, global string changed");

   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', {
         createURL: s => { throw new Error(); }
       })
       .then(t.step_func_done(p => {
         assert_throws(new Error(), _ => {
           p.createURL(INPUTS.URL);
         });
     }));
   }, "url = callback that throws");

   function getURL(s) {
     return s + this.bar;
   }

   var obj = {
     "bar": "#x"
   }

   async_test(t => {
     createURLTest( {
       createURL: getURL.bind(obj)},
       INPUTS.URL + "#x", t);
   }, "url = this bound to an object");

   var bar = "#x";
   async_test(t => {
     createURLTest( { createURL: s => getURL(s) }, INPUTS.URL + bar, t);
   }, "url = this without bind");

   async_test(t => {
     window.trustedTypes.createPolicy('SomeName', null)
         .then(t.step_func_done(p => {
             assert_equals(p.createURL(INPUTS.URL), null);
     }));
   }, "url - calling undefined callback");
 </script>
	<!DOCTYPE html>
	<script src="/resources/testharness.js" ></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="support/helper.sub.js"></script>
	<body>
	<script>
	//Policy name test
	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', { createHTML: s => s } )
	.then(t.step_func_done(policy => {
	assert_true(policy instanceof TrustedTypePolicy);
	assert_equals(policy.name, 'SomeName');
	}));
	}, "policy.name = name");

	//HTML tests
	function createHTMLTest(policy, expectedHTML, t) {
	window.trustedTypes.createPolicy('SomeName', policy)
	.then(t.step_func_done(p => {
	assert_true(p.createHTML('whatever') instanceof TrustedHTML);
	assert_equals(p.createHTML('whatever') + "", expectedHTML);
	}));
	}

	async_test(t => {
	createHTMLTest( { createHTML: s => s }, 'whatever', t);
	}, "html = identity function");

	async_test(t => {
	createHTMLTest( { createHTML: s => null }, "null", t);
	}, "html = null");

	var HTMLstr = 'well, ';
	async_test(t => {
	createHTMLTest( { createHTML: s => HTMLstr + s }, HTMLstr + 'whatever', t);
	}, "html = string + global string");

	var HTMLx = 'global';
	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', {
	createHTML: s => { HTMLx = s; return s; }
	})
	.then(t.step_func_done(p => {
	assert_true(p.createHTML('whatever') instanceof TrustedHTML);
	assert_equals(p.createHTML('whatever') + "", 'whatever');
	assert_equals(HTMLx, 'whatever');
	}));
	}, "html = identity function, global string changed");

	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', {
	createHTML: s => { throw new Error(); }
	})
	.then(t.step_func_done(p => {
	assert_throws(new Error(), _ => {
	p.createHTML('whatever');
	});
	}));
	}, "html = callback that throws");

	var obj = {
	"foo": "well,"
	}

	function getHTML(s) {
	return this.foo + " " + s;
	}

	async_test(t => {
	createHTMLTest( {
	createHTML: getHTML.bind(obj)},
	'well, whatever', t);
	}, "html = this bound to an object");

	var foo = "well,";
	async_test(t => {
	createHTMLTest( { createHTML: s => getHTML(s) }, 'well, whatever', t);
	}, "html = this without bind");

	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', null)
	.then(t.step_func_done(p => {
	assert_equals(p.createHTML('whatever'), null);
	}));
	}, "html - calling undefined callback");

	//Script tests
	function createScriptTest(policy, expectedScript, t) {
	let p = window.trustedTypes.createPolicy('SomeName', policy)
	.then(t.step_func_done(p => {
	assert_true(p.createScript('whatever') instanceof TrustedScript);
	assert_equals(p.createScript('whatever') + "", expectedScript);
	}));
	}

	async_test(t => {
	createScriptTest( { createScript: s => s }, 'whatever', t);
	}, "script = identity function");

	async_test(t => {
	createScriptTest( { createScript: s => null }, "null", t);
	}, "script = null");

	var Scriptstr = 'well, ';
	async_test(t => {
	createScriptTest( { createScript: s => Scriptstr + s }, Scriptstr + 'whatever', t);
	}, "script = string + global string");

	var Scriptx = 'global';
	async_test(t => {
	let p = window.trustedTypes.createPolicy('SomeName', {
	createScript: s => { Scriptx = s; return s; }
	})
	.then(t.step_func_done(p => {
	assert_true(p.createScript('whatever') instanceof TrustedScript);
	assert_equals(p.createScript('whatever') + "", 'whatever');
	assert_equals(Scriptx, 'whatever');
	}));
	}, "script = identity function, global string changed");

	async_test(t => {
	let p = window.trustedTypes.createPolicy('SomeName', {
	createScript: s => { throw new Error(); }
	})
	.then(t.step_func_done(p => {
	assert_throws(new Error(), _ => {
	p.createScript('whatever');
	});
	}));
	}, "script = callback that throws");

	var obj = {
	"foo": "well,"
	}

	function getScript(s) {
	return this.foo + " " + s;
	}

	async_test(t => {
	createScriptTest( {
	createScript: getScript.bind(obj)},
	'well, whatever', t);
	}, "script = this bound to an object");

	var foo = "well,";
	async_test(t => {
	createScriptTest( { createScript: s => getScript(s) }, 'well, whatever', t);
	}, "script = this without bind");

	async_test(t => {
	let p = window.trustedTypes.createPolicy('SomeName', null)
	.then(t.step_func_done(p => {
	assert_equals(p.createScript('whatever'), null);
	}));
	}, "script - calling undefined callback");

	//ScriptURL tests
	function createScriptURLTest(policy, expectedScriptURL, t) {
	window.trustedTypes.createPolicy('SomeName', policy)
	.then(t.step_func_done(p => {
	assert_true(p.createScriptURL(INPUTS.SCRIPTURL) instanceof TrustedScriptURL);
	assert_equals(p.createScriptURL(INPUTS.SCRIPTURL) + "", expectedScriptURL);
	}));
	}

	async_test(t => {
	createScriptURLTest( { createScriptURL: s => s }, INPUTS.SCRIPTURL, t);
	}, "script_url = identity function");

	async_test(t => {
	createScriptURLTest( { createScriptURL: s => null }, "", t);
	}, "script_url = null");

	var scriptURLstr = '#duck';
	async_test(t => {
	createScriptURLTest( { createScriptURL: s => s + scriptURLstr }, INPUTS.SCRIPTURL + scriptURLstr, t);
	}, "script_url = string + global string");

	var scriptURLx = 'global';
	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', {
	createScriptURL: s => { ScriptURLx = s; return s; }
	})
	.then(t.step_func_done(p => {
	assert_true(p.createScriptURL(INPUTS.SCRIPTURL) instanceof TrustedScriptURL);
	assert_equals(p.createScriptURL(INPUTS.SCRIPTURL) + "", INPUTS.SCRIPTURL);
	assert_equals(ScriptURLx, INPUTS.SCRIPTURL);
	}));
	}, "script_url = identity function, global string changed");

	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', {
	createScriptURL: s => { throw new Error(); }
	})
	.then(t.step_func_done(p => {
	assert_throws(new Error(), _ => {
	p.createScriptURL(INPUTS.SCRIPTURL);
	});
	}));
	}, "script_url = callback that throws");

	function getScriptURL(s) {
	return s + this.baz;
	}

	var obj = {
	"baz": "#duck"
	}

	async_test(t => {
	createScriptURLTest( {
	createScriptURL: getScriptURL.bind(obj)},
	INPUTS.SCRIPTURL + "#duck", t);
	}, "script_url = this bound to an object");

	var baz = "#duck";
	async_test(t => {
	createScriptURLTest( { createScriptURL: s => getScriptURL(s) }, INPUTS.SCRIPTURL + baz, t);
	}, "script_url = this without bind");

	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', null)
	.then(t.step_func_done(p => {
	assert_equals(p.createScriptURL(INPUTS.SCRIPTURL), null);
	}));
	}, "script_url - calling undefined callback");

	//URL tests
	function createURLTest(policy, expectedURL, t) {
	window.trustedTypes.createPolicy('SomeName', policy)
	.then(t.step_func_done(p => {
	assert_true(p.createURL(INPUTS.URL) instanceof TrustedURL);
	assert_equals(p.createURL(INPUTS.URL) + "", expectedURL);
	}));
	}

	async_test(t => {
	createURLTest( { createURL: s => s }, INPUTS.URL, t);
	}, "url = identity function");

	async_test(t => {
	createURLTest( { createURL: s => null }, "", t);
	}, "url = null");

	var URLstr = '#x';
	async_test(t => {
	createURLTest( { createURL: s => s + URLstr }, INPUTS.URL + URLstr, t);
	}, "url = string + global string");

	var URLx = 'global';
	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', {
	createURL: s => { URLx = s; return s; }
	})
	.then(t.step_func_done(p => {
	assert_true(p.createURL(INPUTS.URL) instanceof TrustedURL);
	assert_equals(p.createURL(INPUTS.URL) + "", INPUTS.URL);
	assert_equals(URLx, INPUTS.URL);
	}));
	}, "url = identity function, global string changed");

	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', {
	createURL: s => { throw new Error(); }
	})
	.then(t.step_func_done(p => {
	assert_throws(new Error(), _ => {
	p.createURL(INPUTS.URL);
	});
	}));
	}, "url = callback that throws");

	function getURL(s) {
	return s + this.bar;
	}

	var obj = {
	"bar": "#x"
	}

	async_test(t => {
	createURLTest( {
	createURL: getURL.bind(obj)},
	INPUTS.URL + "#x", t);
	}, "url = this bound to an object");

	var bar = "#x";
	async_test(t => {
	createURLTest( { createURL: s => getURL(s) }, INPUTS.URL + bar, t);
	}, "url = this without bind");

	async_test(t => {
	window.trustedTypes.createPolicy('SomeName', null)
	.then(t.step_func_done(p => {
	assert_equals(p.createURL(INPUTS.URL), null);
	}));
	}, "url - calling undefined callback");
	</script>