Import wpt@c5a14f553cba5f197743b9af605a84eddd8692a2

third_party/WebKit/LayoutTests/imported/wpt/custom-elements/reactions/resources/reactions.js

 
 let testNumber = 1;
 
 function testNodeConnector(testFunction, name) {
     let container = document.createElement('div');
     container.appendChild(document.createElement('div'));
     document.body.appendChild(container);
 
     test(function () {
         var element = define_new_custom_element();
@@ skipping 21 matching lines @@
     let container = document.createElement('div');
     container.appendChild(document.createElement('div'));
     document.body.appendChild(container);
  
     test(function () {
         var element = define_new_custom_element();
         var instance = document.createElement(element.name);
         assert_array_equals(element.takeLog().types(), ['constructed']);
         container.appendChild(instance);
         assert_array_equals(element.takeLog().types(), ['connected']);
-        testFunction(instance);
+        testFunction(instance, window);
         assert_array_equals(element.takeLog().types(), ['disconnected']);
     }, name + ' must enqueue a disconnected reaction');
 
     container.parentNode.removeChild(container);
 }
 
+function testInsertingMarkup(testFunction, name) {
+    let container = document.createElement('div');
+    container.appendChild(document.createElement('div'));
+    document.body.appendChild(container);
+
+    test(function () {
+        var element = define_new_custom_element();
+        testFunction(container, `<${element.name}></${element.name}>`);
+        assert_array_equals(element.takeLog().types(), ['constructed', 'connected']);
+    }, name + ' must enqueue a connected reaction for a newly constructed custom element');
+
+    test(function () {
+        var element = define_new_custom_element(['title']);
+        testFunction(container, `<${element.name} id="hello" title="hi"></${element.name}>`);
+        var logEntries = element.takeLog();
+        assert_array_equals(logEntries.types(), ['constructed', 'attributeChanged', 'connected']);
+        assert_attribute_log_entry(logEntries[1], {name: 'title', oldValue: null, newValue: 'hi', namespace: null});
+    }, name + ' must enqueue a attributeChanged reaction for a newly constructed custom element');
+
+    container.parentNode.removeChild(container);
+}
+
+function testParsingMarkup(testFunction, name) {
+    test(function () {
+        var element = define_new_custom_element(['id']);
+        assert_array_equals(element.takeLog().types(), []);
+        var instance = testFunction(document, `<${element.name} id="hello" class="foo"></${element.name}>`);
+        assert_equals(Object.getPrototypeOf(instance.querySelector(element.name)), element.class.prototype);
+        var logEntries = element.takeLog();
+        assert_array_equals(logEntries.types(), ['constructed', 'attributeChanged']);
+        assert_attribute_log_entry(logEntries[1], {name: 'id', oldValue: null, newValue: 'hello', namespace: null});
+    }, name + ' must construct a custom element');
+}
+
 function testCloner(testFunction, name) {
     let container = document.createElement('div');
     container.appendChild(document.createElement('div'));
     document.body.appendChild(container);
 
     test(function () {
         var element = define_new_custom_element(['id']);
         var instance = document.createElement(element.name);
         container.appendChild(instance);
 
@@ skipping 26 matching lines @@
         instance.setAttribute('title', 'hello world');
         assert_array_equals(element.takeLog().types(), ['constructed', 'connected', 'attributeChanged', 'attributeChanged']);
         var newInstance = testFunction(instance);
         var logEntries = element.takeLog();
         assert_array_equals(logEntries.types(), ['constructed', 'attributeChanged', 'attributeChanged']);
         assert_attribute_log_entry(logEntries[1], {name: 'class', oldValue: null, newValue: 'foo', namespace: null});
         assert_attribute_log_entry(logEntries[2], {name: 'title', oldValue: null, newValue: 'hello world', namespace: null});
     }, name + ' must enqueue an attributeChanged reaction when cloning an element only for observed attributes');
 }
 
-function testReflectAttribute(jsAttributeName, contentAttributeName, validValue1, validValue2, name) {
+function testReflectAttributeWithContentValues(jsAttributeName, contentAttributeName, validValue1, contentValue1, validValue2, contentValue2, name) {
     test(function () {
         var element = define_new_custom_element([contentAttributeName]);
         var instance = document.createElement(element.name);
         assert_array_equals(element.takeLog().types(), ['constructed']);
         instance[jsAttributeName] = validValue1;
         var logEntries = element.takeLog();
         assert_array_equals(logEntries.types(), ['attributeChanged']);
-        assert_attribute_log_entry(logEntries.last(), {name: contentAttributeName, oldValue: null, newValue: validValue1, namespace: null});
+
+        assert_attribute_log_entry(logEntries.last(), {name: contentAttributeName, oldValue: null, newValue: contentValue1, namespace: null});
     }, name + ' must enqueue an attributeChanged reaction when adding ' + contentAttributeName + ' content attribute');
 
     test(function () {
         var element = define_new_custom_element([contentAttributeName]);
         var instance = document.createElement(element.name);
         instance[jsAttributeName] = validValue1;
         assert_array_equals(element.takeLog().types(), ['constructed', 'attributeChanged']);
         instance[jsAttributeName] = validValue2;
         var logEntries = element.takeLog();
         assert_array_equals(logEntries.types(), ['attributeChanged']);
-        assert_attribute_log_entry(logEntries.last(), {name: contentAttributeName, oldValue: validValue1, newValue: validValue2, namespace: null});
+        assert_attribute_log_entry(logEntries.last(), {name: contentAttributeName, oldValue: contentValue1, newValue: contentValue2, namespace: null});
     }, name + ' must enqueue an attributeChanged reaction when replacing an existing attribute');
 }
 
+function testReflectAttribute(jsAttributeName, contentAttributeName, validValue1, validValue2, name) {
+    testReflectAttributeWithContentValues(jsAttributeName, contentAttributeName, validValue1, validValue1, validValue2, validValue2, name);
+}
+
+function testReflectBooleanAttribute(jsAttributeName, contentAttributeName, name) {
+    testReflectAttributeWithContentValues(jsAttributeName, contentAttributeName, true, '', false, null, name);
+}
+
 function testAttributeAdder(testFunction, name) {
     test(function () {
         var element = define_new_custom_element(['id']);
         var instance = document.createElement(element.name);
         assert_array_equals(element.takeLog().types(), ['constructed']);
         testFunction(instance, 'id', 'foo');
         var logEntries = element.takeLog();
         assert_array_equals(logEntries.types(), ['attributeChanged']);
         assert_attribute_log_entry(logEntries.last(), {name: 'id', oldValue: null, newValue: 'foo', namespace: null});
     }, name + ' must enqueue an attributeChanged reaction when adding an attribute');
@@ skipping 42 matching lines @@
     test(function () {
         var element = define_new_custom_element(['class']);
         var instance = document.createElement(element.name);
         instance.setAttribute('data-lang', 'zh');
         assert_array_equals(element.takeLog().types(), ['constructed']);
         testFunction(instance, 'data-lang', 'en');
         assert_array_equals(element.takeLog().types(), []);
     }, name + ' must not enqueue an attributeChanged reaction when replacing an existing unobserved attribute');
 }
 
-function testAttributeRemover(testFunction, name) {
-    test(function () {
-        var element = define_new_custom_element(['title']);
-        var instance = document.createElement(element.name);
-        assert_array_equals(element.takeLog().types(), ['constructed']);
-        testFunction(instance, 'title');
-        assert_array_equals(element.takeLog().types(), []);
-    }, name + ' must not enqueue an attributeChanged reaction when removing an attribute that does not exist');
+function testAttributeRemover(testFunction, name, options) {
+    if (options && !options.onlyExistingAttribute) {
+        test(function () {
+            var element = define_new_custom_element(['title']);
+            var instance = document.createElement(element.name);
+            assert_array_equals(element.takeLog().types(), ['constructed']);
+            testFunction(instance, 'title');
+            assert_array_equals(element.takeLog().types(), []);
+        }, name + ' must not enqueue an attributeChanged reaction when removing an attribute that does not exist');
+    }
 
     test(function () {
         var element = define_new_custom_element([]);
         var instance = document.createElement(element.name);
         instance.setAttribute('data-lang', 'hello');
         assert_array_equals(element.takeLog().types(), ['constructed']);
         testFunction(instance, 'data-lang');
         assert_array_equals(element.takeLog().types(), []);
     }, name + ' must not enqueue an attributeChanged reaction when removing an unobserved attribute');
 
@@ skipping 10 matching lines @@
 
     test(function () {
         var element = define_new_custom_element([]);
         var instance = document.createElement(element.name);
         instance.setAttribute('data-lang', 'ja');
         assert_array_equals(element.takeLog().types(), ['constructed']);
         testFunction(instance, 'data-lang');
         assert_array_equals(element.takeLog().types(), []);
     }, name + ' must not enqueue an attributeChanged reaction when removing an existing unobserved attribute');
 }