tor-browser

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

Document-createElement-customized-builtins.html (4399B)

      1 <!DOCTYPE html>
      2 <html>
      3 <head>
      4 <title>Custom Elements: document.createElement should create a customized builtin element with synchronous custom elements flag set</title>
      5 <script src="/resources/testharness.js"></script>
      6 <script src="/resources/testharnessreport.js"></script>
      7 <script src="resources/custom-elements-helpers.js"></script>
      8 </head>
      9 <body>
     10 <div id="log"></div>
     11 <script>
     12 setup({allow_uncaught_exception:true});
     13 
     14 function assert_reports(expected, testFunction, message) {
     15    var uncaughtError = null;
     16    window.onerror = function (message, url, lineNumber, columnNumber, error) { uncaughtError = error; return true; }
     17    testFunction();
     18    if (typeof(expected) == 'string')
     19        assert_equals(uncaughtError, expected, message);
     20    else if (expected && 'name' in expected)
     21        assert_equals(uncaughtError.name, expected.name, message);
     22    else
     23      assert_equals(uncaughtError, expected, message);
     24    window.onerror = null;
     25 }
     26 
     27 test(function () {
     28    class AutonomousCustomElement extends HTMLElement {};
     29    class IsCustomElement extends HTMLElement {};
     30 
     31    customElements.define('autonomous-custom-element', AutonomousCustomElement);
     32    customElements.define('is-custom-element', IsCustomElement);
     33 
     34    var instance = document.createElement('autonomous-custom-element', { is: 'is-custom-element'});
     35 
     36    assert_true(instance instanceof AutonomousCustomElement);
     37    assert_equals(instance.localName, 'autonomous-custom-element');
     38    assert_equals(instance.namespaceURI, 'http://www.w3.org/1999/xhtml', 'A custom element HTML must use HTML namespace');
     39 
     40    var instance2 = document.createElement('undefined-element', { is: 'is-custom-element'});
     41    assert_false(instance2.matches(':defined'));
     42    class DefinedLater extends HTMLElement {}
     43    customElements.define('undefined-element', DefinedLater);
     44    document.body.appendChild(instance2);
     45    assert_true(instance2 instanceof DefinedLater);
     46 }, 'document.createElement must create an instance of autonomous custom elements when it has is attribute');
     47 
     48 test(() => {
     49    class SuperP extends HTMLParagraphElement {}
     50    customElements.define("super-p", SuperP, { extends: "p" });
     51 
     52    const superP = document.createElement("p", { is: "super-p" });
     53    assert_true(superP instanceof HTMLParagraphElement);
     54    assert_true(superP instanceof SuperP);
     55    assert_equals(superP.localName, "p");
     56 
     57    const notSuperP = document.createElement("p", "super-p");
     58    assert_true(notSuperP instanceof HTMLParagraphElement);
     59    assert_false(notSuperP instanceof SuperP);
     60    assert_equals(notSuperP.localName, "p");
     61 }, "document.createElement()'s second argument is to be ignored when it's a string");
     62 
     63 test(function () {
     64    var exceptionToThrow = {name: 'exception thrown by a custom constructor'};
     65    class ThrowCustomBuiltinElement extends HTMLDivElement {
     66        constructor()
     67        {
     68            super();
     69            if (exceptionToThrow)
     70                throw exceptionToThrow;
     71        }
     72    };
     73    customElements.define('throw-custom-builtin-element', ThrowCustomBuiltinElement, { extends: 'div' });
     74 
     75    assert_throws_exactly(exceptionToThrow, function () { new ThrowCustomBuiltinElement; });
     76    var instance;
     77    assert_reports(exceptionToThrow, function () { instance = document.createElement('div', { is: 'throw-custom-builtin-element' }); });
     78    assert_equals(instance.localName, 'div');
     79    assert_true(instance instanceof HTMLDivElement);
     80 
     81    exceptionToThrow = false;
     82    var instance = document.createElement('div', { is: 'throw-custom-builtin-element' });
     83    assert_true(instance instanceof ThrowCustomBuiltinElement);
     84    assert_equals(instance.localName, 'div');
     85 
     86 }, 'document.createElement must report an exception thrown by a custom built-in element constructor');
     87 
     88 test(() => {
     89  class MyElement extends HTMLDivElement {}
     90 
     91  // createElement with unknown 'is' should not throw.
     92  // https://github.com/w3c/webcomponents/issues/608
     93  let div = document.createElement('div', { is: 'my-div' });
     94  assert_false(div instanceof MyElement);
     95  assert_false(div.hasAttribute('is'));
     96 
     97  customElements.define('my-div', MyElement, { extends: 'div' });
     98  document.body.appendChild(div);
     99  assert_true(div instanceof MyElement, 'Undefined element is upgraded on connecting to a document');
    100 }, 'document.createElement with unknown "is" value should create "undefined" state element');
    101 
    102 </script>
    103 </body>
    104 </html>