├── w3c.json
├── CODE_OF_CONDUCT.md
├── README.md
├── timelines
    ├── WebIDL.md
    └── HTML.md
├── meetings
    ├── 17-TPAC.md
    ├── 15-12-15-ShadowDOM.md
    ├── 17-03HTML.md
    ├── 16-09-20TPAC-2.md
    ├── 16-05-10-11HTML.md
    ├── 18-06-html.md
    ├── 16-07-28-29SW.md
    └── 18-03-Web-components.md
├── css
    └── pubstatus.css
├── implementations
    └── webidl-1
    │   ├── tests
    │       ├── byte-002.html
    │       ├── octet-002.html
    │       ├── short-002.html
    │       ├── constant-002.html
    │       ├── Global-005.html
    │       ├── exception-001.html
    │       ├── callback-function-type-003.html
    │       ├── exception-object-001.html
    │       ├── void-001.html
    │       ├── boolean-002.html
    │       ├── unrestricted-float-002.html
    │       ├── nullable-003.html
    │       ├── double-003.html
    │       ├── DOMString-003.html
    │       ├── legacy-caller-001.html
    │       ├── unrestricted-double-004.html
    │       ├── NoInterfaceObject-001.html
    │       ├── EnforceRange-001.html
    │       ├── interface-object-002.html
    │       ├── Unforgeable-001.html
    │       ├── constant-003.html
    │       ├── Global-006.html
    │       ├── USVString-001.html
    │       ├── long-003.html
    │       ├── TreatNullAs-002.html
    │       ├── interface-type-004.html
    │       ├── unsigned-short-003.html
    │       ├── stringifier-001.html
    │       ├── Constructor-002.html
    │       ├── ByteString-001.html
    │       ├── exception-interface-prototype-object-001.html
    │       ├── unsigned-long-003.html
    │       ├── unrestricted-double-003.html
    │       ├── float-003.html
    │       ├── exception-interface-object-001.html
    │       ├── sequence-001.html
    │       ├── interface-001.html
    │       ├── Global-001.html
    │       ├── any-001.html
    │       ├── boolean-001.html
    │       ├── platform-object-001.html
    │       ├── implements-001.html
    │       ├── constant-001.html
    │       ├── Global-004.html
    │       ├── TreatNullAs-001.html
    │       ├── interface-object-001.html
    │       ├── interface-prototype-object-001.html
    │       ├── TreatNonCallableAsNull-001.html
    │       ├── Clamp-001.html
    │       ├── exception-field-001.html
    │       ├── stringifier-002.html
    │       ├── Global-002.html
    │       ├── dictionary-type-002.html
    │       ├── indexed-properties-001.html
    │       ├── named-properties-005.html
    │       ├── Constructor-004.html
    │       ├── named-properties-001.html
    │       ├── Replaceable-001.html
    │       ├── Constructor-001.html
    │       ├── operation-001.html
    │       ├── Constructor-003.html
    │       ├── instanceof-001.html
    │       ├── utils.js
    │       ├── NamedConstructor-001.html
    │       ├── interface-type-001.html
    │       ├── callback-function-type-002.html
    │       ├── enum-type-001.html
    │       ├── indexed-properties-002.html
    │       ├── interface-type-002.html
    │       ├── exception-interface-object-002.html
    │       ├── LenientThis-001.html
    │       ├── callback-function-type-001.html
    │       ├── nullable-001.html
    │       ├── attribute-003.html
    │       ├── operation-003.html
    │       ├── attribute-002.html
    │       ├── throwing-001.html
    │       ├── nullable-002.html
    │       ├── attribute-005.html
    │       ├── byte-001.html
    │       ├── attribute-004.html
    │       ├── octet-001.html
    │       ├── short-001.html
    │       ├── attribute-006.html
    │       ├── property-enumeration-001.html
    │       ├── unsigned-short-001.html
    │       ├── long-001.html
    │       ├── long-002.html
    │       ├── unsigned-long-002.html
    │       ├── unsigned-long-001.html
    │       └── PutForwards-001.html
    │   └── report
    │       ├── analysis.css
    │       └── sticky-headers.js
├── js
    └── newsfeed.js
├── Newbie.md
└── Coordination.md


/w3c.json:
--------------------------------------------------------------------------------
1 | {
2 |   "group": 83482,
3 |   "contacts": ["siusin"],
4 |   "policy": "open",
5 |   "repo-type": "homepage"
6 | }


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | # Code of Conduct
2 | 
3 | All documentation, code and communication under this repository are covered by the [W3C Code of Ethics and Professional Conduct](https://www.w3.org/Consortium/cepc/).
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Web Platform Working Group (CLOSED)
2 | The Web Platform WG's charter expired March 31 2019. It been superceded by the new [Web Apps Working Group](http://github.com/w3c/WebAppsWG). This repository has been archived for historical purposes and is no longer maitained.
3 | 


--------------------------------------------------------------------------------
/timelines/WebIDL.md:
--------------------------------------------------------------------------------
 1 | # WebIDL-1 Timeline
 2 | 
 3 | * July 29, 2016     : PR Transition Request
 4 | * August 9, 2016    : PR published
 5 | * September 1, 2016 : PR review ends
 6 | * September 15, 2016: REC published
 7 | 
 8 | In the meantime:
 9 | WebIDL moved to bikeshed (Google)
10 | automatic publishing as WDs in /TR/WebIDL/
11 | 


--------------------------------------------------------------------------------
/meetings/17-TPAC.md:
--------------------------------------------------------------------------------
1 | ## TPAC 2017
2 | 
3 | * Tuesday 7 November: [Editing APIs TF meeting](https://github.com/w3c/WebPlatformWG/issues/93)
4 | * Thursday 9 November: [General Web Platform (HTML, assorted APIs, DOM, ...)](https://github.com/w3c/WebPlatformWG/issues/94)
5 | * Friday 10 November: [Web Components](https://github.com/w3c/webcomponents/issues/641)
6 | 


--------------------------------------------------------------------------------
/css/pubstatus.css:
--------------------------------------------------------------------------------
 1 | main {
 2 |     width: 90%;
 3 | }
 4 | 
 5 | table {
 6 |     width: 100%;
 7 |     border-collapse: collapse;
 8 |     margin-top: 1em;
 9 |     margin-bottom: 2em;
10 |     /table-layout: fixed;
11 | }
12 | 
13 | th, td {
14 |   border: 1px solid black;
15 |   padding: 0.5em;
16 | }
17 | 
18 | th {
19 |     line-height: 1;
20 |     background: #005A9C;
21 |     color: #fff;
22 | }
23 | 
24 | td ul {
25 |     margin: 0;
26 |     padding: 0;
27 |     list-style-position: inside;
28 | list-style-type: none;
29 | }
30 | 


--------------------------------------------------------------------------------
/meetings/15-12-15-ShadowDOM.md:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |  <head>
 4 |   <meta charset="utf-8">
 5 |   <title>15 December 2015 Shadow DOM meeting</title>
 6 |  </head>
 7 |  <body>
 8 |   <p>Shadow DOM meeting - <em>proposed</em> 15 december 2015</p>
 9 | <h1>There will be no Shadow DOM meeting in December 2015</h1>
10 |   <p>This meeting was <em>proposed</em>, for the US West Coast - either Seattle or the Bay Area. We are looking for a host (requirements: A room that can hold about 20 people, coffee/tea/snacks, somewhere we can have lunch, wifi).</p>
11 | 
12 |  </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/byte-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>byte</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.4 byte
10 | //
11 | // IDL byte values are represented as integer JS Number values in the range
12 | // [-128, 127]
13 | 
14 | // feature: Int8Array (indexed property getter) (of type byte)
15 | 
16 | test(function() {
17 |   var a = new Int8Array(1);
18 |   assert_equals(typeof a[0], "number");
19 |   assert_true(a[0] == Math.floor(a[0]) && a[0] >= -128 && a[0] <= 127);
20 | }, "Int8Array indexed getter returns a value of the correct type");
21 | </script>
22 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/octet-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>octet</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.5 octet
10 | //
11 | // IDL octet values are represented as integer JS Number values in the range
12 | // [0, 255].
13 | 
14 | // feature: Uint8Array (indexed property getter) (of type octet)
15 | 
16 | test(function() {
17 |   var a = new Uint8Array(1);
18 |   assert_equals(typeof a[0], "number");
19 |   assert_true(a[0] == Math.floor(a[0]) && a[0] >= 0 && a[0] <= 255);
20 | }, "Int8Array indexed getter returns a value of the correct type");
21 | </script>
22 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/short-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>short</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.6 short
10 | //
11 | // IDL short values are represented as integer JS Number values in the range
12 | // [-32768, 32767].
13 | 
14 | // feature: Int16Array (indexed property getter) (of type short)
15 | 
16 | test(function() {
17 |   var a = new Int16Array(1);
18 |   assert_equals(typeof a[0], "number");
19 |   assert_true(a[0] == Math.floor(a[0]) && a[0] >= -32768 && a[0] <= 32767);
20 | }, "Int16Array indexed getter returns a value of the correct type");
21 | </script>
22 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/constant-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Constants on callback interfaces</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.5 Constants
10 | //
11 | // Constants on callback interfaces are exposed as non-writable, enumerable,
12 | // non-configurable properties on the interface object.
13 | 
14 | // feature: NodeFilter.SHOW_ALL (constant) (on a callback interface)
15 | 
16 | test(function() {
17 |   assert_property(NodeFilter, "SHOW_ALL", { writable: false, enumerable: true, configurable: false, value: 0xFFFFFFFF });
18 | }, "NodeFilter.SHOW_ALL has correct attributes and value");
19 | </script>
20 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Global-005.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Named properties object [[DefineOwnProperty]]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.4.2 Named properties object [[DefineOwnProperty]] method
10 | //
11 | // Named properties objects cannot have expando properties.
12 | 
13 | // feature: Window (interface) (with [Global])
14 | 
15 | test(function() {
16 |   var namedPropertiesObject = Object.getPrototypeOf(Window.prototype);
17 |   namedPropertiesObject.expando1 = 1;
18 |   assert_equals(window.expando1, undefined);
19 | }, "expando properties cannot be set on the named properties object");
20 | </script>
21 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/exception-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Exception interface object property</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.9 Exceptions
10 | //
11 | // For each interface object that isn't [NoInterfaceObject], there's a property
12 | // on the global object that is writable, unenumerable and configurable.
13 | 
14 | // feature: DOMException (exception) (without [NoInterfaceObject])
15 | 
16 | test(function() {
17 |   assert_property(window, "DOMException", { writable: true, enumerable: false, configurable: true });
18 | }, "property for DOMException exception interface object exists");
19 | </script>
20 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/callback-function-type-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Callback function types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.21 Callback function types
10 | //
11 | // IDL callback function types are represented as JS object references to
12 | // a callable object.
13 | 
14 | // feature: GlobalEventHandlers.onclick (attribute) (of a callback function type)
15 | 
16 | test(function() {
17 |   var e = document.createElement("span");
18 |   e.onclick = function() { };
19 |   assert_equals(typeof e.onclick, "function");
20 | }, "GlobalEventHandlers.onclick returns a value of the correct type");
21 | </script>
22 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/exception-object-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Exception objects</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.10 Exception objects
10 | //
11 | // The [[Prototype]] of a platform object representing an exception is the
12 | // exception interface prototype object.
13 | 
14 | // feature: DOMException (exception)
15 | 
16 | test(function() {
17 |   var exception;
18 |   try {
19 |     document.appendChild(document);
20 |   } catch (e) {
21 |     exception = e;
22 |   }
23 |   assert_equals(Object.getPrototypeOf(exception), DOMException.prototype);
24 | }, "[[Prototype]] of a DOMException object is correct");
25 | </script>
26 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/void-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>void</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.2 void
10 | //
11 | // Operations defined with a return type of void return undefined.
12 | 
13 | // feature: HTMLElement.click (operation) (with return type void)
14 | 
15 | test(function() {
16 |   assert_equals(document.documentElement.click(), undefined);
17 | }, "HTMLElement.click() returns undefined");
18 | 
19 | // feature: HTMSelectLElement.add (operation) (with return type void)
20 | 
21 | test(function() {
22 |   assert_equals(document.createElement("select").add(document.createElement("option")), undefined);
23 | }, "HTMLSelectElement.add() returns undefined");
24 | </script>
25 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/boolean-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>boolean</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.3 boolean
10 | //
11 | // IDL boolean values are represented as JS Boolean values.
12 | 
13 | // feature: Event.bubbles (attribute) (of type boolean)
14 | 
15 | test(function() {
16 |   var e = document.createEvent("Event");
17 |   assert_equals(typeof e.bubbles, "boolean");
18 | }, "Event.bubbles returns a value of the correct type");
19 | 
20 | // feature: Document.hasFocus (operation) (with return type boolean)
21 | 
22 | test(function() {
23 |   assert_equals(typeof document.hasFocus(), "boolean");
24 | }, "Document.hasFocus() returns a value of the correct type");
25 | </script>
26 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unrestricted-float-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>unrestricted float</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.13 unrestricted float
10 | //
11 | // IDL unrestricted float values are represented with JS Number values, although
12 | // for the finite values, only values that correspond to a single precision
13 | // value.
14 | 
15 | // feature: Float32Array (indexed property getter) (of type unrestricted float)
16 | 
17 | test(function() {
18 |   var a = new Float32Array(1);
19 |   a[0] = 1.1;
20 |   assert_equals(typeof a[0], "number");
21 |   assert_equals(a[0], 1.100000023841858);
22 | }, "Float32Array indexed getter returns a value of the correct type");
23 | </script>
24 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/nullable-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Nullable types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <span id="span"></span>
 9 | 
10 | <script>
11 | // 4.2.22 Nullable types – T?
12 | //
13 | // IDL nullable types are represented as the JS null value, if the IDL
14 | // value is null, or of a type appropriate for the inner type otherwise.
15 | 
16 | // feature: Document.getElementById (operation) (with a nullable return type)
17 | 
18 | test(function() {
19 |   var e = document.getElementById("span");
20 |   assert_equals(typeof e, "object");
21 |   e = document.getElementById("missing");
22 |   assert_equals(typeof e, "object");
23 | }, "Document.getElementById() returns a value of the correct type");
24 | </script>
25 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/double-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>double</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.14 double
10 | //
11 | // IDL double values are represented with finite JS Number values.
12 | 
13 | // feature: HTMLProgressElement.value (attribute) (of type double)
14 | 
15 | test(function() {
16 |   var e = document.createElement("progress");
17 |   assert_equals(typeof e.value, "number");
18 |   assert_true(e.value * 0 == 0);
19 | }, "HTMLProgressElement.value returns a value of the correct type");
20 | 
21 | test(function() {
22 |   var e = document.createElement("meter");
23 |   assert_equals(typeof e.min, "number");
24 |   assert_true(e.min * 0 == 0);
25 | }, "HTMLMeterElement.min returns a value of the correct type");
26 | </script>
27 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/DOMString-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>DOMString</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.16 DOMString
10 | //
11 | // IDL DOMString values are represented with JS string values.
12 | 
13 | // feature: Attr.value (attribute) (of type DOMString)
14 | 
15 | test(function() {
16 |   var e = document.createElement("span");
17 |   e.setAttribute("data-test", "test");
18 |   var a = e.getAttributeNode("data-test");
19 |   assert_equals(typeof a.value, "string");
20 | }, "Attr.value returns a value of the correct type");
21 | 
22 | // feature: Node.nodeName (attribute) (of type DOMString)
23 | 
24 | test(function() {
25 |   assert_equals(typeof document.nodeName, "string");
26 | }, "Node.nodeName returns a value of the correct type");
27 | </script>
28 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/legacy-caller-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Legacy callers</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.7.5 Platform object [[Call]] method
10 | //
11 | // Objects that implement an interface that has a legacy caller have an
12 | // internal [[Call]] method that invokes the caller behavior.
13 | 
14 | // feature: HTMLObjectElement (interface) with legacy caller
15 | // feature: HTMLAllCollection (interface) with legacy caller
16 | 
17 | test(function() {
18 |   var object = document.createElement("object");
19 |   assert_equals(typeof object, "function");
20 | }, "typeof HTMLObjectElement is function");
21 | 
22 | test(function() {
23 |   var allCollection = document.all;
24 |   var elem = allCollection(2);
25 |   assert_true(elem instanceof HTMLTitleElement);
26 | }, "an HTMLAllCollection can be called");
27 | </script>
28 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unrestricted-double-004.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>unrestricted double</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.15 unrestricted double
10 | //
11 | // IDL unrestricted double values are represented with JS number values.
12 | 
13 | // feature: HTMLInputElement.number (attribute) (of type unrestricted double)
14 | 
15 | test(function() {
16 |   var e = document.createElement("input");
17 |   e.type = "number";
18 |   assert_equals(typeof e.valueAsNumber, "number");
19 | }, "HTMLInputElement.valueAsNumber returns a value of the correct type");
20 | 
21 | // feature: Float64Array (indexed property getter) (of type unrestricted double)
22 | 
23 | test(function() {
24 |   var a = new Float64Array(1);
25 |   assert_equals(typeof a[0], "number");
26 | }, "Float64Array indexed getter returns a value of the correct type");
27 | </script>
28 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/NoInterfaceObject-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[NoInterfaceObject]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5 Interfaces
10 | //
11 | // Interface objects don't exist for [NoInterfaceObject] interfaces.
12 | 
13 | // feature: WindowTimers (interface) (with [NoInterfaceObject])
14 | 
15 | test(function() {
16 |   assert_true(!!window.setTimeout, "!!window.setTimeout");
17 |   assert_true(!window.WindowTimers, "!window.WindowTimers");
18 | }, "WindowTimers is implemented but does not have an interface object");
19 | 
20 | // feature: NavigatorID (interface) (with [NoInterfaceObject])
21 | 
22 | test(function() {
23 |   assert_true(!!window.navigator.platform, "!!window.navigator.platform");
24 |   assert_true(!window.NavigatorID, "!window.NavigatorID");
25 | }, "NavigatorID is implemented but does not have an interface object");
26 | </script>
27 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/EnforceRange-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[EnforceRange]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.3.4 [EnforceRange]
10 | //
11 | // When converting a JS value to an IDL numeric type with [EnforceRange],
12 | // then out of range values will throw a TypeError rather than being
13 | // converted to a valid value.
14 | 
15 | // feature: IDBFactory.open (operation) (with [EnforceRange] on an argument)
16 | 
17 | var throwingValues = [NaN, Infinity, -Infinity, -1, Math.pow(2, 54)];
18 | 
19 | for (var i = 0; i < throwingValues.length; i++) {
20 |   var value = throwingValues[i];
21 |   test(function() {
22 |     indexedDB.deleteDatabase('EnforceRangeTest');
23 |     assert_throws(new TypeError(), function() { indexedDB.open('EnforceRangeTest', value); });
24 |   }, "passing " + value + " to IDBFactory.open() as the version argument throws a TypeError");
25 | }
26 | </script>
27 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/interface-object-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Interface object for a callback interface</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.1 Interface object
10 | //
11 | // The interface object for a callback interface (which exists due to their
12 | // being constants on the interface) does not have a "prototype" property,
13 | // and is not a function object.
14 | 
15 | // feature: NodeFilter (callback interface) (with constants)
16 | 
17 | test(function() {
18 |   assert_true(!NodeFilter.hasOwnProperty("prototype"));
19 | }, "window.NodeFilter does not have a \"prototype\" property");
20 | 
21 | test(function() {
22 |   assert_equals(Object.getPrototypeOf(NodeFilter), Object.prototype);
23 | }, "window.NodeFilter.[[Prototype]] is correct");
24 | 
25 | test(function() {
26 |   assert_equals(typeof window.NodeFilter, "object");
27 | }, "typeof window.NodeFilter is correct");
28 | </script>
29 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Unforgeable-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[Unforgeable] on attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.6 Attributes
10 | //
11 | // Attributes that are [Unforgeable] exist on the instance rather than on
12 | // the prototype.  They are unconfigurable.
13 | 
14 | // feature: Window.document (attribute) (with [Unforgeable])
15 | 
16 | test(function() {
17 |   assert_property(window, "document", { enumerable: true, configurable: false }, "window.document");
18 | }, "\"document\" is an own, enumerable, non-configurable property on window");
19 | 
20 | // feature: Event.isTrusted (attribute) (with [Unforgeable])
21 | 
22 | test(function() {
23 |   var e = document.createEvent("Event");
24 |   assert_property(e, "isTrusted", { enumerable: true, configurable: false }, "e.isTrusted");
25 | }, "\"isTrusted\" is an own, enumerable, non-configurable property on Event objects");
26 | </script>
27 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/constant-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Constants on exceptions</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.9.3 Constants
10 | //
11 | // Constants on callback interfaces are exposed as non-writable, enumerable,
12 | // non-configurable properties on the exception interface object and
13 | // exception interface prototype.
14 | 
15 | // feature: DOMException.INVALID_STATE_ERR (constant) (on an exception)
16 | 
17 | test(function() {
18 |   assert_property(DOMException, "INVALID_STATE_ERR", { writable: false, enumerable: true, configurable: false, value: 11 });
19 | }, "DOMException.INVALID_STATE_ERR has correct attributes and value");
20 | 
21 | test(function() {
22 |   assert_property(DOMException.prototype, "INVALID_STATE_ERR", { writable: false, enumerable: true, configurable: false, value: 11 });
23 | }, "DOMException.prototype.INVALID_STATE_ERR has correct attributes and value");
24 | </script>
25 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Global-006.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Named properties object [[DefineOwnProperty]]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <form id="f1" name="f1"></form>
10 |   <form id="f2" name="f2"></form>
11 | </div>
12 | 
13 | <script>
14 | // 4.5.4.3 Named properties object [[Delete]] method
15 | //
16 | // Named properties exposed on a named properties object cannot be removed.
17 | 
18 | // feature: Window (interface) (with [Global])
19 | 
20 | test(function() {
21 |   var namedPropertiesObject = Object.getPrototypeOf(Window.prototype);
22 |   assert_equals(namedPropertiesObject.f1, document.getElementById("f1"));
23 |   delete namedPropertiesObject.f1;
24 |   assert_equals(namedPropertiesObject.f1, document.getElementById("f1"));
25 | }, "named properties cannot be deleted from the named properties object");
26 | </script>
27 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/USVString-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <head>
 3 | <meta charset="utf-8">
 4 | <title>USVString</title>
 5 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 6 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 7 | <script src="utils.js"></script>
 8 | </head>
 9 | <div id="log"></div>
10 | 
11 | <script>
12 | // 4.2.18 USVString
13 | 
14 | // Features URL.path
15 | 
16 | var input = "https://www.example.com/~foo";
17 | var testurl = new URL(input);
18 | 
19 | var path_input_tab =  [ "/bar", "/小"       , "/\ud800\udc00", "/\ud800\ue000"      , "/\ud800\uda00"      , "/\udc00"   , "/\ud800"    ];
20 | var path_result_tab = [ "/bar", "/%E5%B0%8F", "/%F0%90%80%80", "/%EF%BF%BD%EE%80%80", "/%EF%BF%BD%EF%BF%BD", "/%EF%BF%BD", "/%EF%BF%BD" ];
21 | 
22 | for ( var i = 0; i < path_input_tab.length; i++) {
23 |     var input = path_input_tab[i];
24 |     var result = path_result_tab[i];
25 |     test(function() {
26 |       testurl.pathname = input;
27 |       assert_equals(testurl.pathname, result);
28 |       }, "URL.pathname convert String "+input+" to USVString properly: "+result);
29 | }
30 | </script>
31 | 
32 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/long-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>long</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.8 long
10 | //
11 | // IDL long values are represented as integer JS Number values in the
12 | // range [-2147483648, 2147483647].
13 | 
14 | // feature: HTMLPreElement.width (attribute) (of type long)
15 | 
16 | test(function() {
17 |   var e = document.createElement("pre");
18 |   assert_equals(typeof e.width, "number");
19 |   assert_true(e.width == Math.floor(e.width) && e.width >= -2147483648 && e.width <= 2147483647);
20 | }, "HTMLPreElement.width returns a value of the correct type");
21 | 
22 | // feature: HTMLElement.tabIndex (attribute) (of type long)
23 | 
24 | test(function() {
25 |   var e = document.createElement("span");
26 |   assert_equals(typeof e.tabIndex, "number");
27 |   assert_true(e.tabIndex == Math.floor(e.tabIndex) && e.tabIndex >= -2147483648 && e.tabIndex <= 2147483647);
28 | }, "HTMLElement.tabIndex returns a value of the correct type");
29 | </script>
30 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/TreatNullAs-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[TreatNullAs] on operation arguments</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.16 DOMString
10 | //
11 | // Passing null to an operation argument of type DOMString will bye default
12 | // convert null to "null".  If [TreatNullAs=EmptyString] is on the argument,
13 | // null will be converted to "" instead.
14 | 
15 | // feature: DOMImplementation.createDocument (operation) (with [TreatNullAs=EmptyString] on an argument)
16 | 
17 | test(function() {
18 |   var doc;
19 |   doc = document.implementation.createDocument(null, "test", null);
20 |   assert_true(!!doc.firstChild);
21 |   doc = document.implementation.createDocument(null, "", null);
22 |   assert_true(!doc.firstChild);
23 |   doc = document.implementation.createDocument(null, null, null);
24 |   assert_true(!doc.firstChild);
25 | }, "passing null to the qualifiedName argument of DOMImplementation.createDocument does not create a document element");
26 | </script>
27 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/interface-type-004.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Interface types for regular interfaces</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.18 Interface type
10 | //
11 | // IDL values of an interface type are represented with JS object references
12 | // to platform objects that implement the interface.
13 | 
14 | // feature: Node.parentNode (attribute) (of an interface type)
15 | 
16 | test(function() {
17 |   var n = document.body.parentNode;
18 |   assert_equals(typeof n, "object");
19 |   assert_true(n instanceof Node);
20 | }, "Node.parentNode returns a value of the correct type");
21 | 
22 | // feature: SVGSVGElement.createSVGPoint (operation) (with interface type return type)
23 | 
24 | test(function() {
25 |   var p = document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGPoint();
26 |   assert_equals(typeof p, "object");
27 |   assert_true(p instanceof SVGPoint);
28 | }, "SVGSVGElement.createSVGPoint() returns a value of the correct type");
29 | </script>
30 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unsigned-short-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>short</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.7 unsigned short
10 | //
11 | // IDL unsigned short values are represented as integer JS Number values in the
12 | // range [0, 65536].
13 | 
14 | // feature: CloseEvent.code (attribute) (of type unsigned short)
15 | 
16 | test(function() {
17 |   var event = new CloseEvent("test");
18 |   assert_equals(typeof event.code, "number");
19 |   assert_true(event.code == Math.floor(event.code) && event.code >= 0 && event.code <= 65535);
20 | }, "CloseEvent.code returns a value of the correct type");
21 | 
22 | // feature: WebSocket.readyState (attribute) (of type unsigned short)
23 | 
24 | test(function() {
25 |   var ws = new WebSocket("wss://test.invalid");
26 |   assert_equals(typeof ws.readyState, "number");
27 |   assert_true(ws.readyState == Math.floor(ws.readyState) && ws.readyState >= 0 && ws.readyState <= 65535);
28 | }, "WebSocket.readyState returns a value of the correct type");
29 | </script>
30 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/stringifier-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Stringifiers</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.7 Operations
10 | //
11 | // Stringifiers correspond to a "toString" property on the interface prototype
12 | // object.  The property is writable, enumerable and configurable.  The Function
13 | // object value has length = 0.
14 | 
15 | var stringifiers = [
16 | 
17 |   // feature: URLUtils (stringifier)
18 |   "HTMLAnchorElement",
19 | 
20 |   // feature: DOMTokenList (stringifier)
21 |   "DOMTokenList"
22 | ];
23 | 
24 | for (var i = 0; i < stringifiers.length; i++) {
25 |   var name = stringifiers[i];
26 |   test(function() {
27 |     assert_property(window[name].prototype, "toString", { writable: true, enumerable: true, configurable: true });
28 |   }, name + ".prototype.toString property has correct attributes");
29 |   test(function() {
30 |     assert_equals(window[name].prototype.toString.length, 0);
31 |   }, name + ".prototype.toString has correct length property");
32 | }
33 | </script>
34 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Constructor-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Invoking constructors without overloading or optional arguments</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.1.1 Interface object [[Call]] method
10 | //
11 | // In this test we're invoking simple constructors -- ones that do not use
12 | // overloading or optional arguments.  When too few arguments are passed,
13 | // a TypeError is thrown.  When too many arguments are passed, the extra
14 | // ones are ignored.  Argument types are not used to eliminate the single
15 | // entry in the effective overload set.
16 | 
17 | // feature: Worker 
18 | 
19 | test(function() {
20 |   assert_throws(new TypeError(), function() { new Worker(); });
21 | }, "passing too few arguments to Worker constructor throws");
22 | 
23 | // feature: Range (interface) (with [Constructor], and no overloading or optional arguments)
24 | test(function() {
25 |   var range = new Range("test");
26 |   assert_true(!!range);
27 | }, "additional arguments passed to Range constructor are ignored");
28 | 
29 | </script>
30 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/report/analysis.css:
--------------------------------------------------------------------------------
 1 | 
 2 | th {
 3 |     text-align: left;
 4 |     background: #4a89dc;
 5 |     color:      #fff;
 6 | }
 7 | 
 8 | td.FAIL {
 9 |     background: #da4453;
10 |     color:      #fff;
11 | }
12 | 
13 | td.PASS {
14 |     background: #37bc9b;
15 |     color:      #fff;
16 | }
17 | 
18 | td.NOTRUN, td.TIMEOUT, td.undefined {
19 |     background: #f6bb42;
20 |     color:  #fff;
21 | }
22 | 
23 | table > tbody > tr > td.NOTRUN, table > tbody > tr > td.TIMEOUT {
24 |     padding:    8px 2px;
25 | }
26 | 
27 | td.OK {
28 |     color:  transparent;
29 | }
30 | 
31 | td.FAIL, td.PASS, td.NOTRUN, td.TIMEOUT, td.undefined, td.OK {
32 |     font-size:  0.7em;
33 |     text-align: center;
34 | }
35 | 
36 | tr.test {
37 |     background: #ccd1d9;
38 | }
39 | 
40 | tr.test > td:first-of-type {
41 |     font-weight:    bold;
42 | }
43 | 
44 | tr.test small {
45 |     font-weight:    normal;
46 | }
47 | 
48 | tr.subtest > td:first-of-type {
49 |     padding-left:   2em;
50 |     max-width:  790px;
51 |     overflow:   hidden;
52 |     text-overflow:  ellipsis;
53 |     white-space:    nowrap;
54 | }
55 | 
56 | .floatingHeader {
57 |     position: fixed;
58 |     top: 0;
59 |     visibility: hidden;
60 | }
61 | 
62 | dd {
63 |     padding-left:   2em;
64 | }
65 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/ByteString-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <head>
 3 | <meta charset="utf-8">
 4 | <title>ByteString</title>
 5 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 6 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 7 | <script src="utils.js"></script>
 8 | </head>
 9 | <div id="log"></div>
10 | 
11 | <script>
12 | // 4.2.17 ByteString
13 | 
14 | // Features XHR.setRequestHeader
15 | 
16 | var client = new XMLHttpRequest();
17 | client.open('GET', '/glop');
18 | 
19 | var path_input_tab =  [ "bar", "foo bar" ];
20 | var path_error_tab = [  "小"  ];
21 | 
22 | for ( var i = 0; i < path_input_tab.length; i++) {
23 |     var input = path_input_tab[i];
24 |     test(function() {
25 |       client.setRequestHeader("X-ByteString", input);
26 |       assert_equals(client.setRequestHeader("X-ByteString", input), undefined);
27 |       }, "XHR.setRequestHeader convert String "+input+" to ByteString properly");
28 | }
29 | 
30 | for ( var i = 0; i < path_error_tab.length; i++) {
31 |     var input = path_error_tab[i];
32 |     test(function() {
33 |       assert_throws(new TypeError(), client.setRequestHeader("X-ByteString", input));
34 |       }, "XHR.setRequestHeader should throw on "+input);
35 | }
36 | </script>
37 | 
38 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/exception-interface-prototype-object-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Exception interface prototype object</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.9.2 Exception interface prototype object
10 | //
11 | // The [[Prototype]] of an exception interface prototype object is
12 | // Error.prototype, if the exception is not declared to inherit from
13 | // another.  The exception interface prototype object has a
14 | // "name" property set to the identifier of the exception.  It also
15 | // has a "constructor" property pointing to the exception interface
16 | // object.
17 | 
18 | // feature: DOMException (exception)
19 | 
20 | test(function() {
21 |   assert_equals(Object.getPrototypeOf(DOMException.prototype), Error.prototype);
22 | }, "DOMException.prototype has the right [[Prototype]]");
23 | 
24 | test(function() {
25 |   assert_property(DOMException.prototype, "constructor", { writable: true, enumerable: false, configurable: true, value: DOMException });
26 | }, "DOMException.prototype.constructor has the right attributes and value");
27 | </script>
28 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unsigned-long-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>unsigned long</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.9 unsigned long
10 | //
11 | // IDL unsigned long values are represented as integer JS Number values in the
12 | // range [0, 4294967295].
13 | 
14 | // feature: HTMLCollection.length (attribute) (of type unsigned long)
15 | 
16 | test(function() {
17 |   var collection = document.getElementsByTagName("div");
18 |   assert_equals(typeof collection.length, "number");
19 |   assert_true(collection.length == Math.floor(collection.length) && collection.length >= 0 && collection.length <= 4294967296);
20 | }, "HTMLCollection.length returns a value of the correct type");
21 | 
22 | // feature: WheelEvent.deltaMode (attribute) (of type unsigned long)
23 | 
24 | test(function() {
25 |   var e = new WheelEvent("test");
26 |   assert_equals(typeof e.deltaMode, "number");
27 |   assert_true(e.deltaMode == Math.floor(e.deltaMode) && e.deltaMode >= 0 && e.deltaMode <= 4294967296);
28 | }, "WheelEvent.deltaMode returns a value of the correct type");
29 | </script>
30 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unrestricted-double-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>unrestricted doubles must canonicalize NaN</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.15 unrestricted double
10 | //
11 | // When converting a JS Number to an IDL unrestricted double, a NaN with
12 | // a specific bit pattern must be used.
13 | 
14 | // feature: Float64Array (indexed property setter) (of type unrestricted double)
15 | 
16 | function arrays_equal(a, b) {
17 |   if (a.length != b.length) {
18 |     return false;
19 |   }
20 |   for (var i = 0; i < a.length; i++) {
21 |     if (a[i] != b[i]) {
22 |       return false;
23 |     }
24 |   }
25 |   return true;
26 | }
27 | 
28 | test(function() {
29 |   var buffer = new ArrayBuffer(8);
30 |   var f = new Float64Array(buffer);
31 |   var b = new Uint8Array(buffer);
32 | 
33 |   f[0] = NaN;
34 | 
35 |   assert_true(arrays_equal(b, [0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) ||
36 |               arrays_equal(b, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7f]));
37 | }, "converting a JS NaN to an IDL unrestricted double uses the NaN with bit pattern 0x7ff8000000000000");
38 | </script>
39 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/float-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>float</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.12 float
10 | //
11 | // IDL float values are represented with JS Number values, although only ones
12 | // that are (a) finite, and (b) correspond to a single precision value.
13 | 
14 | // feature: SVGNumber.value (attribute) (of type float)
15 | 
16 | test(function() {
17 |   var number = document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGNumber();
18 |   number.value = 1.1;
19 |   assert_equals(typeof number.value, "number");
20 |   assert_true(number.value * 0 == 0);
21 |   assert_equals(number.value, 1.100000023841858);
22 | }, "SVGNumber.value returns a value of the correct type");
23 | 
24 | // feature: SVGMatrix.a (attribute) (of type float)
25 | 
26 | test(function() {
27 |   var matrix = document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGMatrix();
28 |   matrix.a = 1.1;
29 |   assert_equals(typeof matrix.a, "number");
30 |   assert_true(matrix.a * 0 == 0);
31 |   assert_equals(matrix.a, 1.100000023841858);
32 | }, "SVGMatrix.a returns a value of the correct type");
33 | </script>
34 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/exception-interface-object-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Exception interface object</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.9.1 Exception interface object
10 | //
11 | // Every exception interface object for an exception has a "prototype"
12 | // property (non-writable, non-enumerable, non-configurable), since it is
13 | // a function object.  Its value is the exception interface prototype object.
14 | 
15 | // feature: DOMException (exception)
16 | 
17 | test(function() {
18 |   assert_property(DOMException, "prototype", { writable: false, enumerable: false, configurable: false }, "DOMException.prototype");
19 | }, "DOMException.prototype has the right attributes");
20 | 
21 | test(function() {
22 |   var exception;
23 |   try {
24 |     document.appendChild(document);
25 |   } catch (e) {
26 |     exception = e;
27 |   }
28 |   assert_true(!!exception);
29 |   assert_equals(DOMException.prototype, Object.getPrototypeOf(exception));
30 | }, "DOMException.prototype has the right value");
31 | 
32 | test(function() {
33 |   assert_equals(typeof DOMException, "function");
34 | }, "typeof DOMException is correct");
35 | </script>
36 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/sequence-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Sequence types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.23 Sequences – sequence<T>
10 | //
11 | // IDL sequence values are represented in JS as newly created Array objects
12 | // which have had their array index properties set as own, writable, enumerable,
13 | // configurable properties.
14 | 
15 | // feature: MutationCallback (operation) (on a callback interface, of a sequence type)
16 | 
17 | async_test(function(t) {
18 |   var span = document.createElement("span");
19 |   var obs = new MutationObserver(function(records) {
20 |     t.step(function() {
21 |       assert_true(Array.isArray(records));
22 |       assert_equals(Object.getPrototypeOf(records), Array.prototype);
23 |       assert_property(records, "0", { writable: true, enumerable: true, configurable: true }, "records[0]");
24 |       assert_true(records[0] instanceof MutationRecord);
25 |       t.done();
26 |     });
27 |   });
28 |   obs.observe(span, { attributes: true });
29 |   span.setAttribute("data-test", "test");
30 | }, "a MutationObserver correctly converts a sequence<MutationRecord> value to a JS value");
31 | </script>
32 | 


--------------------------------------------------------------------------------
/timelines/HTML.md:
--------------------------------------------------------------------------------
 1 | # HTML 5.1 Timeline
 2 | 
 3 | [HTML 5.1 TR](http://www.w3.org/TR/html51/)
 4 | 
 5 | * May 31, 2016: Completion deadline for [HTML 5.1 WD issues](https://github.com/w3c/html/milestones/HTML5.1%20WD%20(June%202016))
 6 | 
 7 | * June 2, 2016: Working Draft update, Call For Consensus for Candidate Recommendation; Branch for 5.1 in GitHub
 8 | 
 9 | * June 14, 2016: transition to Candidate Recommendation request
10 | 
11 | * June 21, 2016: HTML5.1 Candidate Recommendation
12 | 
13 | * July 18, 2016: Deadline for [HTML 5.1 CR issues](https://github.com/w3c/html/milestones/HTML5.1%20CR)
14 | 
15 | * July 19, 2016: Call For Consensus for Proposed Recommendation; implementation report
16 | 
17 | * July 28, 2016: HTML5.1 Proposed Recommendation transition request
18 | 
19 | * August 4, 2016: HTML5.1 Proposed Recommendation
20 | 
21 | * September 1, 2016: W3C Advisory Committee reviews end
22 | 
23 | * September 15, 2016: HTML 5.1 Recommendation published
24 | 
25 | # HTML 5.2 Timeline
26 | 
27 | Note: on June 2, the master branch becomes the placeholder for HTML 5.2.
28 | 
29 | [HTML TR](http://www.w3.org/TR/html/)
30 | 
31 | [After HTML 5.1 issues](https://github.com/w3c/html/milestones/After%20HTML%205.1)
32 | 
33 | * June 14, 2016: Call For Consensus for First Public Working Draft
34 | 
35 | * June 21, 2016: HTML5.2 First Public Working Draft
36 | 
37 | * June 30, 2017: HTML 5.2 Recommendation?
38 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/interface-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Interface object property</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5 Interfaces
10 | //
11 | // For each interface that isn't [NoInterfaceObject], there's a property
12 | // on the global object that is writable, unenumerable and configurable.
13 | 
14 | var interfaces = [
15 | 
16 |   // feature: DOMImplementation (interface) (without inheritance, without [NoInterfaceObject])
17 |   "DOMImplementation",
18 | 
19 |   // feature: HTMLCollection (interface) (without inheritance, without [NoInterfaceObject])
20 |   "HTMLCollection",
21 | 
22 |   // feature: Element (interface) (with inheritance, without [NoInterfaceObject])
23 |   "Element",
24 | 
25 |   // feature: UIEvent (interface) (with inheritance, without [NoInterfaceObject])
26 |   "UIEvent",
27 | 
28 |   // feature: NodeFilter (callback interface) (with constants)
29 |   "NodeFilter"
30 | ];
31 | 
32 | for (var i = 0; i < interfaces.length; i++) {
33 |   var name = interfaces[i];
34 |   test(function() {
35 |     assert_property(window, name, { writable: true, enumerable: false, configurable: true }, "window." + name);
36 |   }, "property for " + name + " interface object exists");
37 | }
38 | </script>
39 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Global-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[Global] prototype chain</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.4 Named properties object
10 | //
11 | // Its [[Prototype]] points to the interface prototype object of any
12 | // interface the one [[Prototype]] is on inherits from, or Object.prototype.
13 | 
14 | // feature: Window (interface) (with [Global])
15 | 
16 | // window -> Window.prototype -> [named properties] -> EventTarget.prototype -> Object.prototype
17 | 
18 | var chain = prototypeChain(window);
19 | 
20 | test(function() {
21 |   assert_equals(chain[1], Window.prototype);
22 | }, "window has correct [[Prototype]]");
23 | 
24 | test(function() {
25 |   assert_true(chain[2] && chain[2] != EventTarget.prototype && chain[2] != Object.prototype);
26 | }, "Window.prototype doesn't have incorrect [[Prototype]]");
27 | 
28 | test(function() {
29 |   assert_equals(chain[3], EventTarget.prototype);
30 | }, "named properties object has correct [[Prototype]]");
31 | 
32 | test(function() {
33 |   assert_equals(chain[4], Object.prototype);
34 | }, "EventTarget.prototype has correct [[Prototype]]");
35 | 
36 | test(function() {
37 |   assert_equals(chain.length, 5);
38 | }, "window has expected prototype chain length");
39 | </script>
40 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/any-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>any</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.1 any
10 | //
11 | // Converting a JS value to an IDL any values and back again should be
12 | // lossless.
13 | 
14 | var values = [
15 |   undefined,   "undefined",
16 |   null,        "null",
17 |   false,       "false",
18 |   true,        "true",
19 |   0,           "0",
20 |   1,           "1",
21 |   -1,          "-1",
22 |   0.5,         "0.5",
23 |   Infinity,    "Infinity",
24 |   -Infinity,   "-Infinity",
25 |   NaN,         "NaN",
26 |   -0,          "-0",
27 |   "",          '""',
28 |   "1",         '"1"',
29 |   "hello",     '"hello"',
30 |   { },         "{ }",
31 |   [],          "[]",
32 |   /abc/,       "/abc/",
33 |   document,    "document"
34 | ];
35 | 
36 | // feature: CustomEvent.initCustomEvent (operation) (with argument of type any)
37 | 
38 | for (var i = 0; i < values.length; i += 2) {
39 |   var value = values[i];
40 |   var desc = values[i + 1];
41 |   test(function() {
42 |     var e = document.createEvent("CustomEvent");
43 |     e.initCustomEvent("test", false, false, value);
44 |     assert_equals(e.detail, values[i]);
45 |   }, "passing " + desc + " to CustomEvent.initCustomEvent() comes out the same from CustomEvent.detail");
46 | }
47 | </script>
48 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/boolean-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>boolean</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.3 boolean
10 | //
11 | // Converting a JS value to an IDL boolean just uses the ToBoolean()
12 | // ECMAScript operation.
13 | 
14 | var values = [
15 |   undefined,   "undefined",
16 |   null,        "null",
17 |   false,       "false",
18 |   true,        "true",
19 |   0,           "0",
20 |   1,           "1",
21 |   -1,          "-1",
22 |   0.5,         "0.5",
23 |   Infinity,    "Infinity",
24 |   -Infinity,   "-Infinity",
25 |   NaN,         "NaN",
26 |   -0,          "-0",
27 |   "",          '""',
28 |   "1",         '"1"',
29 |   "hello",     '"hello"',
30 |   { },         "{ }",
31 |   [],          "[]",
32 |   /abc/,       "/abc/",
33 |   document,    "document"
34 | ];
35 | 
36 | // feature: Event.initEvent (operation) (with argument of type boolean)
37 | 
38 | for (var i = 0; i < values.length; i += 2) {
39 |   var value = values[i];
40 |   var desc = values[i + 1];
41 |   test(function() {
42 |     var e = document.createEvent("Event");
43 |     e.initEvent("test", value, false);
44 |     assert_equals(e.bubbles, !!values[i]);
45 |   }, "passing " + desc + " to the bubbles argument of Event.initEvent() comes out the same from Event.bubbles");
46 | }
47 | </script>
48 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/platform-object-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Platform objects implementing interfaces</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.7 Platform objects implementing interfaces
10 | //
11 | // The [[Prototype]] of a platform object implementing an interface is the
12 | // interface prototype object of its primary interface.
13 | 
14 | var objects = [
15 | 
16 |   // DOMImplementation (interface) (without inheritance, primary interface)
17 |   function() { return document.implementation; }, "DOMImplementation",
18 | 
19 |   // HTMLCollection (interface) (without inheritance, primary interface)
20 |   function() { return document.forms; }, "HTMLCollection",
21 | 
22 |   // HTMLSpanElement (interface) (with inheritance, primary interface)
23 |   function() { return document.createElement("span"); }, "HTMLSpanElement",
24 | 
25 |   // UIEvent (interface) (with inheritance, primary interface)
26 |   function() { return document.createEvent("UIEvent"); }, "UIEvent"
27 | ];
28 | 
29 | for (var i = 0; i < objects.length; i += 2) {
30 |   var object = objects[i]();
31 |   var name = objects[i + 1];
32 | 
33 |   test(function() {
34 |     assert_equals(Object.getPrototypeOf(object), window[name].prototype);
35 |   }, name + " object has correct [[Prototype]]");
36 | }
37 | </script>
38 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/report/sticky-headers.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // stolen from http://css-tricks.com/persistent-headers/
 3 | (function ($) {
 4 |     function updateTH () {
 5 |         $(".persist-area").each(function() {
 6 |             var $el = $(this)
 7 |             ,   offset = $el.offset()
 8 |             ,   scrollTop = $(window).scrollTop()
 9 |             ,   $floatingHeader = $(".floatingHeader", this)
10 |             ;
11 |             if ((scrollTop > offset.top) && (scrollTop < offset.top + $el.height()))
12 |                 $floatingHeader.css({ "visibility": "visible" });
13 |             else
14 |                $floatingHeader.css({ "visibility": "hidden" });
15 |         });
16 |     }
17 |     $(function() {
18 |         var $clonedHeaderRow;
19 |         $(".persist-area").each(function() {
20 |             $clonedHeaderRow = $(".persist-header", this);
21 |             var widths = [];
22 |             $clonedHeaderRow.find("td, th").each(function () {
23 |                 widths.push($(this).outerWidth());
24 |             });
25 |             $clonedHeaderRow
26 |                 .before($clonedHeaderRow.clone())
27 |                 .css("width", $clonedHeaderRow.width())
28 |                 .addClass("floatingHeader");
29 |             $clonedHeaderRow.find("td, th").each(function () {
30 |                 $(this).css("width", widths.shift());
31 |             });
32 |         });
33 |         $(window)
34 |             .scroll(updateTH)
35 |             .trigger("scroll");
36 |     });
37 | }(jQuery));
38 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/implements-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Implements statements</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.6 Implements statement
10 | //
11 | // The implements statement causes all of the properties that would exist
12 | // on the RHS interface's interface object and interface prototype object to
13 | // appear on those objects for the LHS interface.  If they values of the
14 | // properties are objects, they do not refer to the same object.  They
15 | // also can only be applied to the interface that the properties exist on.
16 | 
17 | // feature: URLUtils (interface) (used on RHS of implements statement)
18 | 
19 | test(function() {
20 |   var desc1 = Object.getOwnPropertyDescriptor(HTMLAnchorElement.prototype, "href");
21 |   var desc2 = Object.getOwnPropertyDescriptor(HTMLAreaElement.prototype, "href");
22 |   assert_true(desc1.get != desc2.get);
23 | }, "HTMLAnchorElement.prototype and HTMLAreaElement.prototype have distinct Function objects for their URLUtils.href attribute getter");
24 | 
25 | test(function() {
26 |   var desc = Object.getOwnPropertyDescriptor(HTMLAnchorElement.prototype, "href");
27 |   var area = document.createElement("area");
28 |   assert_throws(new TypeError(), function() { desc.get.call(area); });
29 | }, "HTMLAnchorElement.prototype.href's getter cannot be applied to an HTMLAnchorElement object");
30 | </script>
31 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/constant-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Constants on interfaces</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.5 Constants
10 | //
11 | // Constants are exposed as non-writable, enumerable, non-configurable
12 | // properties on interface objects and interface prototype objects.
13 | 
14 | // feature: HTMLMediaElement.NETWORK_IDLE (constant)
15 | 
16 | test(function() {
17 |   assert_property(HTMLMediaElement, "NETWORK_IDLE", { writable: false, enumerable: true, configurable: false, value: 1 });
18 | }, "HTMLMediaElement.NETWORK_IDLE has correct attributes and value");
19 | 
20 | test(function() {
21 |   assert_property(HTMLMediaElement.prototype, "NETWORK_IDLE", { writable: false, enumerable: true, configurable: false, value: 1 });
22 | }, "HTMLMediaElement.prototype.NETWORK_IDLE has correct attributes and value");
23 | 
24 | // feature: SVGLength.SVG_LENGTHTYPE_NUMBER (constant)
25 | 
26 | test(function() {
27 |   assert_property(SVGLength, "SVG_LENGTHTYPE_NUMBER", { writable: false, enumerable: true, configurable: false, value: 1 });
28 | }, "SVGLength.SVG_LENGTHTYPE_NUMBER has correct attributes and value");
29 | 
30 | test(function() {
31 |   assert_property(SVGLength.prototype, "SVG_LENGTHTYPE_NUMBER", { writable: false, enumerable: true, configurable: false, value: 1 });
32 | }, "SVGLength.prototype.SVG_LENGTHTYPE_NUMBER has correct attributes and value");
33 | </script>
34 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Global-004.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Fixing the named properties object</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe1"></iframe>
10 |   <iframe id="iframe2"></iframe>
11 |   <iframe id="iframe3"></iframe>
12 | </div>
13 | 
14 | <script>
15 | // 4.7.1 Indexed and named properties
16 | //
17 | // Attempts to fix a named properties object by calling Object.freeze,
18 | // Object.seal or Object.preventExtensions on it must fail and throw a
19 | // TypeError.
20 | 
21 | // feature: Window (interface) (with [Global])
22 | 
23 | test(function() {
24 |   var w = document.getElementById("iframe1").contentWindow;
25 |   var npo = Object.getPrototypeOf(w.Window.prototype);
26 |   assert_throws(new TypeError(), function() { Object.freeze(npo); });
27 | }, "Object.freeze must fail on a named properties object");
28 | 
29 | test(function() {
30 |   var w = document.getElementById("iframe2").contentWindow;
31 |   var npo = Object.getPrototypeOf(w.Window.prototype);
32 |   assert_throws(new TypeError(), function() { Object.seal(npo); });
33 | }, "Object.seal must fail on a named properties object");
34 | 
35 | test(function() {
36 |   var w = document.getElementById("iframe3").contentWindow;
37 |   var npo = Object.getPrototypeOf(w.Window.prototype);
38 |   assert_throws(new TypeError(), function() { Object.preventExtensions(npo); });
39 | }, "Object.preventExtensions must fail on a named properties object");
40 | </script>
41 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/TreatNullAs-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[TreatNullAs] on attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.16 DOMString
10 | //
11 | // Assigning to an attribute of type DOMString will by default convert null to
12 | // "null".  If [TreatNullAs=EmptyString] is on the attribute, null will be
13 | // converted to "" instead.
14 | 
15 | // feature: Element.className (attribute) (without [TreatNullAs])
16 | 
17 | test(function() {
18 |   var e = document.createElement("span");
19 |   e.className = "hello";
20 |   assert_equals(e.className, "hello", "e.className");
21 |   e.className = null;
22 |   assert_equals(e.className, "null", "e.className");
23 | }, "assigning to Element.className converts null to \"null\"");
24 | 
25 | // feature: CharacterData.data (attribute) (with [TreatNullAs=EmptyString])
26 | 
27 | test(function() {
28 |   var n = document.createTextNode("hello");
29 |   assert_equals(n.data, "hello", "n.data");
30 |   n.data = null;
31 |   assert_equals(n.data, "", "n.data");
32 | }, "assigning to CharacterData.data converts null to \"\"");
33 | 
34 | // feature: HTMLFrameElement.marginWidth (attribute) (with [TreatNullAs=EmptyString])
35 | 
36 | test(function() {
37 |   var e = document.createElement("frame");
38 |   e.setAttribute("marginwidth", "hello");
39 |   assert_equals(e.marginWidth, "hello", "e.marginWidth");
40 |   e.marginWidth = null;
41 |   assert_equals(e.marginWidth, "", "e.marginWidth");
42 | }, "assigning to HTMLFrameElement.marginWidth converts null to \"\"");
43 | </script>
44 | 


--------------------------------------------------------------------------------
/meetings/17-03HTML.md:
--------------------------------------------------------------------------------
 1 | # HTML meeting
 2 | 
 3 | This meeting will take place from 28 to 30 March 2017, and will be hosted by [Q42](http://q42.nl) in Amsterdam (The Netherlands).
 4 | 
 5 | ## Expected attendees
 6 | 
 7 | Please add your name, and agenda requests here by [editing a branch and making a Pull Request, or by mail to either the public-webapps mailing list or the chairs of the Web Platform group, which will result in it being posted here.
 8 | 
 9 | ### Will attend
10 | * Steve Faulkner (TPG)
11 | * Léonie Watson (TPG)
12 | * Alex Danilo (Google)
13 | * Chaals McCathie Nevile (Yandex)
14 | * Xiaoqian Wu (W3C)
15 | * Paul Changjin Jeong (HTML5 CT Forum)
16 | * Teahwan Kim (HTML5 CT Forum)
17 | 
18 | #### Observers
19 | * Roelf-Jan de Vries  (Q42)
20 | * Guido Bouman  (Q42)
21 | * Johan Huijkman (Q42)
22 |  
23 | ### Hope to attend
24 | -
25 | 
26 | ### Regrets
27 | * Travis Leithead (Microsoft - HTML editor), morning only
28 | * Arron Eicholz (Microsoft)
29 | * Sangwhan Moon (IE)
30 | 
31 | ## Draft agenda
32 | * Moving HTML5.2 to CR
33 | * Open HTML5.2 issues
34 | * HTML ideas in incubation
35 | * Continuous review
36 | * Documentation (build process)
37 | * Plan for HTML5.3
38 | 
39 | ## Logistics
40 | 
41 | <dl>
42 | <dt>Date(s)</dt>
43 | <dd>Tue 28 to Thu 30 March 2017</dd>
44 | <dt>Time</dt>
45 | <dd>9.30am to 5pm (each day)</dd>
46 | <dt>Venue</dt>
47 | <dd>
48 | Oostelijke Handelskade 749,<br> 
49 | Amsterdam</dd>
50 | <dt><a href="https://yandex.com/maps/-/CZhe56j-">Map</a></dt>
51 | <dt>Contact</dt>
52 | <dd>Johan Huijkman</dd>
53 | <dt>IRC</dt>
54 | <dd>irc.w3.org, #html</dd>
55 | <dt>Remote Participation</dt>
56 | <dd>+1-617-324-0000 , access code: 640 454 877 (please <a href="mailto:team-webplatform@w3.org">contact the chairs</a> for remote participation)</dd>
57 | </dl>
58 | 


--------------------------------------------------------------------------------
/meetings/16-09-20TPAC-2.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # TPAC Service Workers meeting - 20 September 2016
 3 | 
 4 | This meeting will take place on 20 September 2016 as part of [TPAC 2016](https://www.w3.org/2016/09/TPAC/)
 5 | 
 6 | ## minutes
 7 | [Minutes from the 20 September 2016 TPAC Service Workers meeting](https://www.w3.org/2016/09/20-webapps-minutes.html).
 8 | 
 9 | ## Expected attendees
10 | 
11 | ### Will attend
12 | 
13 | * Kenji Baheux (Google)
14 | * Chaals (Yandex)
15 | * Léonie Watson (TPG) Morning only
16 | * Kris Borchers (jQuery Foundation) Morning only
17 | 
18 | ### Hope to attend
19 | 
20 | * TBD
21 | 
22 | ## Agenda
23 | 
24 | * TBD
25 | 
26 | Please add your name, and agenda requests here by [editing a branch and making a Pull Request](https://github.com/w3c/WebPlatformWG/edit/gh-pages/meetings/16-09-20TPAC-2.md), or by mail to either the public-webapps mailing list or the chairs of the Web Platform group, which will result in it being posted here.
27 | 
28 | ## Background reading
29 | 
30 | * TBD
31 | 
32 | ## Logistics
33 | 
34 | <dl>
35 |   <dt>Date/time</dt>
36 |   <dd>9am - 6pm, Tuesday 20 September 2016</dd>
37 |   <dt>Location</dt>
38 |   <dd>Auditorium III, First Floor, Centro de Congressos de Lisboa, Lisbon, Portugal.</dd>
39 | <dt>IRC</dt>
40 |   <dd>irc.w3.org, #webapps</dd>
41 |   </dl>
42 | 
43 | ## Remote Participation
44 | 
45 | <dl>
46 |   <dt>WebEx</dt>
47 |   <dd><a href="https://mit.webex.com/mit/j.php?MTID=m8a90c9a726583ba3e7f00d7ab7241ca4">https://mit.webex.com/mit/j.php?MTID=m8a90c9a726583ba3e7f00d7ab7241ca4</a>, meeting number: 642 961 925 (please contact the chairs or the team for meeting password)</dd>
48 |   <dt>Join by phone</dt>
49 |   <dd>+1-617-324-0000, access code: 642 961 925</dd>
50 | </dl>
51 | 
52 | Further information will be posted here as it becomes available.
53 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/interface-object-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Interface object property</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.1 Interface object
10 | //
11 | // Every interface object for a non-callback interface has a "prototype"
12 | // property (non-writable, non-enumerable, non-configurable), since it is
13 | // a function object.  Its value is the interface prototype object.
14 | 
15 | // feature: DOMImplementation (interface)
16 | 
17 | test(function() {
18 |   assert_property(DOMImplementation, "prototype", { writable: false, enumerable: false, configurable: false }, "DOMImplementation.prototype");
19 | }, "DOMImplementation.prototype has the right attributes");
20 | 
21 | test(function() {
22 |   assert_equals(DOMImplementation.prototype, Object.getPrototypeOf(document.implementation));
23 | }, "DOMImplementation.prototype has the right value");
24 | 
25 | test(function() {
26 |   assert_equals(typeof DOMImplementation, "function");
27 | }, "typeof DOMImplementation is correct");
28 | 
29 | // feature: HTMLCollection (interface)
30 | 
31 | test(function() {
32 |   assert_property(HTMLCollection, "prototype", { writable: false, enumerable: false, configurable: false }, "HTMLCollection.prototype");
33 | }, "HTMLCollection.prototype has the right attributes");
34 | 
35 | test(function() {
36 |   assert_equals(HTMLCollection.prototype, Object.getPrototypeOf(document.getElementsByTagName("div")));
37 | }, "HTMLCollection.prototype has the right value");
38 | 
39 | test(function() {
40 |   assert_equals(typeof HTMLCollection, "function");
41 | }, "typeof HTMLCollection is correct");
42 | </script>
43 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/interface-prototype-object-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Interface prototype objects</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.3 Interface prototype object
10 | //
11 | // The [[Prototype]] of an interface prototype object is Object.prototype,
12 | // if the interface does not inherit from another; otherwise it is
13 | // is the interface prototype object of the inherited interface.
14 | // The interface prototype object has "constructor" property if it is not
15 | // [NoInterfaceObject].
16 | 
17 | var interfaces = [
18 | 
19 |   // feature: DOMImplementation (interface) (without inheritance, without [NoInterfaceObject])
20 |   "DOMImplementation", "Object",
21 | 
22 |   // feature: HTMLCollection (interface) (without inheritance, without [NoInterfaceObject])
23 |   "HTMLCollection", "Object",
24 | 
25 |   // feature: Element (interface) (with inheritance, without [NoInterfaceObject])
26 |   "Element", "Node",
27 | 
28 |   // feature: UIEvent (interface) (with inheritance, without [NoInterfaceObject])
29 |   "UIEvent", "Event"
30 | ];
31 | 
32 | for (var i = 0; i < interfaces.length; i += 2) {
33 |   var name = interfaces[i];
34 |   var inh = interfaces[i + 1];
35 | 
36 |   test(function() {
37 |     assert_equals(Object.getPrototypeOf(window[name].prototype), window[inh].prototype);
38 |   }, name + ".prototype has the right [[Prototype]]");
39 | 
40 |   test(function() {
41 |     assert_property(window[name].prototype, "constructor", { writable: true, enumerable: false, configurable: true, value: window[name] });
42 |   }, name + ".prototype.constructor has the right attributes and value");
43 | }
44 | </script>
45 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/TreatNonCallableAsNull-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[TreatNonObjectAsNull]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.22 Nullable types — T?
10 | //
11 | // If the [TreatNonObjectAsNull] extended attribute appears on a callback 
12 | // function, then it indicates that any value assigned to an attribute whose 
13 | // type is a nullable callback function that is not an object will be 
14 | // converted to the null value. 
15 | 
16 | // feature: Document.onclick (attribute) (with [TreatNonObjectAsNull])
17 | // feature: Document.onerror (attribute) (with [TreatNonObjectAsNull])
18 | 
19 | function noop() { }
20 | var obj = { };
21 | var str = "test";
22 | var bool = false;
23 | var num = 123;
24 | 
25 | var properties = ["onclick", "onerror"];
26 | var tests = [
27 |   // assign this            // get this
28 |   noop,                     noop,
29 |   obj,                      obj,
30 |   Event,                    Event,
31 |   Event.prototype,          Event.prototype,
32 |   Image,                    Image,
33 |   document.documentElement, document.documentElement,
34 |   str,                      null,
35 |   bool,                     null,
36 |   num,                      null
37 | ];
38 | 
39 | for (var i = 0; i < properties.length; i++) {
40 |   var p = properties[i];
41 |   test(function() {
42 |     for (var j = 0; j < tests.length; j += 2) {
43 |       var value = tests[j];
44 |       var expected = tests[j + 1];
45 |       document[p] = value;
46 |       assert_equals(document[p], expected, "#" + (j / 2));
47 |     }
48 |   }, "assignments of non-object values to document." + p + " are treated as assignments of null");
49 | }
50 | </script>
51 | 


--------------------------------------------------------------------------------
/js/newsfeed.js:
--------------------------------------------------------------------------------
 1 | // Quick n' dirty news feed
 2 | (function () {
 3 | try {
 4 |   var attempts = 0;
 5 | 
 6 |   function updateArticles(feed) {
 7 |       var body = document.getElementById("articles");
 8 | 
 9 |       if (body === null) {
10 |         // just in case the network request was really fast
11 |         attempts++;
12 |         if (attempts < 5) {
13 |           setTimeOut(function() { updateArticles(feed); }, 300);
14 |         }
15 |         return;
16 |       }
17 |       var items = feed.querySelectorAll("item");
18 |       for (var i = 0; i < items.length; i++) {
19 |         var item = items.item(i);
20 |         var desc = item.querySelector("description").textContent;
21 |         if (desc.indexOf("Web Platform Working Group") != -1) {
22 |           var link =  item.querySelector("link").textContent;
23 |           var article = document.createElement("article");
24 |           article.appendChild(document.createElement("h3"));
25 |           article.firstChild.textContent = item.querySelector("title").textContent;
26 |           article.appendChild(document.createElement("p"));
27 |           var d = new Date(item.querySelector("pubDate").textContent);
28 |           article.lastChild.innerHTML =
29 |             "<p class='date'><time class='dtstart' datetime='"
30 |             + d.toISOString()
31 |             + "''>" + d.toDateString()
32 |             + "</time></p>"
33 |             + item.querySelector("encoded").textContent;
34 |           body.appendChild(article);
35 |         }
36 |       }
37 |   }
38 | 
39 |   var xhr = new XMLHttpRequest();
40 |   xhr.onreadystatechange = function () {
41 |     if (this.readyState == 4
42 |         && this.status == 200) {
43 |       updateArticles(this.responseXML);
44 |     }
45 |   };
46 | 
47 |   xhr.open("GET", "//www.w3.org/blog/news/feed", true);
48 |   xhr.withCredentials = false;
49 |   xhr.send(null);
50 | } catch (e) {
51 | }
52 | })();
53 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Clamp-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[Clamp] on operation arguments</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.5 octet
10 | //
11 | // When [Clamp] is on an operation argument whose type is an integer type, then
12 | // values outside the range of the integer will be clamped to be valid.
13 | 
14 | // feature: Uint8ClampedArray (indexed property setter) (with [Clamp])
15 | 
16 | test(function() {
17 |   var a = new Uint8ClampedArray(1);
18 |   a[0] = 128;
19 |   assert_equals(a[0], 128);
20 |   a[0] = -1;
21 |   assert_equals(a[0], 0);
22 |   a[0] = 256;
23 |   assert_equals(a[0], 255);
24 |   a[0] = -0.1;
25 |   assert_equals(a[0], 0);
26 |   a[0] = 255.1;
27 |   assert_equals(a[0], 255);
28 |   a[0] = -Infinity;
29 |   assert_equals(a[0], 0);
30 |   a[0] = Infinity;
31 |   assert_equals(a[0], 255);
32 |   a[0] = -0;
33 |   assert_true(a[0] == 0 && 1 / a[0] > 0);
34 |   a[0] = 2.5;
35 |   assert_equals(a[0], 2);
36 |   a[0] = 5.5;
37 |   assert_equals(a[0], 6);
38 |   a[0] = NaN;
39 |   assert_equals(a[0], 0);
40 | }, "correct conversion of Number values to a [Clamp]ed octet");
41 | 
42 | // feature: WebSocket.close (operation) (with [Clamp] on an argument)
43 | 
44 | test(function() {
45 |   var ws = new WebSocket("wss://test.invalid");
46 | 
47 |   // valid code, should not throw
48 |   ws.close(1000);
49 | 
50 |   // invalid code, should throw
51 |   assert_throws({ name: "InvalidAccessError" }, function() { ws.close(500); });
52 | 
53 |   // invalid code, as it should clamp to 65535, rather than wrap to 1000
54 |   assert_throws({ name: "InvalidAccessError" }, function() { ws.close(66536); });
55 | }, "correct conversion of Number values to a [Clamp]ed unsigned short");
56 | </script>
57 | 


--------------------------------------------------------------------------------
/meetings/16-05-10-11HTML.md:
--------------------------------------------------------------------------------
 1 | # HTML editors meeting - 10 - 11 May 2016
 2 | 
 3 | This meeting will take place on 10 - 11 May 2016, and will be hosted by Microsoft in Redmond.
 4 | 
 5 | ## Expected attendees
 6 | 
 7 | ### Will attend
 8 | 
 9 | * Alex Danilo
10 | * Arron Eicholz
11 | * Travis Leithead
12 | * Chaals McCathie Nevile
13 | * Léonie Watson
14 | * Philippe Le Hegaret
15 | 
16 | ### Hope to attend
17 | 
18 | * Adrian Bateman
19 | 
20 | ## Agenda
21 | 
22 | The aim is to bring the HTML editors together to discuss work mode and editorial strategy, and to work collaboratively on the HTML5.1 specification.
23 | 
24 | ### Administrivia
25 | * Modules and integration
26 | * [Configure](https://help.github.com/articles/configuring-pull-request-merge-squashing/) [merging](https://help.github.com/articles/merging-a-pull-request/) or [squash merging](https://help.github.com/articles/about-pull-request-merge-squashing/)
27 | * Branching for HTML 5.1 CR/PR/Rec and 5.2 FPWD
28 | * Changes that need calls for consensus
29 | 
30 | ### Editing Work
31 | * Prioritizing open issues and assigning milestones
32 | * Reviewing WHATWG changes since Jan 12th 2016 [Diff tool](https://diffofhtmls.herokuapp.com/)
33 | * Documentation of the repo, working with bikeshed, etc.
34 | 
35 | ### If we have time
36 | * Using [web-platform-tests](https://w3c.github.io/testing-how-to/)
37 | 
38 | Please add your name, and agenda requests here by [editing a branch and making a Pull Request](https://github.com/w3c/WebPlatformWG/blob/gh-pages/meetings/10-11mayHTML.md), or by mail to either the public-webapps mailing list or the chairs of the Web Platform group, which will result in it being posted here.
39 | 
40 | ## Background reading
41 | 
42 | * N/A
43 | 
44 | ## Logistics
45 | 
46 | <dl>
47 |   <dt>Date/time</dt>
48 |   <dd>10am - 5pm, Tue 10 and Wed 11 May 2016</dd>
49 |   <dt>Location</dt>
50 |   <dd>Microsoft Building 99, 14820 NE 36th St, Redmond, WA 98052</dd>
51 | </dl>
52 | 
53 | Further information will be posted here as it becomes available.
54 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/exception-field-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Exception fields</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.9.4 Exception fields
10 | //
11 | // Exception fields are exposed as accessor properties on the exception
12 | // interface prototype object.
13 | 
14 | // feature: DOMException.code (exception field)
15 | 
16 | test(function() {
17 |   var desc = Object.getOwnPropertyDescriptor(DOMException.prototype, "code");
18 |   assert_descriptor(desc, { enumerable: true, configurable: true });
19 |   assert_equals(typeof desc.get, "function");
20 |   assert_true(!desc.set);
21 | }, "DOMException.prototype.code is an accessor property with the correct attributes and with no setter");
22 | 
23 | test(function() {
24 |   var desc = Object.getOwnPropertyDescriptor(DOMException.prototype, "code");
25 |   assert_equals(desc.get.length, 0);
26 | }, "DOMException.code getter length property has the right value");
27 | 
28 | test(function() {
29 |   var desc = Object.getOwnPropertyDescriptor(DOMException.prototype, "code");
30 |   assert_throws(new TypeError(), function() { desc.get.call(null); });
31 | }, "DOMException.code getter throws when called with a null this value");
32 | 
33 | test(function() {
34 |   var desc = Object.getOwnPropertyDescriptor(DOMException.prototype, "code");
35 |   assert_throws(new TypeError(), function() { desc.get.call(document); });
36 | }, "DOMException.code getter throws when called with a bad this value");
37 | 
38 | test(function() {
39 |   var exception;
40 |   try {
41 |     document.appendChild(document);
42 |   } catch (e) {
43 |     exception = e;
44 |   }
45 |   assert_equals(exception.code, 3);
46 | 
47 |   var desc = Object.getOwnPropertyDescriptor(DOMException.prototype, "code");
48 |   assert_equals(desc.get.call(exception, "extra"), 3);
49 | }, "arguments passed to DOMException.code getter are ignored");
50 | </script>
51 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/stringifier-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Stringifiers on attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.7 Operations
10 | //
11 | // Stringifiers that appear on an attribute do not invoke the [[Get]] internal
12 | // method on the object to get the value of the IDL attribute it is on.  Instead,
13 | // it just performs the same behavior as getting the attribute, internally.
14 | // The toString Function ignores any arguments passed to it.  If applied to the
15 | // wrong kind of object, a TypeError is thrown.
16 | 
17 | // feature: URLUtils (stringifier)
18 | 
19 | var url = "http://test.invalid/somewhere";
20 | 
21 | test(function() {
22 |   var a = document.createElement("a");
23 |   a.setAttribute("href", url);
24 |   assert_equals(a.toString(), a.href);
25 | }, "the HTMLAnchorElement stringifier returns the same value as the href attribute");
26 | 
27 | test(function() {
28 |   assert_throws(new TypeError(), function() { HTMLAnchorElement.prototype.toString.call(null); });
29 | }, "the HTMLAnchorElement stringifier throws when passed a null this-object");
30 | 
31 | test(function() {
32 |   assert_throws(new TypeError(), function() { HTMLAnchorElement.prototype.toString.call(document); });
33 | }, "the HTMLAnchorElement stringifier throws when passed a bad this-object");
34 | 
35 | test(function() {
36 |   var a = document.createElement("a");
37 |   a.setAttribute("href", url);
38 |   Object.defineProperty(a, "href", { value: 123 });
39 |   assert_equals(String(a), url);
40 | }, "the HTMLAnchorElement stringifier does not call [[Get]](\"href\")");
41 | 
42 | test(function() {
43 |   var a = document.createElement("a");
44 |   a.setAttribute("href", url);
45 |   Object.defineProperty(a, "href", { get: function() { throw { name: "Something" }; } });
46 |   assert_equals(String(a), url);
47 | }, "the HTMLAnchorElement stringifier does not invoke an \"href\" accessor property");
48 | </script>
49 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Global-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[Global] property lookup</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <form id="f1" name="f1"></form>
10 |   <form id="f2" name="f2"></form>
11 | </div>
12 | 
13 | <script>
14 | // 4.5.4.1 Named properties object [[GetOwnProperty]] method
15 | //
16 | // Named properties are exposed as data properties through [[GetOwnProperty]].
17 | 
18 | // feature: Window (interface) (with [Global])
19 | 
20 | var hidden = document.getElementById("hidden");
21 | var form1 = document.getElementById("f1");
22 | var form2 = document.getElementById("f2");
23 | 
24 | test(function() {
25 |   assert_equals(window.f1, form1);
26 | }, "properties from the named properties object can be looked up on window");
27 | 
28 | test(function() {
29 |   assert_equals(Window.prototype.f1, form1);
30 | }, "properties from the named properties object can be looked up on Window.prototype");
31 | 
32 | test(function() {
33 |   var namedPropertiesObject = Object.getPrototypeOf(Window.prototype);
34 |   assert_equals(namedPropertiesObject.f1, form1);
35 | }, "named properties can be looked up on the named properties object");
36 | 
37 | test(function() {
38 |   var object = window;
39 |   var desc;
40 |   while (object && !desc) {
41 |     desc = Object.getOwnPropertyDescriptor(object, "f1");
42 |     object = Object.getPrototypeOf(object);
43 |   }
44 |   assert_true(!!desc, "named property exposed through [[GetOwnProperty]]");
45 |   assert_descriptor(desc, { writable: true, enumerable: false, configurable: true, value: form1 }, "f1");
46 | }, "named properties are exposed correctly through [[GetOwnProperty]]");
47 | 
48 | // XXX We probably shouldn't allow non-configurable properties to be defined
49 | // on the named properties object: https://www.w3.org/Bugs/Public/show_bug.cgi?id=21929
50 | // Once that bug is resolved, we should test this.
51 | </script>
52 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/dictionary-type-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Dictionary type returned from an operation</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <canvas id="canvas" width="100" height="100"></canvas>
10 | </div>
11 | 
12 | <script>
13 | // 4.2.19 Dictionary types
14 | //
15 | // When IDL dictionary values are converted to JS values, they are as an object
16 | // whose [[Prototype]] is Object.prototype, and where all dictionary member
17 | // values that are present are own, writable, enumerable, configurable
18 | // properties on the object.
19 | 
20 | // feature: WebGLRenderingContext.getContextAttributes (operation) (with dictionary type return type)
21 | 
22 | test(function() {
23 |   var canvas = document.getElementById("canvas");
24 |   var ctx = canvas.getContext("webgl") ||
25 |             canvas.getContext("experimental-webgl");
26 |   var attrs = ctx.getContextAttributes();
27 |   assert_equals(Object.getPrototypeOf(attrs), Object.prototype);
28 |   assert_property(attrs, "alpha", { value: true, writable: true, enumerable: true, configurable: true }, "attrs.alpha");
29 |   assert_property(attrs, "depth", { value: true, writable: true, enumerable: true, configurable: true }, "attrs.depth");
30 |   assert_property(attrs, "stencil", { value: false, writable: true, enumerable: true, configurable: true }, "attrs.stencil");
31 |   assert_property(attrs, "antialias", { value: true, writable: true, enumerable: true, configurable: true }, "attrs.antialias");
32 |   assert_property(attrs, "premultipliedAlpha", { value: true, writable: true, enumerable: true, configurable: true }, "attrs.premultipliedAlpha");
33 |   assert_property(attrs, "preserveDrawingBuffer", { value: false, writable: true, enumerable: true, configurable: true }, "attrs.preserveDrawingBuffer");
34 | }, "WebGLRenderingContext.getContextAttributes() returns a dictionary value correctly");
35 | </script>
36 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/indexed-properties-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Fixing objects that support indexed properties</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.7.1 Indexed and named properties
10 | //
11 | // Attempts to fix an object that supports indexed properties by calling
12 | // Object.freeze, Object.seal or Object.preventExtensions on it must fail and
13 | // throw a TypeError.
14 | 
15 | // feature: NodeList (interface) (supports indexed properties)
16 | 
17 | test(function() {
18 |   var e = document.createElement("span");
19 |   assert_throws(new TypeError(), function() { Object.freeze(e.childNodes); });
20 | }, "Object.freeze must fail on a NodeList since it supports indexed properties");
21 | 
22 | test(function() {
23 |   var e = document.createElement("span");
24 |   assert_throws(new TypeError(), function() { Object.seal(e.childNodes); });
25 | }, "Object.seal must fail on a NodeList since it supports indexed properties");
26 | 
27 | test(function() {
28 |   var e = document.createElement("span");
29 |   assert_throws(new TypeError(), function() { Object.preventExtensions(e.childNodes); });
30 | }, "Object.preventExtensions must fail on a NodeList since it supports indexed properties");
31 | 
32 | 
33 | // was testing Uint8Array, but this is no longer a platform object (interface)--it's native to 
34 | // ECMAScript, and supports seal() and preventExtensions()
35 | 
36 | // Test with HTMLCollection (supports indexed properties)
37 | 
38 | test(function() {
39 |   var a = document.scripts;
40 |   assert_throws(new TypeError(), function() { Object.freeze(a); });
41 | }, "Object.freeze must fail on an HTMLCollection since it supports indexed properties");
42 | 
43 | test(function() {
44 |   var a = document.scripts;
45 |   assert_throws(new TypeError(), function() { Object.seal(a); });
46 | }, "Object.seal must fail on an HTMLCollection since it supports indexed properties");
47 | 
48 | test(function() {
49 |   var a = document.scripts;
50 |   assert_throws(new TypeError(), function() { Object.preventExtensions(a); });
51 | }, "Object.preventExtensions must fail on an HTMLCollection since it supports indexed properties");
52 | </script>
53 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/named-properties-005.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Deleting named properties</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.7.3 Platform object [[DefineOwnProperty]] method
10 | //
11 | // If an object supports named properties, and a named property
12 | // deleter is available, then attempting to delete a property with a name that
13 | // is a supported property name will invoke the deleter.
14 | 
15 | // feature: DOMStringMap (named property deleter)
16 | 
17 | test(function() {
18 |   var span = document.createElement("span");
19 |   span.dataset.hello = "test";
20 |   assert_true(span.hasAttribute("data-hello"));
21 |   assert_true(delete span.dataset.hello);
22 |   assert_true(!span.hasAttribute("data-hello"));
23 | }, "invoking the named property deleter on a DOMStringMap works");
24 | 
25 | test(function() {
26 |   var span = document.createElement("span");
27 |   span.dataset.constructor = "test";
28 |   assert_true(span.hasAttribute("data-constructor"));
29 |   assert_true(delete span.dataset.constructor);
30 |   assert_true(span.hasAttribute("data-constructor"));
31 | }, "using delete on a DOMStringMap on a named property that is hidden due to the named property visibility algorithm will not invoke the named property deleter");
32 | 
33 | // feature: Storage (named property deleter)
34 | 
35 | test(function() {
36 |   window.localStorage.hello = "test";
37 |   assert_equals(window.localStorage.getItem("hello"), "test");
38 |   assert_true(delete window.localStorage.hello);
39 |   assert_equals(window.localStorage.getItem("hello"), null);
40 | }, "invoking the named property deleter on a Storage works");
41 | 
42 | test(function() {
43 |   window.localStorage.constructor = "test";
44 |   assert_equals(window.localStorage.getItem("constructor"), "test");
45 |   assert_equals(window.localStorage.constructor, Object.prototype.constructor);
46 |   assert_true(delete window.localStorage.constructor);
47 |   assert_equals(window.localStorage.getItem("constructor"), "test");
48 | }, "using delete on a Storage on a named property that is hidden due to the named property visibility algorithm will not invoke the named property deleter");
49 | </script>
50 | 


--------------------------------------------------------------------------------
/meetings/18-06-html.md:
--------------------------------------------------------------------------------
 1 | # HTML meeting
 2 | 
 3 | Amsterdam (The Netherlands), 19th - 21st June 2018
 4 | 
 5 | ## Expected attendees
 6 | Please add your name by [editing a branch and making a Pull Request, or by mail to public-html@w3.org (which will result in your name being published here.
 7 | 
 8 | ### Will attend
 9 | * Chaals McCathie Nevile (Yandex)
10 | * Scott O'Hara (TPG)
11 | * Léonie Watson (TPG)
12 | * Xiaoqian Wu (W3C)
13 | * Steve Faulkner (TPG)
14 | * Shwetank Dixit (Barrier Break)
15 | * Bruce Lawson (Independant Consultant for Wix)
16 | 
17 | #### Observers
18 | * Job van Achterberg (Tenon)
19 | * Michiel BIJL (Invited Expert)
20 | 
21 | ### Hope to attend
22 | * Sangwhan Moon (Odd Concepts)
23 | 
24 | ### Regrets
25 | * Patricia AAs (Vivaldi)
26 | 
27 | ## Agenda
28 | Please add agenda requests here by [editing a branch and making a Pull Request, or by mail to public-html@w3.org (which will result in it being published here.
29 | 
30 | * Day 1 - Issue Triage
31 |   * TAG HTML review
32 |     * https://github.com/w3ctag/design-reviews/issues/275
33 |   * I18n review
34 |     * https://github.com/w3c/html/issues/1039
35 |     * https://github.com/w3c/html/labels/i18n-comment
36 |   * Privacy review
37 |     * https://github.com/w3c/html/issues/1458
38 |     * https://github.com/w3c/html/issues/1457
39 |     * https://github.com/w3c/html/issues/1456
40 |   * implementation report
41 |     * http://w3c.github.io/test-results/html53/implementation-report.html
42 | 
43 | * Day 2 
44 |   * Tests
45 |   * HTML 52 vs HTML 53 diffs
46 |   * HTML 53 vs HTML LS diffs
47 |   * others
48 | 
49 | * Day 3 - W3C and WHATWG collaboration
50 | 
51 | 
52 | ## Logistics
53 | 
54 | <dl>
55 | <dt>Date(s)</dt>
56 | <dd>Tue 19th to Thu 21st June 2018</dd>
57 | <dt>Time</dt>
58 | <dd>9.30am to 5pm (each day)</dd>
59 | <dt>Venue</dt>
60 | <dd>
61 | [University of Applied Sciences](http://www.amsterdamuas.com/locations/hva-locations/theo-thijssen-building.html)<br>
62 | Wibautstraat 2-4<br>
63 | 1091 GM Amsterdam</dd>
64 | <dt>Rooms</dt>
65 | <dd>
66 | * Tuesday 19 June in room TTH 02A03
67 | * Wednesday 20 and Thursday in room TTH 05A13</dd>
68 | <dt>Contact</dt>
69 | <dd>Vasilis Van Gemert</dd>
70 | <dt>IRC</dt>
71 | <dd>irc.w3.org, #html</dd>
72 | <dt>Remote Participation</dt>
73 | <dd><a href="https://lists.w3.org/Archives/Member/w3c-archive/2018Jun/0178.html">WebEx info archived</a> (member-only space), or ask the chairs</dd>
74 | </dl>
75 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Constructor-004.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Invoking constructors with overloading</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.1.1 Interface object [[Call]] method
10 | //
11 | // In this test we're invoking constructors with overloading.  When too few
12 | // arguments are passed, a TypeError is thrown.  When too many arguments are
13 | // passed, the extra ones are ignored.  Candidate overloads are first chosen
14 | // based on how many arguments were passed.  Then, a specific argument is used
15 | // as the one that distinguishes between the different candidate overloads.
16 | // Values before this distinguishing argument are converted to IDL values before
17 | // the distinguishing argument is inspected.  Looking at the distinguishing
18 | // argument might then cause the call to fail (and a TypeError to be thrown) if
19 | // there is not an appropriate value passed in that position.
20 | //
21 | // With Blob, it's not possible to test the "arguments before the distinguishing 
22 | // argument are converted before possibly throwing due to an invalid value in that
23 | // argument position" since the distinguishing argument index is < 1.
24 | 
25 | // feature WebSocket (interface) (with [Constructor] and overloading)
26 | 
27 | test(function() {
28 |    assert_throws(new TypeError(), function() { var s = new WebSocket(); }); }, "passing no arguments to the WebSocket constructor fails");
29 | 
30 | // feature Blob (interface) (with [Constructor] and overloading)
31 | 
32 | test(function() {
33 |   var b = new Blob();
34 |   assert_equals(b.size, 0);
35 | }, "passing no arguments to the Blob constructor selects the () overload");
36 | 
37 | test(function() {
38 |   var b1 = new Blob([]);
39 |   var b2 = new Blob([], { });
40 |   assert_equals(b1.size, 0);
41 |   assert_equals(b1.type, b2.type);
42 | }, "passing an Array object as the only argument to the Blob constructor selects the (sequence<...>, optional BlobPropertyBag) overload");
43 | 
44 | test(function() {
45 |   var b = new Blob(["abc"], { }, "extra");
46 |   assert_equals(b.size, 3);
47 | }, "passing ([\"abc\"], { }, \"extra\") to the Blob constructor selects the (sequence<...>, optional BlobPropertyBag) overload");
48 | </script>
49 | 


--------------------------------------------------------------------------------
/meetings/16-07-28-29SW.md:
--------------------------------------------------------------------------------
 1 | <html>
 2 |  <head>
 3 |   <meta charset="utf-8">
 4 |   <title>28-29 July 2016 Service Workers meeting - W3C Web platform Working Group</title>
 5 |  </head>
 6 |  <body>
 7 | <h1>28-29 July 2016 Service Workers meeting - <a href="https://www.w3.org/WebPlatform/WG/">W3C Web platform Working Group</a></h1>
 8 | 
 9 | <p>This meeting will take place on 28-29 July 2016, and will be hosted by Mozilla in Toronto</p>
10 | 
11 | <h2>Expected attendees</h2>
12 | 
13 | <h3>Will attend</h3>
14 | 
15 |   <ul>
16 |     <li><strong>Mozilla</strong> - Ben Kelly, Ehsan Akhgari</li>
17 |     <li><strong>Microsoft</strong> - Ali Alabbas, Jatinder Mann</li>
18 |     <li><strong>Apple</strong> - Brady Eidson, Edward O'Connor, Sam Weinig</li>
19 |     <li><strong>Google</strong> - Jake Archibald, Marijn Kruisselbrink, Kenji Baheux</li>
20 |     <li><strong>Samsung</strong> - Jungkee Song</li>
21 |     <li><strong>Facebook</strong> - Nathan Schloss</li>
22 |   </ul>
23 | 
24 | <h3>Will attend remotely</h3>
25 |   <ul>
26 |   </ul>
27 | 
28 | <h3>Hope to attend</h3>
29 |   <ul>
30 |     <li>Chaals (chair, Yandex) - 28th only</li>
31 |   </ul>
32 | 
33 | <h2>Agenda</h2>
34 | 
35 |   <p>Please add your name, and agenda requests here by
36 |     <a href="https://github.com/w3c/WebPlatformWG/blob/gh-pages/meetings/28-29.md">
37 |     editing a branch and making a Pull Request
38 |     </a>,
39 |     or by mail to either the public-webapps mailing list or the chairs of the
40 |     Web Platform group, which will result in it being posted here.</p>
41 | 
42 |   <ul>
43 |     <li>[Version 1 issues](https://github.com/slightlyoff/ServiceWorker/issues?q=is%3Aopen+is%3Aissue+milestone%3A%22Version+1%22)</li>
44 |   </ul>
45 | 
46 | <h2>Background reading</h2>
47 | 
48 | <ul>
49 | </ul>
50 | 
51 | 
52 | <h2>Logistics</h2>
53 | 
54 | <dl>
55 |   <dt>Time</dt>
56 |   <dd>9am - 5pm on July 28-29</dd>
57 |   <dt>Location</dt>
58 |   <dd><strong>Mozilla Toronto</strong> (366 Adelaide St W, Suite 500) - please come up to the 5th floor and check in at the desk</dd>
59 |   <dd><strong>Recommended Hotel</strong> Hilton Garden Inn Toronto Downtown (92 Peter St)
60 | </dl>
61 | 
62 |   <h3>Remote Participants</h3>
63 | 
64 | <p>A vidyo meeting will be available, allowing connection either through vidyo client, or by ordinary telephone. Details to be confirmed.</p>
65 | 
66 | <p>IRC channel: irc://irc.w3.org/#webapps</p>
67 | 
68 | </body>
69 | </html>
70 | 


--------------------------------------------------------------------------------
/Newbie.md:
--------------------------------------------------------------------------------
 1 | This document includes some information for new members ("*Newbies*") of the Web Platform Working Group (WPWG).
 2 | 
 3 | Members of the WG, **especially new members** are encouraged to help maintain this document.
 4 | 
 5 | ## Welcome to the Web Platform Working Group
 6 | 
 7 | The Working Group's home page is: [https://www.w3.org/WebPlatform/WG/](https://www.w3.org/WebPlatform/WG/).
 8 | 
 9 | The group's *Work Mode* is described in the [*WorkMode*](WorkMode.md) document and it includes information about how the WG operates, including links to the WG's various resources.
10 | 
11 | Please note in particular these sections of the Work Mode document:
12 | 
13 | 1. [Group Participation and Communication](WorkMode.md#participation-and-communication)
14 | 
15 | 2. [Meetings? What Meeting?](WorkMode.md#meetings-what-meetings)
16 | 
17 | 3. [The Technical Reports Process. (What is an Editor's Draft)?](WorkMode.md#the-technical-reports-process-what-is-an-editors-draft)
18 | 
19 | 4. [Editor Policy: Write First and Review Later](WorkMode.md#editors)
20 | 
21 | 5. [Consensus and Call for Consensus (CfC)](WorkMode.md#consensus-and-call-for-consensus)
22 | 
23 | 6. Mail List Policies: [Usage and Etiquette](WorkMode.md#mail-list-policy-usage-etiquette-etc) and [Off-topic Discussion Policy](WorkMode.md#off-topic-discussion-policy)
24 | 
25 | ### Specifications in Progress
26 | 
27 | A list of the group's specifications, including the publication status of each spec, can be found in the group's *PubStatus* document: [<https://www.w3.org/WebPlatform/WG/PubStatus>](https://www.w3.org/WebPlatform/WG/PubStatus).
28 | 
29 | ### New WG Member Introductions
30 | 
31 | Although it isn't required, **new WG members are encouraged to send a short introductory e-mail to the WG's Public mail list** ([public-webapps@w3.org](https://lists.w3.org/Archives/Public/public-webapps/)) or the group's Member-only list ([member-webapps@w3.org](https://lists.w3.org/Archives/Member/member-webapps/)). The introduction should include your area(s) of interest.
32 | 
33 | ### Questions, Comments, Issues, etc.?
34 | 
35 | Please contact the group's Chairs and staff contacts (using the team-webplatform@w3.org list) - *at any time* - if you have any questions, issues, concerns, etc. about WebApps.
36 | 
37 | ### Resources
38 | 
39 | If you are unfamiliar with processes and roles within the Consortium; there is an [introduction course](http://lists.w3.org/Archives/Public/www-archive/2014Apr/0026.html) available which takes little over an hour and a half to complete.
40 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/named-properties-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Fixing objects that support named properties</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 | </div>
11 | 
12 | <script>
13 | // 4.7.1 Indexed and named properties
14 | //
15 | // Attempts to fix an object that supports named properties by calling
16 | // Object.freeze, Object.seal or Object.preventExtensions on it must fail and
17 | // throw a TypeError.
18 | 
19 | // feature: Storage (interface) (supports named properties)
20 | 
21 | test(function() {
22 |   var storage = document.getElementById("iframe").contentWindow.localStorage;
23 |   assert_throws(new TypeError(), function() { Object.freeze(storage); });
24 | }, "Object.freeze must fail on a Storage since it supports named properties");
25 | 
26 | test(function() {
27 |   var storage = document.getElementById("iframe").contentWindow.localStorage;
28 |   assert_throws(new TypeError(), function() { Object.seal(storage); });
29 | }, "Object.seal must fail on a Storage since it supports named properties");
30 | 
31 | test(function() {
32 |   var storage = document.getElementById("iframe").contentWindow.localStorage;
33 |   assert_throws(new TypeError(), function() { Object.preventExtensions(storage); });
34 | }, "Object.preventExtensions must fail on a Storage since it supports named properties");
35 | 
36 | 
37 | // feature: DOMStringMap (interface) (supports named properties)
38 | 
39 | test(function() {
40 |   var dataset = document.createElement("span").dataset;
41 |   assert_throws(new TypeError(), function() { Object.freeze(dataset); });
42 | }, "Object.freeze must fail on a DOMStringMap since it supports named properties");
43 | 
44 | test(function() {
45 |   var dataset = document.createElement("span").dataset;
46 |   assert_throws(new TypeError(), function() { Object.seal(dataset); });
47 | }, "Object.seal must fail on a DOMStringMap since it supports named properties");
48 | 
49 | test(function() {
50 |   var dataset = document.createElement("span").dataset;
51 |   assert_throws(new TypeError(), function() { Object.preventExtensions(dataset); });
52 | }, "Object.preventExtensions must fail on a DOMStringMap since it supports named properties");
53 | </script>
54 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Replaceable-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[Replaceable]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe1"></iframe>
10 |   <iframe id="iframe2"></iframe>
11 |   <iframe id="iframe3"></iframe>
12 |   <iframe id="iframe4"></iframe>
13 | </div>
14 | 
15 | <script>
16 | // 4.5.6 Attributes
17 | //
18 | // Read only attributes that are [Replaceable] allow themselves to be replaced
19 | // when you assign to them.
20 | 
21 | // feature: Window.self (attribute) (with [Replaceable])
22 | 
23 | test(function() {
24 |   var iframe = document.getElementById("iframe1");
25 |   var w = iframe.contentWindow;
26 | 
27 |   assert_equals(w, w.self);
28 |   w.self = "hello";
29 |   assert_equals(w.self, "hello");
30 | }, "assigning to Window.self will define a property on the window instance");
31 | 
32 | test(function() {
33 |   var iframe = document.getElementById("iframe2");
34 |   var w = iframe.contentWindow;
35 | 
36 |   w.self = "hello";
37 |   assert_true(delete w.self, "delete w.self");
38 |   assert_true(!w.hasOwnProperty("self"), "!w.hasOwnProperty(\"self\")");
39 | }, "replacing Window.self and deleting the property will result in no own property \"self\" on the window");
40 | 
41 | // feature: Window.length (attribute) (with [Replaceable])
42 | 
43 | test(function() {
44 |   var iframe = document.getElementById("iframe3");
45 |   var w = iframe.contentWindow;
46 | 
47 |   assert_equals(typeof w.length, "number");
48 |   w.length = "hello";
49 |   assert_equals(w.length, "hello");
50 | }, "assigning to Window.length will define a property on the window instance");
51 | 
52 | test(function() {
53 |   var iframe = document.getElementById("iframe4");
54 |   var w = iframe.contentWindow;
55 | 
56 |   w.length = "hello";
57 |   assert_true(delete w.length, "delete w.length");
58 |   assert_true(!w.hasOwnProperty("length"), "!w.hasOwnProperty(\"length\")");
59 | }, "replacing Window.length and deleting the property will result in no own property \"length\" on the window");
60 | 
61 | // XXX The only [Replaceable] attributes are on Window, and the way that
62 | // attributes are exposed on Window might change.  If the result is that
63 | // attributes should exist as accessor properties on the window instance,
64 | // we can add some tests for the setter.
65 | </script>
66 | 


--------------------------------------------------------------------------------
/Coordination.md:
--------------------------------------------------------------------------------
 1 | This document contains information about the relationships and coordination points between the [Web Platform WG](//www.w3.org/WebPlatform/WG/) (WPWG) and other Working Groups such as the [Device API WG](http://www.w3.org/2009/dap/) (aka DAP).
 2 | 
 3 | **WG charters formally define each WG's scope, deliverables, related groups, etc. The information in this document is superseded by the WGs' Charters.**
 4 | 
 5 | **The information is this page subject to change at any time. Members of the WGs mentioned here are encouraged to update this document. Pull requests should be submitted to [github](https://github.com/w3c/WebPlatformWG).**
 6 | 
 7 | CSS WG
 8 | ------
 9 | 
10 | The Web Platform WG and the CSS WG coordinate on the following:
11 | 
12 | -   [Shadow DOM](http://w3c.github.io/webcomponents/spec/shadow/) - see CSS WG's [CSS Scoping Module](http://dev.w3.org/csswg/shadow-styling/)
13 | 
14 | DAP WG
15 | ------
16 | 
17 | WPWG specifications do not include any normative references for any of DAP's specifications.
18 | 
19 | The following DAP specifications include one or more normative references to WPWG specs:
20 | 
21 | -   Several of DAP's API specs reference Web Platform' [Web IDL](http://dev.w3.org/2006/webapi/WebIDL/) spec
22 | -   DAP's [HTML Media Capture](http://dev.w3.org/2009/dap/camera/) spec has a non-normative reference to Web Platform' [File API](https://w3c.github.io/FileAPI/) spec
23 | 
24 | WebAppSec WG
25 | ------------
26 | 
27 | The Web Platform and WebAppSec WGs have the following spec as a joint deliverable:
28 | 
29 | -   [Cross-origin Resource Sharing](http://www.w3.org/TR/cors/) aka CORS
30 | 
31 | Web Annotations WG
32 | ------------------
33 | 
34 | The [Web Platform WG charter](//www.w3.org/2015/10/webplatform-charter.html), identifies the [FindText API](http://w3c.github.io/findtext/) as a joint deliverable with the [Web Annotations WG](//www.w3.org/annotation/).
35 | 
36 | Technical Architecture Group (TAG)
37 | ----------------------------------
38 | 
39 | WPWG and the TAG work together on the following specifications:
40 | 
41 | -   [W3C URL](http://w3ctag.github.io/url/)
42 | -   [Packaging on the Web](http://w3ctag.github.io/packaging-on-the-web/)
43 | 
44 | References
45 | ----------
46 | 
47 | References:
48 | 
49 | -   [Web Platform WG Charter](https://www.w3.org/2015/10/webplatform-charter.html)
50 | -   [CSS WG Charter](http://www.w3.org/Style/2014/css-charter)
51 | -   [Device API (DAP) WG Charter](http://www.w3.org/2011/07/DeviceAPICharter)
52 | -   [Web Application Security WG Charter](http://www.w3.org/2015/03/webappsec-charter-2015.html) (aka WebAppSec)
53 | 
54 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Constructor-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[Constructor]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.1.1 Interface object [[Call]] method
10 | //
11 | // Interfaces with [Constructor] have a [[Call]] method that invokes the
12 | // constructor behavior.  If it didn't have [Constructor], a TypeError is
13 | // thrown.  The returned object must implement the interface.  There must
14 | // also be a "length" property on the interface object.
15 | 
16 | // feature: Element (interface) (without [Constructor])
17 | 
18 | test(function() {
19 |   assert_throws(new TypeError(), function() { new Element(); }, "new Element()");
20 | }, "Calling new on an interface object whose interface does not have [Constructor]");
21 | 
22 | test(function() {
23 |   assert_throws(new TypeError(), function() { Element(); }, "Element()");
24 | }, "Calling method on interface object whose interface does not have [Constructor]");
25 | 
26 | 
27 | // feature: Event (interface) (with [Constructor])
28 | 
29 | test(function() {
30 |   assert_true(new Event("test") instanceof Event, "new Event(...) instanceof Event");
31 | }, "Event constructor returns an object that is instanceof Event");
32 | 
33 | test(function() {
34 |   assert_true(Event("test") instanceof Event, "Event(...) instanceof Event");
35 | }, "Event constructor called as a function returns an object that is instanceof Event");
36 | 
37 | // feature: XMLHttpRequest (interface) (with [Constructor])
38 | 
39 | test(function() {
40 |   assert_true(new XMLHttpRequest() instanceof XMLHttpRequest, "new XMLHttpRequest() instanceof XMLHttpRequest");
41 | }, "XMLHttpRequest constructor returns an object that is instanceof XMLHttpRequest");
42 | 
43 | test(function() {
44 |   assert_true(XMLHttpRequest() instanceof XMLHttpRequest, "XMLHttpRequest() instanceof XMLHttpRequest");
45 | }, "XMLHttpRequest constructor called as a function returns an object that is instanceof XMLHttpRequest");
46 | 
47 | var lengthProperties = [
48 |   "Event", 1,
49 |   "XMLHttpRequest", 0
50 | ];
51 | 
52 | for (var i = 0; i < lengthProperties.length; i += 2) {
53 |   var intf = lengthProperties[i];
54 |   var val = lengthProperties[i + 1];
55 | 
56 |   test(function() {
57 |     assert_property(window[intf], "length", { writable: false, enumerable: false, configurable: true, value: val }, intf + ".length");
58 |   }, intf + " has correct length property");
59 | }
60 | </script>
61 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/operation-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Regular operations</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.7 Operations
10 | //
11 | // Regular operations correspond to properties on the interface prototype
12 | // object, which are writable, enumerable and configurable.  If they're on
13 | // the [Global] object, then the properties will be on the instance instead.
14 | // The .length property on the Function object is the shortest valid argument
15 | // for the operation.
16 | 
17 | var operations = [
18 | 
19 |   // feature: HTMLElement.click (operation)
20 |   "HTMLElement", "click", 0,
21 | 
22 |   // feature: Node.appendChild (operation)
23 |   "Node", "appendChild", 1,
24 | 
25 |   // feature: DOMTokenList.add (operation) (variadic)
26 |   "DOMTokenList", "add", 0,
27 | 
28 |   // feature: DOMImplementation.createHTMLDocument (operation) (with optional argument)
29 |   "DOMImplementation", "createHTMLDocument", 0,
30 | 
31 |   // feature: Node.cloneNode (operation) (with optional argument default value)
32 |   "Node", "cloneNode", 0,
33 | 
34 |   // feature: HTMLSelectElement.add (operation) (with optional argument default value)
35 |   "HTMLSelectElement", "add", 1,
36 | 
37 |   // feature: CanvasRenderingContext2D.drawImage (operation) (overloaded)
38 |   "CanvasRenderingContext2D", "drawImage", 3,
39 | 
40 |   // feature: FormData.append (operation) (overloaded)
41 |   "FormData", "append", 2
42 | ];
43 | 
44 | function operationHome(intf) {
45 | }
46 | 
47 | function operationHomeName(intf) {
48 | }
49 | 
50 | for (var i = 0; i < operations.length; i+= 3) {
51 |   var intf = operations[i];
52 |   var name = operations[i + 1];
53 |   var length = operations[i + 2];
54 |   var object = interfaceMemberHome(intf);
55 |   var objectName = interfaceMemberHomeName(intf);
56 | 
57 |   test(function() {
58 |     assert_property(object, name, { writable: true, enumerable: true, configurable: true });
59 |   }, "the " + objectName + " " + name + " property has the right attributes");
60 | 
61 |   test(function() {
62 |     assert_equals(typeof window[intf].prototype[name], "function");
63 |   }, objectName + " " + name + " property is a function");
64 | 
65 |   test(function() {
66 |     assert_property(window[intf].prototype[name], "length", { writable: false, enumerable: false, configurable: false, value: length });
67 |   }, objectName + " " + name + ".length  has correct length property");
68 | }
69 | </script>
70 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/Constructor-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Invoking constructors without overloading but with optional arguments</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.1.1 Interface object [[Call]] method
10 | //
11 | // In this test we're invoking constructors with no overloading but which
12 | // do have optional arguments.  When too few arguments are passed, a TypeError
13 | // is thrown.  When too many arguments are passed, the extra ones are ignored.
14 | // Argument types are not used to eliminate the single entry in the effective
15 | // overload set that remains after discarding others due to incorrect argument
16 | // list length.  Optional argument default values are also filled in for
17 | // trailing missing arguments.
18 | 
19 | // feature: Event (interface) (with [Constructor] and optional arguments)
20 | 
21 | test(function() {
22 |   assert_throws(new TypeError(), function() { new Event(); });
23 | }, "passing too few arguments to Event constructor throws");
24 | 
25 | test(function() {
26 |   var e1 = new Event("click");
27 |   var e2 = new Event("click", { });
28 |   var e3 = new Event("click", null);
29 |   assert_equals(e1.bubbles, e2.bubbles);
30 |   assert_equals(e1.cancelable, e2.cancelable);
31 |   assert_equals(e1.bubbles, e3.bubbles);
32 |   assert_equals(e1.cancelable, e3.cancelable);
33 | }, "passing one argument to Event constructor will use the default argument value");
34 | 
35 | test(function() {
36 |   assert_throws(new TypeError(), function() { new Event("click", false); });
37 | }, "passing a bad type as the Event constructor optional argument value throws an exception");
38 | 
39 | test(function() {
40 |   var e = new Event("click", { }, "ignored");
41 |   assert_true(!!e);
42 | }, "extra arguments passed to Event constructor are ignored");
43 | 
44 | // feature: WebSocket (interface) (with [Constructor] and optional arguments)
45 | 
46 | test(function() {
47 |   assert_throws(new TypeError(), function() { new WebSocket(); });
48 | }, "passing too few arguments to WebSocket constructor throws");
49 | 
50 | test(function() {
51 |   var ws = new WebSocket("wss://test.invalid");
52 |   assert_true(!!ws);
53 | }, "omitting an optional argument in the WebSocket constructor works");
54 | 
55 | test(function() {
56 |   var ws = new WebSocket("wss://test.invalid", "protocol", "ignored");
57 |   assert_true(!!ws);
58 | }, "additional arguments passed to the WebSocket constructor are ignored");
59 | </script>
60 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/instanceof-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[[HasInstance]]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 | </div>
11 | 
12 | <script>
13 | // 4.5.1.2. Interface object [[HasInstance]] method
14 | //
15 | // The [[HasInstance]] method of interface objects check whether a platform
16 | // object implements the interface.  This works across different global
17 | // environments.
18 | 
19 | var w = document.getElementById("iframe").contentWindow;
20 | 
21 | // feature: DOMImplementation (interface)
22 | 
23 | test(function() {
24 |   assert_true(document.implementation instanceof DOMImplementation);
25 | }, "a DOMImplementation object is considered to be instanceof window.DOMImplementation");
26 | 
27 | test(function() {
28 |   assert_true(document.implementation instanceof w.DOMImplementation);
29 | }, "a DOMImplementation object is considered to be instanceof anotherWindow.DOMImplementation");
30 | 
31 | test(function() {
32 |   var object = Object.create(document.implementation);
33 |   assert_true(object instanceof DOMImplementation);
34 | }, "an object whose [[Prototype]] is DOMImplementation.prototype is considered to be instanceof window.DOMImplementation");
35 | 
36 | test(function() {
37 |   var object = Object.create(document.implementation);
38 |   assert_true(object instanceof w.DOMImplementation);
39 | }, "an object whose [[Prototype]] is DOMImplementation.prototype is considered to be instanceof anotherWindow.DOMImplementation");
40 | 
41 | // feature: Element (interface)
42 | 
43 | var div = document.createElement("div");
44 | 
45 | test(function() {
46 |   assert_true(div instanceof Element);
47 | }, "an HTMLDivElement object is considered to be instanceof window.Element");
48 | 
49 | test(function() {
50 |   assert_true(div instanceof w.Element);
51 | }, "an HTMLDivElement object is considered to be instanceof anotherWindow.Element");
52 | 
53 | test(function() {
54 |   var object = Object.create(div);
55 |   assert_true(object instanceof Element);
56 | }, "an object whose [[Prototype]] is HTMLDivElement.prototype is considered to be instanceof window.Element");
57 | 
58 | test(function() {
59 |   var object = Object.create(div);
60 |   assert_true(object instanceof w.Element);
61 | }, "an object whose [[Prototype]] is HTMLDivElement.prototype is considered to be instanceof anotherWindow.Element");
62 | </script>
63 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/utils.js:
--------------------------------------------------------------------------------
 1 | // Utility functions for Web IDL tests.
 2 | 
 3 | function interfaceObject(interfaceName, w) {
 4 |   return function() { return (w || window)[interfaceName]; }
 5 | }
 6 | 
 7 | function interfacePrototypeObject(interfaceName, w) {
 8 |   return function() { return (w || window)[interfaceName].prototype; }
 9 | }
10 | 
11 | function namedConstructorObject(constructorName, w) {
12 |   return function() { return (w || window)[constructorName]; }
13 | }
14 | 
15 | function getter(interfaceName, attributeName, w) {
16 |   return function() { return Object.getOwnPropertyDescriptor((w || window)[interfaceName].prototype, attributeName).get; }
17 | }
18 | 
19 | function setter(interfaceName, attributeName, w) {
20 |   return function() { return Object.getOwnPropertyDescriptor((w || window)[interfaceName].prototype, attributeName).set; }
21 | }
22 | 
23 | function operation(interfaceName, operationName, w) {
24 |   return function() { return Object.getOwnPropertyDescriptor((w || window)[interfaceName].prototype, operationName).value; }
25 | }
26 | 
27 | function staticOperation(interfaceName, operationName, w) {
28 |   return function() { return Object.getOwnPropertyDescriptor((w || window)[interfaceName], operationName).value; }
29 | }
30 | 
31 | function stringifier(interfaceName, w) {
32 |   return operation(interfaceName, "toString", w);
33 | }
34 | 
35 | function assert_descriptor(desc1, desc2, description) {
36 |   description = description || "property";
37 |   assert_true(!!desc1, description + " exists");
38 |   if ("value" in desc2) {
39 |     assert_equals(desc1.value, desc2.value, description + " [[Value]]");
40 |   }
41 |   if ("writable" in desc2) {
42 |     assert_equals(desc1.writable, desc2.writable, description + " [[Writable]]");
43 |   }
44 |   if ("enumerable" in desc2) {
45 |     assert_equals(desc1.enumerable, desc2.enumerable, description + " [[Enumerable]]");
46 |   }
47 |   if ("configurable" in desc2) {
48 |     assert_equals(desc1.configurable, desc2.configurable, description + " [[Configurable]]");
49 |   }
50 | }
51 | 
52 | function assert_property(object, property, desc, description) {
53 |   assert_descriptor(Object.getOwnPropertyDescriptor(object, property), desc, description);
54 | }
55 | 
56 | function prototypeChain(o) {
57 |   var a = [];
58 |   do {
59 |     a.push(o);
60 |     o = Object.getPrototypeOf(o);
61 |   } while (o);
62 |   return a;
63 | }
64 | 
65 | function interfaceMemberHome(intf) {
66 |   if (intf == 'Window') {
67 |     return window;
68 |   }
69 |   return window[intf].prototype;
70 | }
71 | 
72 | function interfaceMemberHomeName(intf) {
73 |   if (intf == 'Window') {
74 |     return "window instance";
75 |   }
76 |   return intf + ".prototype";
77 | }
78 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/NamedConstructor-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[NamedConstructor]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.2 Named constructors
10 | //
11 | // Interfaces with [NamedConstructor] have a function on the global that
12 | // can be called or constructed.  The returned object must implement the
13 | // interface.  There must also be a "length" property on the interface object.
14 | // And they have a "prototype" property pointing to the interface prototype
15 | // object.
16 | 
17 | // feature: HTMLImageElement (interface) (with [NamedConstructor])
18 | 
19 | test(function() {
20 | }, "Image named constructor exists with the right attributes");
21 | 
22 | test(function() {
23 |   assert_true(new Image() instanceof HTMLImageElement, "new Image() instanceof HTMLImageElement");
24 | }, "Image named constructor returns an object that is instanceof HTMLImageElement");
25 | 
26 | test(function() {
27 |   assert_true(Image() instanceof HTMLImageElement, "Image() instanceof HTMLImageElement");
28 | }, "Image named constructor called as a function returns an object that is instanceof HTMLImageElement");
29 | 
30 | // feature: HTMLAudioElement (interface) (with [NamedConstructor])
31 | 
32 | test(function() {
33 |   assert_true(new Audio() instanceof HTMLAudioElement, "new Audio() instanceof HTMLAudioElement");
34 | }, "Audio named constructor returns an object that is instanceof HTMLAudioElement");
35 | 
36 | test(function() {
37 |   assert_true(Audio() instanceof HTMLAudioElement, "Audio() instanceof HTMLAudioElement");
38 | }, "Audio named constructor called as a function returns an object that is instanceof HTMLAudioElement");
39 | 
40 | var lengthProperties = [
41 |   "Image", 0, "HTMLImageElement",
42 |   "Audio", 0, "HTMLAudioElement"
43 | ];
44 | 
45 | for (var i = 0; i < lengthProperties.length; i += 3) {
46 |   var named = lengthProperties[i];
47 |   var val = lengthProperties[i + 1];
48 |   var intf = lengthProperties[i + 2];
49 | 
50 |   test(function() {
51 |     assert_property(window, named, { writable: true, enumerable: false, configurable: true }, "window." + named);
52 |   }, named + " named constructor exists");
53 |   test(function() {
54 |     assert_property(window[named], "length", { writable: false, enumerable: false, configurable: true, value: val }, named + ".length");
55 |   }, named + " has correct length property");
56 |   test(function() {
57 |     assert_property(window[named], "prototype", { writable: false, enumerable: false, configurable: false, value: window[intf].prototype }, named + ".prototype");
58 |   }, named + " has correct prototype property");
59 | }
60 | </script>
61 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/interface-type-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Interface types for regular interfaces</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.18 Interface types
10 | //
11 | // If the value being converted to an interface type is not an object, a
12 | // TypeError exception is thrown.
13 | //
14 | // For a regular interface, only a platform object that implements the
15 | // interface will be accepted.
16 | 
17 | function runTests() {
18 |   var iframe = document.getElementById("iframe");
19 | 
20 |   var object = { };
21 |   var array = [];
22 |   var regexp = /abc/;
23 |   var span = document.createElement("span");
24 |   var fakeSpan = Object.create(span);
25 |   var fakeNode = Object.create(Node.prototype);
26 |   var otherSpan = iframe.contentDocument.createElement("span");
27 | 
28 |   var values = [
29 |     undefined,                  undefined,  "undefined",
30 |     null,                       undefined,  "null",
31 |     false,                      undefined,  "false",
32 |     0,                          undefined,  "0",
33 |     "",                         undefined,  '""',
34 |     window,                     undefined,  "window",
35 |     object,                     undefined,  "{ }",
36 |     array,                      undefined,  "[]",
37 |     regexp,                     undefined,  "/abc/",
38 |     span,                       span,       "an HTMLSpanElement object",
39 |     HTMLSpanElement,            undefined,  "HTMLSpanElement",
40 |     HTMLSpanElement.prototype,  undefined,  "HTMLSpanElement.prototype",
41 |     fakeSpan,                   undefined,  "fakeSpan",
42 |     fakeNode,                   undefined,  "fakeNode",
43 |     otherSpan,                  otherSpan,  "otherSpan"
44 |   ];
45 | 
46 |   // feature: Node.appendChild (operation) (with argument of an interface type)
47 | 
48 |   for (var i = 0; i < values.length; i += 3) {
49 |     var value = values[i];
50 |     var expected = values[i + 1];
51 |     var desc = values[i + 2];
52 | 
53 |     test(function() {
54 |       if (expected !== undefined) {
55 |         var div = document.createElement("div");
56 |         div.appendChild(value);
57 |         assert_equals(div.firstChild, expected);
58 |       } else {
59 |         assert_throws(new TypeError(), function() { div.appendChild(value); });
60 |       }
61 |     }, "passing " + desc + " to Node.appendChild() correctly converts to an IDL Node value");
62 |   }
63 | }
64 | </script>
65 | 
66 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
67 |   <iframe id="iframe" onload="runTests()"></iframe>
68 | </div>
69 | 
70 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/callback-function-type-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Callback function types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.21 Callback function types
10 | //
11 | // Anything that isn't callable is a TypeError.
12 | 
13 | // feature: GlobalEventHandlers.onclick (attribute) (writable, of a callback function type)
14 | 
15 | async_test(function(t) {
16 |   var invoked = false;
17 |   var span = document.createElement("span");
18 |   span.onclick = function() { invoked = true; };
19 |   span.addEventListener("click", function() { t.step(function() { assert_true(invoked); t.done(); }); }, false);
20 |   var event = document.createEvent("Event");
21 |   event.initEvent("click", false, false);
22 |   span.dispatchEvent(event);
23 | }, "assigning a Function object to HTMLElement.onclick converts to an IDL callback function type correctly");
24 | 
25 | async_test(function(t) {
26 |   var invoked = false;
27 |   var span = document.createElement("span");
28 |   span.onclick = function(e) { var callbackThis = this; t.step(function() { assert_equals(callbackThis, e.currentTarget); t.done(); }); };
29 |   var event = document.createEvent("Event");
30 |   event.initEvent("click", false, false);
31 |   span.dispatchEvent(event);
32 | }, "callback this value set appropriately for HTMLElement.onclick callback function");
33 | 
34 | test(function() {
35 |   var span = document.createElement("span");
36 |   span.onclick = Node.prototype.appendChild;
37 |   assert_equals(span.onclick, Node.prototype.appendChild);
38 | }, "assigning Node.prototype.appendChild converts to an IDL callback function type correctly");
39 | 
40 | test(function() {
41 |   var span = document.createElement("span");
42 |   span.onclick = Image;
43 |   assert_equals(span.onclick, Image);
44 | }, "assigning Image converts to an IDL callback function type correctly");
45 | 
46 | test(function() {
47 |   var span = document.createElement("span");
48 |   var obj = { };
49 |   span.onclick = obj;
50 |   assert_equals(span.onclick, obj); // because of [[TreatNonObjectAsNull]]
51 | }, "assigning { } converts to an IDL callback function type correctly");
52 | 
53 | test(function() {
54 |   var span = document.createElement("span");
55 |   var array = [];
56 |   span.onclick = array;
57 |   assert_equals(span.onclick, array); // because of [[TreatNonObjectAsNull]]
58 | }, "assigning [] converts to an IDL callback function type correctly");
59 | 
60 | test(function() {
61 |   var span = document.createElement("span");
62 |   span.onclick = 123;
63 |   assert_equals(span.onclick, null);
64 | }, "assigning 123 converts to an IDL callback function type correctly");
65 | </script>
66 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/enum-type-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Enumeration types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="evenodd" class="evenodd"></div>
 9 | 
10 | <script>
11 | // 4.2.20 Enumeration types
12 | //
13 | // Converting a JS value to an IDL enumeration type involves:
14 | //   - converting the value with ToString()
15 | //   - throwing a TypeError if it not a valid enumerated value, except when
16 | //     assigning to an attribute, in which case the assignment is ignored
17 | 
18 | // feature: CanvasRenderingContext2D.fill (operation, with argument of an enum type)
19 | 
20 | function drawAndGetPixel(rule) {
21 |   var e = document.createElement("canvas");
22 |   e.width = 40;
23 |   e.height = 40;
24 |   var c = e.getContext("2d");
25 |   c.rect(0, 0, 40, 40);
26 |   c.rect(10, 10, 20, 20);
27 |   c.fill(rule);
28 |   var i = c.getImageData(20, 20, 1, 1);
29 |   return i.data[3];
30 | }
31 | 
32 | test(function() {
33 |   assert_equals(drawAndGetPixel("nonzero"), 255);
34 | }, "passing \"nonzero\" to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
35 | 
36 | test(function() {
37 |   assert_equals(drawAndGetPixel("evenodd"), 0);
38 | }, "passing \"evenodd\" to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
39 | 
40 | test(function() {
41 |   assert_throws(new TypeError(), function() { drawAndGetPixel("evenodd "); });
42 | }, "passing \"evenodd \" to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
43 | 
44 | test(function() {
45 |   assert_throws(new TypeError(), function() { drawAndGetPixel("Evenodd"); });
46 | }, "passing \"Evenodd\" to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
47 | 
48 | test(function() {
49 |   assert_equals(drawAndGetPixel({ toString: function() { return "nonzero"; } }), 255);
50 | }, "passing { toString: ... \"nonzero\" } to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
51 | 
52 | test(function() {
53 |   assert_equals(drawAndGetPixel({ toString: function() { return "evenodd"; } }), 0);
54 | }, "passing { toString: ... \"evenodd\" } to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
55 | 
56 | test(function() {
57 |   assert_throws({ name: "SomeError" }, function() { drawAndGetPixel({ toString: function() { throw { name: "SomeError" }; } }); });
58 | }, "passing { toString: ... throw } to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
59 | 
60 | test(function() {
61 |   assert_equals(drawAndGetPixel(document.getElementById("evenodd").classList), 0);
62 | }, "passing DOMTokenList to CanvasRenderingContext2D.fill() converts to the CanvasFillRule enum correctly");
63 | </script>
64 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/indexed-properties-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Indexed properties</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.7.2 Platform object [[GetOwnProperty]] method
10 | //
11 | // If an object supports indexed properties, then own properties exist on the
12 | // object corresponding to the supported property indexes.  Each property is
13 | // exposed through [[GetOwnProperty]] as being enumerable, configurable,
14 | // and writable if there is also an indexed property setter.
15 | 
16 | // feature: NodeList (indexed property getter) (does not have an indexed property setter)
17 | 
18 | function makeSpan() {
19 |   var e = document.createElement("span");
20 |   e.appendChild(document.createElement("span"));
21 |   e.appendChild(document.createElement("span"));
22 |   return e;
23 | }
24 | 
25 | test(function() {
26 |   var span = makeSpan();
27 |   var nl = span.childNodes;
28 |   assert_property(nl, "0", { writable: false, enumerable: true, configurable: true, value: span.firstChild });
29 | }, "NodeList indexed property has correct attributes and value");
30 | 
31 | test(function() {
32 |   var span = makeSpan();
33 |   var nl = span.childNodes;
34 |   assert_true(!nl.hasOwnProperty(2));
35 | }, "NodeList property corresponding to a non-existent supported property index does not exist");
36 | 
37 | test(function() {
38 |   var span = makeSpan();
39 |   var nl = span.childNodes;
40 |   try {
41 |     NodeList.prototype[2] = "hello";
42 |     assert_equals(nl[2], "hello");
43 |   } finally {
44 |     delete NodeList.prototype[2];
45 |   }
46 | }, "NodeList allows properties with names that are array index property names to show through from the prototype");
47 | 
48 | 
49 | // feature: HTMLSelectElement (indexed property getter) (has an indexed property setter)
50 | 
51 | function makeSelect() {
52 |   var e = document.createElement("select");
53 |   e.appendChild(document.createElement("option"));
54 |   e.appendChild(document.createElement("option"));
55 |   return e;
56 | }
57 | 
58 | test(function() {
59 |   var select = makeSelect();
60 |   assert_property(select, "0", { writable: true, enumerable: true, configurable: true, value: select.firstChild });
61 | }, "HTMLSelectElement indexed property has correct attributes and value");
62 | 
63 | test(function() {
64 |   var select = makeSelect();
65 |   assert_true(!select.hasOwnProperty(2));
66 | }, "HTMLSelectElement property corresponding to a non-existent supported property index does not exist");
67 | 
68 | test(function() {
69 |   var select = makeSelect();
70 |   try {
71 |     HTMLSelectElement.prototype[2] = "hello";
72 |     assert_equals(select[2], "hello");
73 |   } finally {
74 |     delete HTMLSelectElement.prototype[2];
75 |   }
76 | }, "HTMLSelectElement allows properties with names that are array index property names to show through from the prototype");
77 | </script>
78 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/interface-type-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Interface types for regular interfaces</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.18 Interface types
10 | //
11 | // If the value being converted to an interface type is not an object, a
12 | // TypeError exception is thrown.
13 | //
14 | // For a regular interface, only a platform object that implements the
15 | // interface will be accepted.
16 | 
17 | function runTests() {
18 |   var iframe = document.getElementById("iframe");
19 | 
20 |   var object = { };
21 |   var array = [];
22 |   var regexp = /abc/;
23 |   var matrix = document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGMatrix();
24 |   var fakeMatrix1 = Object.create(matrix);
25 |   var fakeMatrix2 = Object.create(SVGMatrix.prototype);
26 |   var fakeMatrix3 = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
27 |   var otherMatrix = iframe.contentDocument.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGMatrix();
28 | 
29 |   var values = [
30 |     undefined,                  undefined,  "undefined",
31 |     null,                       undefined,  "null",
32 |     false,                      undefined,  "false",
33 |     0,                          undefined,  "0",
34 |     "",                         undefined,  '""',
35 |     window,                     undefined,  "window",
36 |     object,                     undefined,  "{ }",
37 |     array,                      undefined,  "[]",
38 |     regexp,                     undefined,  "/abc/",
39 |     matrix,                     SVGPoint,   "an SVGMatrix object",
40 |     SVGMatrix,                  undefined,  "SVGMatrix",
41 |     SVGMatrix.prototype,        undefined,  "SVGMatrix.prototype",
42 |     fakeMatrix1,                undefined,  "fakeMatrix1",
43 |     fakeMatrix2,                undefined,  "fakeMatrix2",
44 |     fakeMatrix3,                undefined,  "fakeMatrix3",
45 |     otherMatrix,                SVGPoint,   "otherMatrix"
46 |   ];
47 | 
48 |   // feature: SVGPoint.matrixTransform (operation) (with argument of an interface type)
49 | 
50 |   for (var i = 0; i < values.length; i += 3) {
51 |     var value = values[i];
52 |     var expected = values[i + 1];
53 |     var desc = values[i + 2];
54 | 
55 |     test(function() {
56 |       var point = document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGPoint();
57 |       if (expected !== undefined) {
58 |         assert_true(point.matrixTransform(value) instanceof expected);
59 |       } else {
60 |         assert_throws(new TypeError(), function() { point.matrixTransform(point); });
61 |       }
62 |     }, "passing " + desc + " to SVGPoint.matrixTransform() correctly converts to an IDL SVGMatrix value");
63 |   }
64 | }
65 | </script>
66 | 
67 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
68 |   <iframe id="iframe" onload="runTests()"></iframe>
69 | </div>
70 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/exception-interface-object-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Exception interface object [[Call]] method</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.9.1.1 Exception interface object [[Call]] method
10 | //
11 | // When called, exception interface objects construct and return a new
12 | // platform exception object.
13 | 
14 | // feature: DOMException (exception)
15 | 
16 | test(function() {
17 |   var e = new DOMException();
18 |   assert_equals(Object.getPrototypeOf(e), DOMException.prototype);
19 | }, "DOMException object returned from DOMException constructor has the right prototype");
20 | 
21 | test(function() {
22 |   assert_throws(new TypeError(), function () { 
23 |     var e = DOMException(); 
24 |     assert_equals(Object.getPrototypeOf(e), DOMException.prototype);
25 |   });
26 | }, "DOMException called without new throws");//See issue: https://github.com/heycam/webidl/issues/62
27 | 
28 | test(function() {
29 |   var e = new DOMException();
30 |   assert_equals(e.message, "");
31 |   assert_true(!e.hasOwnProperty("message"));
32 | }, "constructing a DOMException with no arguments does not set a message property");
33 | 
34 | test(function() {
35 |   var e = new DOMException();
36 |   assert_equals(e.message, "");
37 |   assert_true(!e.hasOwnProperty("message"));
38 | }, "calling DOMException with no arguments returns a DOMException object without a message property");
39 | 
40 | test(function() {
41 |   var e = new DOMException({ toString: function() { return "test"; } });
42 |   assert_property(e, "message", { writable: true, enumerable: false, configurable: true, value: "test" });
43 | }, "constructing a DOMException with one argument sets its message property correctly");
44 | 
45 | test(function() {
46 |   var e = new DOMException("test", "myname");
47 |   assert_property(e, "message", { writable: true, enumerable: false, configurable: true, value: "test" });
48 |   assert_property(e, "name", { writable: true, enumerable: false, configurable: true, value: "myname" });
49 |   assert_property(e, "code", { writable: true, enumerable: false, configurable: true, value: 0 });
50 | }, "constructing a DOMException with two arguments sets message, name, and code correctly");
51 | 
52 | test(function() {
53 |   var e = new DOMException("test", "SyntaxError");
54 |   assert_property(e, "message", { writable: true, enumerable: false, configurable: true, value: "test" });
55 |   assert_property(e, "name", { writable: true, enumerable: false, configurable: true, value: "SyntaxError" });
56 |   assert_property(e, "code", { writable: true, enumerable: false, configurable: true, value: 12 });
57 | }, "constructing a DOMException with known name sets code correctly");
58 | 
59 | test(function() {
60 |   var e = new DOMException("test", "myname", "extra");
61 |   assert_equals(e.hasOwnProperty("extra"), false);
62 | }, "additional argument passed to DOMException constructor is ignored");
63 | </script>
64 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/LenientThis-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>[LenientThis]</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.5.6 Attributes
10 | //
11 | // If [LenientThis] is on an attribute, invoking an attribute getter/setter
12 | // with an invalid this object will cause the function to return without
13 | // doing anything.
14 | 
15 | function noop1() { }
16 | function noop2() { }
17 | 
18 | // feature: Document.onreadystatechange (attribute) (with [LenientThis])
19 | 
20 | test(function() {
21 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "onreadystatechange");
22 | 
23 |   document.onreadystatechange = noop1;
24 |   assert_equals(document.onreadystatechange, noop1, "document.onreadystatechange == noop1");
25 | 
26 |   assert_true(!!desc, "Document.prototype.onreadystatechange");
27 |   assert_equals(desc.get.call({ }), undefined, "document.onreadystatechange getter.call({}) == undefined");
28 | }, "invoking Document.onreadystatechange's getter with an invalid this object returns undefined");
29 | 
30 | test(function() {
31 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "onreadystatechange");
32 | 
33 |   document.onreadystatechange = noop1;
34 |   assert_equals(document.onreadystatechange, noop1, "document.onreadystatechange == noop1");
35 | 
36 |   assert_true(!!desc, "Document.prototype.onreadystatechange");
37 |   assert_equals(desc.set.call({ }, noop2), undefined, "document.onreadystatechange setter.call({}) == undefined");
38 |   assert_equals(document.onreadystatechange, noop1, "document.onreadystatechange == noop1 (still)");
39 | }, "invoking Document.onreadystatechange's setter with an invalid this object does nothing and returns undefined");
40 | 
41 | // feature: GlobalEventHandlers.onmouseenter (attribute) (with [LenientThis])
42 | 
43 | test(function() {
44 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "onmouseenter");
45 | 
46 |   document.onmouseenter = noop1;
47 |   assert_equals(document.onmouseenter, noop1, "document.onmouseenter == noop1");
48 | 
49 |   assert_true(!!desc, "Document.prototype.onmouseenter");
50 |   assert_equals(desc.get.call({ }), undefined, "document.onmouseenter getter.call({}) == undefined");
51 | }, "invoking GlobalEventHandlers.onmouseenter's getter with an invalid this object returns undefined");
52 | 
53 | test(function() {
54 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "onmouseenter");
55 | 
56 |   document.onmouseenter = noop1;
57 |   assert_equals(document.onmouseenter, noop1, "document.onmouseenter == noop1");
58 | 
59 |   assert_true(!!desc, "Document.prototype.onmouseenter");
60 |   assert_equals(desc.set.call({ }, noop2), undefined, "document.onmouseenter setter.call({}) == undefined");
61 |   assert_equals(document.onmouseenter, noop1, "document.onmouseenter == noop1 (still)");
62 | }, "invoking GlobalEventHandlers.onmouseenter's setter with an invalid this object does nothing and returns undefined");
63 | </script>
64 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/callback-function-type-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Callback function types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.21 Callback function types
10 | //
11 | // Anything that isn't callable is a TypeError.
12 | 
13 | // feature: MutationObserver (interface) (with [Constructor] with argument of a callback function type)
14 | 
15 | async_test(function(t) {
16 |   var invoked = false;
17 |   var span = document.createElement("span");
18 |   var obs1 = new MutationObserver(function() { invoked = true; });
19 |   var obs2 = new MutationObserver(function() { t.step(function() { assert_true(invoked); t.done(); }); });
20 |   obs1.observe(span, { attributes: true });
21 |   obs2.observe(span, { attributes: true });
22 |   span.setAttribute("data-test", "value");
23 | }, "passing a Function object to the MutationObserver constructor converts to an IDL callback function type correctly");
24 | 
25 | async_test(function(t) {
26 |   var span = document.createElement("span");
27 |   var obs = new MutationObserver(function() { var callbackThis = this; t.step(function() { assert_equals(callbackThis, obs); t.done(); }); });
28 |   obs.observe(span, { attributes: true });
29 |   span.setAttribute("data-test", "value");
30 | }, "callback this value set appropriately for MutationObserver callback function");
31 | 
32 | test(function() {
33 |   assert_throws(new TypeError(), function() { new MutationObserver(undefined); });
34 | }, "passing undefined to the MutationObserver constructor coverts to an IDL callback function type correctly");
35 | 
36 | test(function() {
37 |   assert_throws(new TypeError(), function() { new MutationObserver(null); });
38 | }, "passing null to the MutationObserver constructor coverts to an IDL callback function type correctly");
39 | 
40 | test(function() {
41 |   assert_throws(new TypeError(), function() { new MutationObserver(true); });
42 | }, "passing true to the MutationObserver constructor coverts to an IDL callback function type correctly");
43 | 
44 | test(function() {
45 |   assert_throws(new TypeError(), function() { new MutationObserver(123); });
46 | }, "passing 123 to the MutationObserver constructor coverts to an IDL callback function type correctly");
47 | 
48 | test(function() {
49 |   assert_throws(new TypeError(), function() { new MutationObserver("abc"); });
50 | }, "passing \"abc\" to the MutationObserver constructor coverts to an IDL callback function type correctly");
51 | 
52 | test(function() {
53 |   assert_throws(new TypeError(), function() { new MutationObserver({ }); });
54 | }, "passing { } to the MutationObserver constructor coverts to an IDL callback function type correctly");
55 | 
56 | test(function() {
57 |   new MutationObserver(Node.prototype.appendChild);
58 | }, "passing Node.prototype.appendChild to the MutationObserver constructor converts to an IDL callback function type correctly");
59 | 
60 | test(function() {
61 |   new MutationObserver(Image);
62 | }, "passing Image to the MutationObserver constructor converts to an IDL callback function type correctly");
63 | </script>
64 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/nullable-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Nullable types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.22 Nullable types – T?
10 | //
11 | // Except in the face of [TreatUndefinedAs] and [TreatNonCallableAs], JS
12 | // undefined and null values get converted to IDL null.
13 | 
14 | // feature: Node.textContext (attribute) (writable, of type DOMString?)
15 | 
16 | test(function() {
17 |   var span = document.createElement("span");
18 |   span.textContent = "test";
19 |   assert_equals(span.textContent, "test");
20 | }, "assigning a string to Node.textContent converts to an IDL \"DOMString?\" type correctly");
21 | 
22 | test(function() {
23 |   var span = document.createElement("span");
24 |   span.textContent = "test";
25 |   assert_equals(span.textContent, "test");
26 |   span.textContent = null;
27 |   assert_equals(span.textContent, "");
28 | }, "assigning null to Node.textContent converts to an IDL \"DOMString?\" type correctly");
29 | 
30 | test(function() {
31 |   var span = document.createElement("span");
32 |   span.textContent = "test";
33 |   assert_equals(span.textContent, "test");
34 |   span.textContent = undefined;
35 |   assert_equals(span.textContent, "");
36 | }, "assigning undefined to Node.textContent converts to an IDL \"DOMString?\" type correctly");
37 | 
38 | test(function() {
39 |   var span = document.createElement("span");
40 |   span.textContent = "test";
41 |   assert_equals(span.textContent, "test");
42 |   span.textContent = window;
43 |   assert_equals(span.textContent, "[object Window]");
44 | }, "assigning window to Node.textContent converts to an IDL \"DOMString?\" type correctly");
45 | 
46 | test(function() {
47 |   var span = document.createElement("span");
48 |   span.textContent = "test";
49 |   assert_equals(span.textContent, "test");
50 |   span.textContent = { toString: function() { return "hello"; } };
51 |   assert_equals(span.textContent, "hello");
52 | }, "assigning { toString: ... string } to Node.textContent converts to an IDL \"DOMString?\" type correctly");
53 | 
54 | test(function() {
55 |   var span = document.createElement("span");
56 |   span.textContent = "test";
57 |   assert_equals(span.textContent, "test");
58 |   span.textContent = { toString: function() { return null; } };
59 |   assert_equals(span.textContent, "null");
60 | }, "assigning { toString: ... null } to Node.textContent converts to an IDL \"DOMString?\" type correctly");
61 | 
62 | test(function() {
63 |   var span = document.createElement("span");
64 |   span.textContent = "test";
65 |   assert_equals(span.textContent, "test");
66 |   span.textContent = { toString: function() { return undefined; } };
67 |   assert_equals(span.textContent, "undefined");
68 | }, "assigning { toString: ... undefined } to Node.textContent converts to an IDL \"DOMString?\" type correctly");
69 | 
70 | test(function() {
71 |   var span = document.createElement("span");
72 |   span.textContent = "test";
73 |   assert_equals(span.textContent, "test");
74 |   assert_throws(new TypeError(), function() { span.textContent = { toString: function() { return { }; } } });
75 | }, "assigning { toString: ... { } } to Node.textContent converts to an IDL \"DOMString?\" type correctly");
76 | </script>
77 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/attribute-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Getters for read only attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 | </div>
11 | 
12 | <script>
13 | // 4.5.6 Attributes
14 | //
15 | // Properties for non-[Unforgeable] attributes exist on the interface prototype
16 | // object and are enumerable and configurable.  These are accessor properties
17 | // always have a getter.  The getter expects no arguments, and will ignore
18 | // extra ones.  The getter can be applied to objects of the right type
19 | // from other windows.  Calling it with a bad this object value will throw
20 | // a TypeError.
21 | 
22 | // feature: Node.parentNode (attribute) (read only, without [Unforgeable])
23 | 
24 | test(function() {
25 |   assert_true(!document.documentElement.hasOwnProperty("parentNode"));
26 | }, "HTMLHtmlElement object does not have own property \"parentNode\"");
27 | 
28 | test(function() {
29 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
30 |   assert_descriptor(desc, { enumerable: true, configurable: true });
31 | }, "Node.prototype.parentNode has correct property attributes");
32 | 
33 | test(function() {
34 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
35 |   assert_equals(typeof desc.get, "function");
36 |   assert_equals(desc.get.length, 0);
37 | }, "Node.parentNode has a getter function with the right length");
38 | 
39 | test(function() {
40 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
41 |   assert_true(!desc.set);
42 | }, "Node.parentNode has no setter function");
43 | 
44 | test(function() {
45 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
46 |   assert_true(!!desc);
47 |   assert_throws(new TypeError(), function() { desc.get.call(null); });
48 | }, "calling Node.parentNode getter with a null this-value throws");
49 | 
50 | test(function() {
51 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
52 |   assert_true(!!desc);
53 |   assert_throws(new TypeError(), function() { desc.get.call(new Range()); });
54 | }, "calling Node.parentNode getter with a non-Node object this-value throws");
55 | 
56 | test(function() {
57 |   var doc = document.implementation.createHTMLDocument("test");
58 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
59 |   assert_equals(desc.get.call(doc.documentElement), doc);
60 | }, "calling Node.parentNode getter on a different Document object works");
61 | 
62 | test(function() {
63 |   var doc = document.getElementById("iframe").contentDocument;
64 |   var n = doc.createComment("test");
65 |   doc.insertBefore(n, doc.firstChild);
66 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
67 |   assert_equals(desc.get.call(n), doc);
68 | }, "calling Node.parentNode getter on an object for a different window works");
69 | 
70 | test(function() {
71 |   var desc = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode");
72 |   assert_equals(desc.get.call(document.documentElement, "extra"), document);
73 | }, "arguments passed to Node.parentNode getter are ignored");
74 | </script>
75 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/operation-003.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Invoking regular, variadic operations</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 | </div>
11 | 
12 | <script>
13 | // 4.5.7 Operations
14 | //
15 | // Here we're invoking regular operations that are variadic.  When too few
16 | // arguments are passed, a TypeError is thrown.  Any additional arguments
17 | // beyond those explicitly listed in the IDL are passed in are converted
18 | // to the variadic argument type.
19 | 
20 | // feature: DOMTokenList.add (operation) (variadic)
21 | 
22 | test(function() {
23 |   var span = document.createElement("span");
24 |   span.setAttribute("class", "abc");
25 |   span.classList.add();
26 |   assert_equals(span.getAttribute("class"), "abc");
27 | }, "passing no arguments corresponding to the variadic argument of DOMTokenList.add works");
28 | 
29 | test(function() {
30 |   var span = document.createElement("span");
31 |   span.setAttribute("class", "abc");
32 |   span.classList.add("def");
33 |   assert_equals(span.getAttribute("class"), "abc def");
34 | }, "passing one argument corresponding to the variadic argument of DOMTokenList.add works");
35 | 
36 | test(function() {
37 |   var order = [];
38 |   var span = document.createElement("span");
39 |   span.setAttribute("class", "abc");
40 |   span.classList.add({ toString: function() { order.push("first"); return "def"; } },
41 |                      { toString: function() { order.push("second"); return "ghi"; } });
42 |   assert_equals(span.getAttribute("class"), "abc def ghi");
43 |   assert_array_equals(order, ["first", "second"]);
44 | }, "passing multiple arguments corresponding to the variadic argument of DOMTokenList.add works");
45 | 
46 | 
47 | // feature: WindowTimers.setTimeout (operation) (variadic)
48 | 
49 | test(function() {
50 |   assert_throws(new TypeError(), function() { window.setTimeout(); });
51 | }, "passing too few arguments to WindowTimers.setTimeout throws");
52 | 
53 | async_test(function(t) {
54 |   window.setTimeout(function() {
55 |     var argc = arguments.length;
56 |     t.step(function() {
57 |       assert_equals(argc, 0);
58 |       t.done();
59 |     });
60 |   }, 1);
61 | }, "passing no arguments corresponding to the variadic argument of WindowTimers.setTimeout works");
62 | 
63 | async_test(function(t) {
64 |   window.setTimeout(function(arg1) {
65 |     var argc = arguments.length;
66 |     t.step(function() {
67 |       assert_equals(argc, 1);
68 |       assert_equals(arg1, "hello");
69 |       t.done();
70 |     });
71 |   }, 1, "hello");
72 | }, "passing one argument corresponding to the variadic argument of WindowTimers.setTimeout works");
73 | 
74 | async_test(function(t) {
75 |   var object = { };
76 |   window.setTimeout(function(arg1, arg2, arg3, arg4) {
77 |     var argc = arguments.length;
78 |     t.step(function() {
79 |       assert_equals(argc, 4);
80 |       assert_equals(arg1, "hello");
81 |       assert_equals(arg2, object);
82 |       assert_equals(arg3, -0);
83 |       assert_equals(arg4, undefined);
84 |       t.done();
85 |     });
86 |   }, 1, "hello", object, -0, undefined);
87 | }, "passing multiple arguments corresponding to the variadic argument of WindowTimers.setTimeout works");
88 | </script>
89 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/attribute-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Getters for writable attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 |   <select id="select">
11 |     <option></option>
12 |     <option></option>
13 |   </select>
14 | </div>
15 | 
16 | <script>
17 | // 4.5.6 Attributes
18 | //
19 | // Properties for non-[Unforgeable] attributes exist on the interface prototype
20 | // object and are enumerable and configurable.  These are accessor properties
21 | // always have a getter.  The getter expects no arguments, and will ignore
22 | // extra ones.  The getter can be applied to objects of the right type
23 | // from other windows.  Calling it with a bad this object value will throw
24 | // a TypeError.
25 | 
26 | // feature: HTMLSelectElement.length (attribute) (writable, without [Unforgeable])
27 | 
28 | var select = document.getElementById("select");
29 | 
30 | test(function() {
31 |   assert_true(!select.hasOwnProperty("length"));
32 | }, "HTMLSelectElement object does not have own property \"length\"");
33 | 
34 | test(function() {
35 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
36 |   assert_descriptor(desc, { enumerable: true, configurable: true });
37 | }, "HTMLSelectElement.prototype.length has correct property attributes");
38 | 
39 | test(function() {
40 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
41 |   assert_equals(typeof desc.get, "function");
42 |   assert_equals(desc.get.length, 0);
43 | }, "HTMLSelectElement.length has a getter function with the right length");
44 | 
45 | test(function() {
46 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
47 |   assert_true(!!desc);
48 |   assert_throws(new TypeError(), function() { desc.get.call(null); });
49 | }, "calling HTMLSelectElement.length getter with a null this-value throws");
50 | 
51 | test(function() {
52 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
53 |   assert_true(!!desc);
54 |   assert_throws(new TypeError(), function() { desc.get.call(document); });
55 | }, "calling HTMLSelectElement.length getter with a non-HTMLSelectElement object this-value throws");
56 | 
57 | test(function() {
58 |   var e = document.createElement("select");
59 |   e.appendChild(document.createElement("option"));
60 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
61 |   assert_equals(desc.get.call(e), 1);
62 | }, "calling HTMLSelectElement.length getter on a different HTMLSelectElement object works");
63 | 
64 | test(function() {
65 |   var doc = document.getElementById("iframe").contentDocument;
66 |   var e = doc.createElement("select");
67 |   e.appendChild(doc.createElement("option"));
68 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
69 |   assert_equals(desc.get.call(e), 1);
70 | }, "calling HTMLSelectElement.length getter on an object from a different window works");
71 | 
72 | test(function() {
73 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
74 |   assert_equals(desc.get.call(select, "extra"), 2);
75 | }, "arguments passed to HTMLSelectElement.length getter are ignored");
76 | </script>
77 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/throwing-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Throwing exceptions</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 | </div>
11 | 
12 | <script>
13 | // 4.11 Throwing exceptions
14 | //
15 | // When an exception is thrown, it is associated with a particular
16 | // global environment.
17 | 
18 | var iframe = document.getElementById("iframe");
19 | 
20 | // feature: HTMLSelectElement.length (attribute)
21 | 
22 | test(function() {
23 |   var desc = Object.getOwnPropertyDescriptor(iframe.contentWindow.HTMLSelectElement.prototype, "length");
24 |   try {
25 |     desc.get.call(document);
26 |     assert_unreached("exception should have been thrown");
27 |   } catch (e) {
28 |     assert_equals(Object.getPrototypeOf(e), iframe.contentWindow.TypeError.prototype);
29 |   }
30 | }, "exception thrown from attribute getter is associated with the correct global environment");
31 | 
32 | // feature: Node.appendChild (operation)
33 | 
34 | test(function() {
35 |   var func = iframe.contentWindow.Node.prototype.appendChild;
36 |   try {
37 |     func.call(new Range());
38 |     assert_unreached("exception should have been thrown");
39 |   } catch (e) {
40 |     assert_equals(Object.getPrototypeOf(e), iframe.contentWindow.TypeError.prototype);
41 |   }
42 | }, "exception thrown from operation is associated with the correct global environment");
43 | 
44 | // feature: Uint8Array (indexed property setter)
45 | 
46 | test(function() {
47 |   var a = new iframe.contentWindow.Uint8Array(1);
48 |   try {
49 |     a[0] = { toString: function() { return { }; }, valueOf: function() { return { }; } };
50 |     assert_unreached("exception should have been thrown");
51 |   } catch (e) {
52 |     assert_equals(Object.getPrototypeOf(e), iframe.contentWindow.TypeError.prototype);
53 |   }
54 | }, "exception thrown from indexed property is associated with the correct global environment");
55 | 
56 | // feature: Event (interface) (with [Constructor])
57 | 
58 | test(function() {
59 |   try {
60 |     new iframe.contentWindow.Event();
61 |     assert_unreached("exception should have been thrown");
62 |   } catch (e) {
63 |     assert_equals(Object.getPrototypeOf(e), iframe.contentWindow.TypeError.prototype);
64 |   }
65 | }, "exception thrown from constructor is associated with the correct global environment");
66 | 
67 | // feature: HTMLImageElement (interface) (with [NamedConstructor])
68 | 
69 | test(function() {
70 |   try {
71 |     new iframe.contentWindow.Image({ toString: function() { return { } }, value: function() { return { } } });
72 |     assert_unreached("exception should have been thrown");
73 |   } catch (e) {
74 |     assert_equals(Object.getPrototypeOf(e), iframe.contentWindow.TypeError.prototype);
75 |   }
76 | }, "exception thrown from named constructor is associated with the correct global environment");
77 | 
78 | // feature: Location (stringifier)
79 | 
80 | test(function() {
81 |   try {
82 |     iframe.contentWindow.Location.prototype.toString.call(document);
83 |     assert_unreached("exception should have been thrown");
84 |   } catch (e) {
85 |     assert_equals(Object.getPrototypeOf(e), iframe.contentWindow.TypeError.prototype);
86 |   }
87 | }, "exception thrown from stringifier is associated with the correct global environment");
88 | </script>
89 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/nullable-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Nullable types</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.22 Nullable types – T?
10 | //
11 | // Except in the face of [TreatUndefinedAs] and [TreatNonCallableAs], JS
12 | // undefined and null values get converted to IDL null.
13 | 
14 | // feature: Node.insertBefore (operation) (with an argument of a nullable interface type)
15 | 
16 | function makeDiv() {
17 |   var div = document.createElement("div");
18 |   div.appendChild(document.createElement("span"));
19 |   return div;
20 | }
21 | 
22 | test(function() {
23 |   var div = document.createElement("div");
24 |   var span1 = document.createElement("span");
25 |   var span2 = document.createElement("span");
26 |   div.appendChild(span1);
27 | 
28 |   div.insertBefore(span2, span1);
29 |   assert_equals(div.firstChild, span2);
30 |   assert_equals(div.lastChild, span1);
31 | }, "passing a Node to Node.insertBefore converts to an IDL \"Node?\" type correctly");
32 | 
33 | test(function() {
34 |   var div = document.createElement("div");
35 |   var span1 = document.createElement("span");
36 |   var span2 = document.createElement("span");
37 |   div.appendChild(span1);
38 | 
39 |   div.insertBefore(span2, null);
40 |   assert_equals(div.firstChild, span1);
41 |   assert_equals(div.lastChild, span2);
42 | }, "passing null to Node.insertBefore converts to an IDL \"Node?\" type correctly");
43 | 
44 | test(function() {
45 |   var div = document.createElement("div");
46 |   var span1 = document.createElement("span");
47 |   var span2 = document.createElement("span");
48 |   div.appendChild(span1);
49 | 
50 |   div.insertBefore(span2, undefined);
51 |   assert_equals(div.firstChild, span1);
52 |   assert_equals(div.lastChild, span2);
53 | }, "passing undefined to Node.insertBefore converts to an IDL \"Node?\" type correctly");
54 | 
55 | test(function() {
56 |   var div = document.createElement("div");
57 |   var span1 = document.createElement("span");
58 |   var span2 = document.createElement("span");
59 |   div.appendChild(span1);
60 | 
61 |   assert_throws(new TypeError(), function() { div.insertBefore(span2, window); });
62 | }, "passing window to Node.insertBefore converts to an IDL \"Node?\" type correctly");
63 | 
64 | test(function() {
65 |   var div = document.createElement("div");
66 |   var span1 = document.createElement("span");
67 |   var span2 = document.createElement("span");
68 |   div.appendChild(span1);
69 | 
70 |   assert_throws(new TypeError(), function() { div.insertBefore(span2, false); });
71 | }, "passing false to Node.insertBefore converts to an IDL \"Node?\" type correctly");
72 | 
73 | test(function() {
74 |   var div = document.createElement("div");
75 |   var span1 = document.createElement("span");
76 |   var span2 = document.createElement("span");
77 |   div.appendChild(span1);
78 | 
79 |   assert_throws(new TypeError(), function() { div.insertBefore(span2, { }); });
80 | }, "passing { } to Node.insertBefore converts to an IDL \"Node?\" type correctly");
81 | 
82 | test(function() {
83 |   var div = document.createElement("div");
84 |   var span1 = document.createElement("span");
85 |   var span2 = document.createElement("span");
86 |   div.appendChild(span1);
87 | 
88 |   assert_throws(new TypeError(), function() { div.insertBefore(span2, Image); });
89 | }, "passing Image to Node.insertBefore converts to an IDL \"Node?\" type correctly");
90 | </script>
91 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/attribute-005.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Setters for writable attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 | </div>
11 | 
12 | <script>
13 | // 4.5.6 Attributes
14 | //
15 | // Properties for non-[Unforgeable] attributes exist on the interface prototype
16 | // object and are enumerable and configurable.  These are accessor properties
17 | // and have a setter if they are not read only.  The setter expects one
18 | // argument, and will ignore extra ones.  If no argument is passed, a TypeError
19 | // is thrown.  The setter can be applied to objects of the right type from
20 | // other windows.  Calling it with a bad this object value will throw
21 | // a TypeError.
22 | 
23 | // feature: Document.title (attribute) (writable, without [Unforgeable])
24 | 
25 | test(function() {
26 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
27 |   assert_equals(typeof desc.set, "function");
28 |   assert_equals(desc.set.length, 1);
29 | }, "Document.title has a setter function with the right length");
30 | 
31 | test(function() {
32 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
33 |   assert_true(!!desc);
34 |   assert_throws(new TypeError(), function() { desc.set.call(null); });
35 | }, "calling Document.title setter with a null this-value throws");
36 | 
37 | test(function() {
38 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
39 |   assert_true(!!desc);
40 |   assert_throws(new TypeError(), function() { desc.set.call(document.documentElement); });
41 | }, "calling Document.title setter with a non-Document object this-value throws");
42 | 
43 | test(function() {
44 |   var doc = document.implementation.createHTMLDocument("test");
45 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
46 |   desc.set.call(doc, "something");
47 |   assert_equals(doc.title, "something");
48 | }, "calling Document.title setter on a different document object works");
49 | 
50 | test(function() {
51 |   var doc = document.implementation.createHTMLDocument("test");
52 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
53 |   assert_equals(desc.set.call(doc, "something"), undefined);
54 | }, "calling Document.title setter returns undefined");
55 | 
56 | test(function() {
57 |   var doc = document.getElementById("iframe").contentDocument;
58 |   doc.title = "test";
59 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
60 |   desc.set.call(doc, "something");
61 |   assert_equals(doc.title, "something");
62 | }, "calling Document.title setter on an object from a different window works");
63 | 
64 | test(function() {
65 |   var doc = document.implementation.createHTMLDocument("test");
66 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
67 |   desc.set.call(doc, "something");
68 |   assert_equals(doc.title, "something");
69 | }, "arguments passed to Document.title setter are ignored");
70 | 
71 | test(function() {
72 |   var doc = document.implementation.createHTMLDocument("test");
73 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "title");
74 |   assert_throws(new TypeError(), function() { desc.set.call(doc); });
75 | }, "passing no arguments to Document.title setter will throw");
76 | </script>
77 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/byte-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>byte</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.4 byte
10 | //
11 | // Converting a JS value to an IDL byte performs a similar operation to
12 | // ECMAScript's ToInt32, but for an 8 bit result.
13 | 
14 | var values = [
15 |   undefined,   0,    "undefined",
16 |   null,        0,    "null",
17 |   false,       0,    "false",
18 |   true,        1,    "true",
19 |   0,           0,    "0",
20 |   1,           1,    "1",
21 |   -1,          -1,   "-1",
22 |   0.5,         0,    "0.5",
23 |   Infinity,    0,    "Infinity",
24 |   -Infinity,   0,    "-Infinity",
25 |   NaN,         0,    "NaN",
26 |   -0,          0,    "-0",
27 |   "",          0,    '""',
28 |   "1",         1,    '"1"',
29 |   "hello",     0,    '"hello"',
30 |   { },         0,    "{ }",
31 |   [],          0,    "[]",
32 |   /abc/,       0,    "/abc/",
33 |   document,    0,    "document",
34 |   -128,        -128, "-128",
35 |   -129,        127,  "-129",
36 |   127,         127,  "127",
37 |   128,         -128, "128",
38 |   -0.5,        0,    "-0.5",
39 |   -1.5,        -1,   "-1.5",
40 |   1.5,         1,    "1.5"
41 | ];
42 | 
43 | // feature: Int8Array (indexed property setter) (of type byte)
44 | 
45 | var a = new Int8Array(1);
46 | 
47 | for (var i = 0; i < values.length; i += 3) {
48 |   var value = values[i];
49 |   var expected = values[i + 1];
50 |   var desc = values[i + 2];
51 |   test(function() {
52 |     a[0] = value;
53 |     assert_equals(a[0], expected);
54 |   }, "passing " + desc + " through an Int8Array indexed property setter coerces the value to an IDL byte correctly");
55 | }
56 | 
57 | for (var i = 0; i < values.length; i += 3) {
58 |   var value = values[i];
59 |   var expected = values[i + 1];
60 |   var desc = values[i + 2];
61 |   test(function() {
62 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
63 |     if (value === null || typeof value != "object") {
64 |       a[0] = objectValue;
65 |       assert_equals(a[0], expected);
66 |     } else {
67 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
68 |       assert_throws(new TypeError(), function() { a[0] = objectValue; });
69 |     }
70 |   }, "passing { valueOf: function() { return " + desc + " } } through an Int8Array indexed property setter coerces the value to an IDL byte correctly");
71 | }
72 | 
73 | for (var i = 0; i < values.length; i += 3) {
74 |   var value = values[i];
75 |   var expected = values[i + 1];
76 |   var desc = values[i + 2];
77 |   test(function() {
78 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
79 |     if (value === null || typeof value != "object") {
80 |       a[0] = objectValue;
81 |       assert_equals(a[0], expected);
82 |     } else {
83 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
84 |       assert_throws(new TypeError(), function() { a[0] = objectValue; });
85 |     }
86 |   }, "passing { toString: function() { return " + desc + " } } through an Int8Array indexed property setter coerces the value to an IDL byte correctly");
87 | }
88 | 
89 | test(function() {
90 |   assert_throws({ name: "SomeError" }, function() { a[0] = { toString: function() { throw { name: "SomeError" }; } }; });
91 | }, "passing { toString: function() { throw ... } } to the Int8Array indexed property setter will propagate the exception");
92 | </script>
93 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/attribute-004.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Getters for read only attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 |   <form id="form">
11 |     <input></input>
12 |     <input></input>
13 |   </form>
14 | </div>
15 | 
16 | <script>
17 | // 4.5.6 Attributes
18 | //
19 | // Properties for non-[Unforgeable] attributes exist on the interface prototype
20 | // object and are enumerable and configurable.  These are accessor properties
21 | // always have a getter.  The getter expects no arguments, and will ignore
22 | // extra ones.  The getter can be applied to objects of the right type
23 | // from other windows.  Calling it with a bad this object value will throw
24 | // a TypeError.
25 | 
26 | // feature: HTMLFormElement (attribute) (read only, without [Unforgeable])
27 | 
28 | var form = document.getElementById("form");
29 | 
30 | test(function() {
31 |   assert_true(!form.hasOwnProperty("length"));
32 | }, "HTMLFormElement object does not have own property \"length\"");
33 | 
34 | test(function() {
35 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
36 |   assert_descriptor(desc, { enumerable: true, configurable: true });
37 | }, "HTMLFormElement.prototype.length has correct property attributes");
38 | 
39 | test(function() {
40 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
41 |   assert_equals(typeof desc.get, "function");
42 |   assert_equals(desc.get.length, 0);
43 | }, "HTMLFormElement.length has a getter function with the right length");
44 | 
45 | test(function() {
46 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
47 |   assert_true(!desc.set);
48 | }, "HTMLFormElement.length has no setter function");
49 | 
50 | test(function() {
51 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
52 |   assert_true(!!desc);
53 |   assert_throws(new TypeError(), function() { desc.get.call(null); });
54 | }, "calling HTMLFormElement.length getter with a null this-value throws");
55 | 
56 | test(function() {
57 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
58 |   assert_true(!!desc);
59 |   assert_throws(new TypeError(), function() { desc.get.call(document); });
60 | }, "calling HTMLFormElement.length getter with a non-HTMLFormElement object this-value throws");
61 | 
62 | test(function() {
63 |   var e = document.createElement("form");
64 |   e.appendChild(document.createElement("input"));
65 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
66 |   assert_equals(desc.get.call(e), 1);
67 | }, "calling HTMLFormElement.length getter on a different HTMLFormElement object works");
68 | 
69 | test(function() {
70 |   var doc = document.getElementById("iframe").contentDocument;
71 |   var e = doc.createElement("form");
72 |   e.appendChild(doc.createElement("input"));
73 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
74 |   assert_equals(desc.get.call(e), 1);
75 | }, "calling HTMLFormElement.length getter on an object from a different window works");
76 | 
77 | test(function() {
78 |   var desc = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "length");
79 |   assert_equals(desc.get.call(form, "extra"), 2);
80 | }, "arguments passed to HTMLFormElement.length getter are ignored");
81 | </script>
82 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/octet-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>octet</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.5 octet
10 | //
11 | // Converting a JS value to an IDL octet performs a similar operation to
12 | // ECMAScript's ToUint32, but for an 8 bit result.
13 | 
14 | var values = [
15 |   undefined,   0,    "undefined",
16 |   null,        0,    "null",
17 |   false,       0,    "false",
18 |   true,        1,    "true",
19 |   0,           0,    "0",
20 |   1,           1,    "1",
21 |   -1,          255,  "-1",
22 |   0.5,         0,    "0.5",
23 |   Infinity,    0,    "Infinity",
24 |   -Infinity,   0,    "-Infinity",
25 |   NaN,         0,    "NaN",
26 |   -0,          0,    "-0",
27 |   "",          0,    '""',
28 |   "1",         1,    '"1"',
29 |   "hello",     0,    '"hello"',
30 |   { },         0,    "{ }",
31 |   [],          0,    "[]",
32 |   /abc/,       0,    "/abc/",
33 |   document,    0,    "document",
34 |   -128,        128,  "-128",
35 |   -129,        127,  "-129",
36 |   255,         255,  "255",
37 |   256,         0,    "256",
38 |   -0.5,        0,    "-0.5",
39 |   -1.5,        255,  "-1.5",
40 |   1.5,         1,    "1.5"
41 | ];
42 | 
43 | // feature: Uint8Array (indexed property setter) (of type octet)
44 | 
45 | var a = new Uint8Array(1);
46 | 
47 | for (var i = 0; i < values.length; i += 3) {
48 |   var value = values[i];
49 |   var expected = values[i + 1];
50 |   var desc = values[i + 2];
51 |   test(function() {
52 |     a[0] = value;
53 |     assert_equals(a[0], expected);
54 |   }, "passing " + desc + " through an Uint8Array indexed property setter coerces the value to an IDL octet correctly");
55 | }
56 | 
57 | for (var i = 0; i < values.length; i += 3) {
58 |   var value = values[i];
59 |   var expected = values[i + 1];
60 |   var desc = values[i + 2];
61 |   test(function() {
62 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
63 |     if (value === null || typeof value != "object") {
64 |       a[0] = objectValue;
65 |       assert_equals(a[0], expected);
66 |     } else {
67 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
68 |       assert_throws(new TypeError(), function() { a[0] = objectValue; });
69 |     }
70 |   }, "passing { valueOf: function() { return " + desc + " } } through an Uint8Array indexed property setter coerces the value to an IDL octet correctly");
71 | }
72 | 
73 | for (var i = 0; i < values.length; i += 3) {
74 |   var value = values[i];
75 |   var expected = values[i + 1];
76 |   var desc = values[i + 2];
77 |   test(function() {
78 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
79 |     if (value === null || typeof value != "object") {
80 |       a[0] = objectValue;
81 |       assert_equals(a[0], expected);
82 |     } else {
83 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
84 |       assert_throws(new TypeError(), function() { a[0] = objectValue; });
85 |     }
86 |   }, "passing { toString: function() { return " + desc + " } } through an Uint8Array indexed property setter coerces the value to an IDL octet correctly");
87 | }
88 | 
89 | test(function() {
90 |   assert_throws({ name: "SomeError" }, function() { a[0] = { toString: function() { throw { name: "SomeError" }; } }; });
91 | }, "passing { toString: function() { throw ... } } to the Int8Array indexed property setter will propagate the exception");
92 | </script>
93 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/short-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>short</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.6 short
10 | //
11 | // Converting a JS value to an IDL short performs a similar operation to
12 | // ECMAScript's ToInt32, but for a 16 bit result.
13 | 
14 | var values = [
15 |   undefined,   0,       "undefined",
16 |   null,        0,       "null",
17 |   false,       0,       "false",
18 |   true,        1,       "true",
19 |   0,           0,       "0",
20 |   1,           1,       "1",
21 |   -1,          -1,      "-1",
22 |   0.5,         0,       "0.5",
23 |   Infinity,    0,       "Infinity",
24 |   -Infinity,   0,       "-Infinity",
25 |   NaN,         0,       "NaN",
26 |   -0,          0,       "-0",
27 |   "",          0,       '""',
28 |   "1",         1,       '"1"',
29 |   "hello",     0,       '"hello"',
30 |   { },         0,       "{ }",
31 |   [],          0,       "[]",
32 |   /abc/,       0,       "/abc/",
33 |   document,    0,       "document",
34 |   -32768,      -32768,  "-32768",
35 |   -32769,      32767,   "-32769",
36 |   32767,       32767,   "32767",
37 |   32768,       -32768,  "32768",
38 |   -0.5,        0,       "-0.5",
39 |   -1.5,        -1,      "-1.5",
40 |   1.5,         1,       "1.5"
41 | ];
42 | 
43 | // feature: Int16Array (indexed property setter) (of type short)
44 | 
45 | var a = new Int16Array(1);
46 | 
47 | for (var i = 0; i < values.length; i += 3) {
48 |   var value = values[i];
49 |   var expected = values[i + 1];
50 |   var desc = values[i + 2];
51 |   test(function() {
52 |     a[0] = value;
53 |     assert_equals(a[0], expected);
54 |   }, "passing " + desc + " through an Int16Array indexed property setter coerces the value to an IDL short correctly");
55 | }
56 | 
57 | for (var i = 0; i < values.length; i += 3) {
58 |   var value = values[i];
59 |   var expected = values[i + 1];
60 |   var desc = values[i + 2];
61 |   test(function() {
62 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
63 |     if (value === null || typeof value != "object") {
64 |       a[0] = objectValue;
65 |       assert_equals(a[0], expected);
66 |     } else {
67 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
68 |       assert_throws(new TypeError(), function() { a[0] = objectValue; });
69 |     }
70 |   }, "passing { valueOf: function() { return " + desc + " } } through an Int16Array indexed property setter coerces the value to an IDL short correctly");
71 | }
72 | 
73 | for (var i = 0; i < values.length; i += 3) {
74 |   var value = values[i];
75 |   var expected = values[i + 1];
76 |   var desc = values[i + 2];
77 |   test(function() {
78 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
79 |     if (value === null || typeof value != "object") {
80 |       a[0] = objectValue;
81 |       assert_equals(a[0], expected);
82 |     } else {
83 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
84 |       assert_throws(new TypeError(), function() { a[0] = objectValue; });
85 |     }
86 |   }, "passing { toString: function() { return " + desc + " } } through an Int16Array indexed property setter coerces the value to an IDL short correctly");
87 | }
88 | 
89 | test(function() {
90 |   assert_throws({ name: "SomeError" }, function() { a[0] = { toString: function() { throw { name: "SomeError" }; } }; });
91 | }, "passing { toString: function() { throw ... } } to the Int16Array indexed property setter will propagate the exception");
92 | </script>
93 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/attribute-006.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>Setters for writable attributes</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
 9 |   <iframe id="iframe"></iframe>
10 |   <select id="select">
11 |     <option></option>
12 |     <option></option>
13 |   </select>
14 | </div>
15 | 
16 | <script>
17 | // 4.5.6 Attributes
18 | //
19 | // Properties for non-[Unforgeable] attributes exist on the interface prototype
20 | // object and are enumerable and configurable.  These are accessor properties
21 | // and have a setter if they are not read only.  The setter expects one
22 | // argument, and will ignore extra ones.  If no argument is passed, a TypeError
23 | // is thrown.  The setter can be applied to objects of the right type from
24 | // other windows.  Calling it with a bad this object value will throw
25 | // a TypeError.
26 | 
27 | // feature: HTMLSelectElement.length (attribute) (writable, without [Unforgeable])
28 | 
29 | var select = document.getElementById("select");
30 | 
31 | test(function() {
32 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
33 |   assert_equals(typeof desc.set, "function");
34 |   assert_equals(desc.set.length, 1);
35 | }, "HTMLSelectElement.length has a setter function with the right length");
36 | 
37 | test(function() {
38 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
39 |   assert_true(!!desc);
40 |   assert_throws(new TypeError(), function() { desc.set.call(null); });
41 | }, "calling HTMLSelectElement.length setter with a null this-value throws");
42 | 
43 | test(function() {
44 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
45 |   assert_true(!!desc);
46 |   assert_throws(new TypeError(), function() { desc.set.call(document, 0); });
47 | }, "calling HTMLSelectElement.length setter with a non-HTMLSelectElement object this-value throws");
48 | 
49 | test(function() {
50 |   var e = document.createElement("select");
51 |   e.appendChild(document.createElement("option"));
52 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
53 |   desc.set.call(e, 1);
54 |   assert_equals(e.length, 1);
55 | }, "calling HTMLSelectElement.length setter on a different HTMLSelectElement object works");
56 | 
57 | test(function() {
58 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
59 |   assert_equals(desc.set.call(select, 4), undefined);
60 | }, "calling HTMLSelectElement.length setter returns undefined");
61 | 
62 | test(function() {
63 |   var doc = document.getElementById("iframe").contentDocument;
64 |   var e = doc.createElement("select");
65 |   e.appendChild(doc.createElement("option"));
66 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
67 |   desc.set.call(e, 0);
68 |   assert_equals(e.length, 0);
69 | }, "calling HTMLSelectElement.length setter on an object from a different window works");
70 | 
71 | test(function() {
72 |   var desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "length");
73 |   desc.set.call(select, 3, "extra");
74 |   assert_equals(select.length, 3);
75 | }, "arguments passed to HTMLSelectElement.length setter are ignored");
76 | 
77 | test(function() {
78 |   var desc = Object.getOwnPropertyDescriptor(Document.prototype, "length");
79 |   assert_throws(new TypeError(), function() { desc.set.call(select); });
80 | }, "passing no arguments to HTMLSelectElement.length setter will throw");
81 | </script>
82 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/property-enumeration-001.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <title>Property enumeration</title>
  3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
  4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
  5 | <script src="utils.js"></script>
  6 | <div id="log"></div>
  7 | 
  8 | <div id="container" style="display: none">
  9 |   <form name="abc"></form>
 10 |   <form name="def"></form>
 11 | </div>
 12 | 
 13 | <script>
 14 | // 4.7.6 Property enumeration
 15 | //
 16 | // If an object supports indexed properties, they are enumerated first,
 17 | // in numerical order.  If it supports named properties, they are enumerated
 18 | // next, in the order that is defined by the spec that describes the set
 19 | // of supported property names.  Finally, any own properties and properties
 20 | // from the prototype are enumerated, in an unspecified order.
 21 | 
 22 | // feature: HTMLCollection (interface) (supports indexed properties, supports named properties)
 23 | 
 24 | test(function() {
 25 |   document.forms.some = 1;
 26 |   document.forms.thing = 1;
 27 | 
 28 |   var container = document.getElementById("container");
 29 | 
 30 |   var form = document.createElement("form");
 31 |   form.setAttribute("name", "ghi");
 32 |   container.insertBefore(form, container.firstChild);
 33 | 
 34 |   form = document.createElement("form");
 35 |   form.setAttribute("name", "thing");
 36 |   container.insertBefore(form, container.firstChild);
 37 | 
 38 |   var expectedOrder = ["0", "1", "2", "3", "thing", "ghi", "abc", "def", "some"];
 39 |   var expected = Object.create(null);
 40 |   for (var i = 0; i < expectedOrder.length; i++) {
 41 |     expected[expectedOrder[i]] = true;
 42 |   }
 43 | 
 44 |   var actualOrder = [];
 45 |   for (var p in document.forms) {
 46 |     if (expected[p]) {
 47 |       actualOrder.push(p);
 48 |     }
 49 |   }
 50 | 
 51 |   assert_array_equals(actualOrder, expectedOrder);
 52 | }, "HTMLCollection enumerates properties in the right order");
 53 | 
 54 | 
 55 | // feature: Uint8Array (interface) (supports indexed properties, does not support named properties)
 56 | 
 57 | test(function() {
 58 |   var a = new Uint8Array(3);
 59 |   a.something = 1;
 60 | 
 61 |   var expectedOrder = ["0", "1", "2", "something"];
 62 |   var expected = Object.create(null);
 63 |   for (var i = 0; i < expectedOrder.length; i++) {
 64 |     expected[expectedOrder[i]] = true;
 65 |   }
 66 | 
 67 |   var actualOrder = [];
 68 |   for (var p in a) {
 69 |     if (expected[p]) {
 70 |       actualOrder.push(p);
 71 |     }
 72 |   }
 73 | 
 74 |   assert_array_equals(actualOrder, expectedOrder);
 75 | }, "Uint8Array enumerates properties in the right order");
 76 | 
 77 | 
 78 | // feature: DOMStringMap (interface) (does not support indexed properties, supports named properties)
 79 | 
 80 | test(function() {
 81 |   try {
 82 |     DOMStringMap.prototype.some = 1;
 83 |     DOMStringMap.prototype.thing = 1;
 84 | 
 85 |     var span = document.createElement("span");
 86 |     window.span = span;
 87 |     span.dataset.abc = "test";
 88 |     span.dataset.thing = "test";
 89 |     span.dataset.def = "test";
 90 |     span.dataset.ghi = "test";
 91 |     delete span.dataset.abc;
 92 | 
 93 |     var expectedOrder = ["thing", "def", "ghi", "some"];
 94 |     var expected = Object.create(null);
 95 |     for (var i = 0; i < expectedOrder.length; i++) {
 96 |       expected[expectedOrder[i]] = true;
 97 |     }
 98 | 
 99 |     var actualOrder = [];
100 |     for (var p in span.dataset) {
101 |       if (expected[p]) {
102 |         actualOrder.push(p);
103 |       }
104 |     }
105 | 
106 |     assert_array_equals(actualOrder, expectedOrder);
107 |   } finally {
108 |     delete DOMStringMap.prototype.something;
109 |   }
110 | }, "DOMStringMap enumerates properties in the right order");
111 | </script>
112 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unsigned-short-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>unsigned short</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.7 unsigned short
10 | //
11 | // Converting a JS value to an IDL unsigned short uses ECMAScript's ToUint16
12 | // operation.
13 | 
14 | var values = [
15 |   undefined,   0,       "undefined",
16 |   null,        0,       "null",
17 |   false,       0,       "false",
18 |   true,        1,       "true",
19 |   0,           0,       "0",
20 |   1,           1,       "1",
21 |   -1,          65535,   "-1",
22 |   0.5,         0,       "0.5",
23 |   Infinity,    0,       "Infinity",
24 |   -Infinity,   0,       "-Infinity",
25 |   NaN,         0,       "NaN",
26 |   -0,          0,       "-0",
27 |   "",          0,       '""',
28 |   "1",         1,       '"1"',
29 |   "hello",     0,       '"hello"',
30 |   { },         0,       "{ }",
31 |   [],          0,       "[]",
32 |   /abc/,       0,       "/abc/",
33 |   document,    0,       "document",
34 |   -32768,      32768,   "-32768",
35 |   -32769,      32767,   "-32769",
36 |   65535,       65535,   "65535",
37 |   65536,       0,       "65536",
38 |   -0.5,        0,       "-0.5",
39 |   -1.5,        65535,   "-1.5",
40 |   1.5,         1,       "1.5"
41 | ];
42 | 
43 | // feature: CloseEvent (interface) (with constructor with argument of type unsigned short)
44 | 
45 | for (var i = 0; i < values.length; i += 3) {
46 |   var value = values[i];
47 |   var expected = values[i + 1];
48 |   var desc = values[i + 2];
49 |   test(function() {
50 |     var e = new CloseEvent("test", { code: value });
51 |     assert_equals(e.code, expected);
52 |   }, "passing " + desc + " to CloseEvent constructor coerces the value to an IDL unsigned short correctly");
53 | }
54 | 
55 | for (var i = 0; i < values.length; i += 3) {
56 |   var value = values[i];
57 |   var expected = values[i + 1];
58 |   var desc = values[i + 2];
59 |   test(function() {
60 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
61 |     if (value === null || typeof value != "object") {
62 |       var e = new CloseEvent("test", { code: value });
63 |       assert_equals(e.code, expected);
64 |     } else {
65 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
66 |       assert_throws(new TypeError(), function() { new CloseEvent("test", { code: objectValue }); });
67 |     }
68 |   }, "passing { valueOf: function() { return " + desc + " } } to CloseEvent constructor coerces the value to an IDL unsigned short correctly");
69 | }
70 | 
71 | for (var i = 0; i < values.length; i += 3) {
72 |   var value = values[i];
73 |   var expected = values[i + 1];
74 |   var desc = values[i + 2];
75 |   test(function() {
76 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
77 |     if (value === null || typeof value != "object") {
78 |       var e = new CloseEvent("test", { code: value });
79 |       assert_equals(e.code, expected);
80 |     } else {
81 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
82 |       assert_throws(new TypeError(), function() { new CloseEvent("test", { code: objectValue }); });
83 |     }
84 |   }, "passing { toString: function() { return " + desc + " } } to CloseEvent constructor coerces the value to an IDL unsigned short correctly");
85 | }
86 | 
87 | test(function() {
88 |   assert_throws({ name: "SomeError" }, function() { new CloseEvent("test", { code: { toString: function() { throw { name: "SomeError" }; } } }); });
89 | }, "passing { toString: function() { throw ... } } to CloseEvent constructor will propagate the exception");
90 | </script>
91 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/long-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>long</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.8 long
10 | //
11 | // Converting a JS value to an IDL long uses ECMAScript's ToInt32 operation.
12 | 
13 | var values = [
14 |   undefined,    0,            "undefined",
15 |   null,         0,            "null",
16 |   false,        0,            "false",
17 |   true,         1,            "true",
18 |   0,            0,            "0",
19 |   1,            1,            "1",
20 |   -1,           -1,           "-1",
21 |   0.5,          0,            "0.5",
22 |   Infinity,     0,            "Infinity",
23 |   -Infinity,    0,            "-Infinity",
24 |   NaN,          0,            "NaN",
25 |   -0,           0,            "-0",
26 |   "",           0,            '""',
27 |   "1",          1,            '"1"',
28 |   "hello",      0,            '"hello"',
29 |   { },          0,            "{ }",
30 |   [],           0,            "[]",
31 |   /abc/,        0,            "/abc/",
32 |   document,     0,            "document",
33 |   -2147483648,  -2147483648,  "-2147483648",
34 |   -2147483649,  2147483647,   "-2147483649",
35 |   2147483647,   2147483647,   "2147483647",
36 |   2147483648,   -2147483648,  "2147483648",
37 |   -0.5,         0,            "-0.5",
38 |   -1.5,         -1,           "-1.5",
39 |   1.5,          1,            "1.5"
40 | ];
41 | 
42 | // feature: HTMLOLElement.start (attribute) (writable, of type long)
43 | 
44 | var ol = document.createElement("ol");
45 | 
46 | for (var i = 0; i < values.length; i += 3) {
47 |   var value = values[i];
48 |   var expected = values[i + 1];
49 |   var desc = values[i + 2];
50 |   test(function() {
51 |     ol.start = value;
52 |     assert_equals(+ol.getAttribute("start"), expected);
53 |   }, "assigning " + desc + " to HTMLOListElement.start coerces the value to an IDL long correctly");
54 | }
55 | 
56 | for (var i = 0; i < values.length; i += 3) {
57 |   var value = values[i];
58 |   var expected = values[i + 1];
59 |   var desc = values[i + 2];
60 |   test(function() {
61 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
62 |     if (value === null || typeof value != "object") {
63 |       ol.start = objectValue;
64 |       assert_equals(+ol.getAttribute("start"), expected);
65 |     } else {
66 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
67 |       assert_throws(new TypeError(), function() { ol.start = objectValue; });
68 |     }
69 |   }, "assigning { valueOf: function() { return " + desc + " } } to HTMLOListElement.start coerces the value to an IDL long correctly");
70 | }
71 | 
72 | for (var i = 0; i < values.length; i += 3) {
73 |   var value = values[i];
74 |   var expected = values[i + 1];
75 |   var desc = values[i + 2];
76 |   test(function() {
77 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
78 |     if (value === null || typeof value != "object") {
79 |       ol.start = objectValue;
80 |       assert_equals(+ol.getAttribute("start"), expected);
81 |     } else {
82 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
83 |       assert_throws(new TypeError(), function() { ol.start = objectValue; });
84 |     }
85 |   }, "assigning { toString: function() { return " + desc + " } } to HTMLOListElement.start coerces the value to an IDL long correctly");
86 | }
87 | 
88 | test(function() {
89 |   assert_throws({ name: "SomeError" }, function() { ol.start = { toString: function() { throw { name: "SomeError" }; } }; });
90 | }, "assigning { toString: function() { throw ... } } to HTMLOListElement.start will propagate the exception");
91 | </script>
92 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/long-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>long</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.8 long
10 | //
11 | // Converting a JS value to an IDL long uses ECMAScript's ToInt32 operation.
12 | 
13 | var values = [
14 |   undefined,    0,            "undefined",
15 |   null,         0,            "null",
16 |   false,        0,            "false",
17 |   true,         1,            "true",
18 |   0,            0,            "0",
19 |   1,            1,            "1",
20 |   -1,           -1,           "-1",
21 |   0.5,          0,            "0.5",
22 |   Infinity,     0,            "Infinity",
23 |   -Infinity,    0,            "-Infinity",
24 |   NaN,          0,            "NaN",
25 |   -0,           0,            "-0",
26 |   "",           0,            '""',
27 |   "1",          1,            '"1"',
28 |   "hello",      0,            '"hello"',
29 |   { },          0,            "{ }",
30 |   [],           0,            "[]",
31 |   /abc/,        0,            "/abc/",
32 |   document,     0,            "document",
33 |   -2147483648,  -2147483648,  "-2147483648",
34 |   -2147483649,  2147483647,   "-2147483649",
35 |   2147483647,   2147483647,   "2147483647",
36 |   2147483648,   -2147483648,  "2147483648",
37 |   -0.5,         0,            "-0.5",
38 |   -1.5,         -1,           "-1.5",
39 |   1.5,          1,            "1.5"
40 | ];
41 | 
42 | // feature: HTMLElement.tabIndex (attribute) (writable, of type long)
43 | 
44 | var span = document.createElement("span");
45 | 
46 | for (var i = 0; i < values.length; i += 3) {
47 |   var value = values[i];
48 |   var expected = values[i + 1];
49 |   var desc = values[i + 2];
50 |   test(function() {
51 |     span.tabIndex = value;
52 |     assert_equals(+span.getAttribute("tabindex"), expected);
53 |   }, "assigning " + desc + " to HTMLElement.tabIndex coerces the value to an IDL long correctly");
54 | }
55 | 
56 | for (var i = 0; i < values.length; i += 3) {
57 |   var value = values[i];
58 |   var expected = values[i + 1];
59 |   var desc = values[i + 2];
60 |   test(function() {
61 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
62 |     if (value === null || typeof value != "object") {
63 |       span.tabIndex = objectValue;
64 |       assert_equals(+span.getAttribute("tabindex"), expected);
65 |     } else {
66 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
67 |       assert_throws(new TypeError(), function() { span.tabIndex = objectValue; });
68 |     }
69 |   }, "assigning { valueOf: function() { return " + desc + " } } to HTMLElement.tabIndex coerces the value to an IDL long correctly");
70 | }
71 | 
72 | for (var i = 0; i < values.length; i += 3) {
73 |   var value = values[i];
74 |   var expected = values[i + 1];
75 |   var desc = values[i + 2];
76 |   test(function() {
77 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
78 |     if (value === null || typeof value != "object") {
79 |       span.tabIndex = objectValue;
80 |       assert_equals(+span.getAttribute("tabindex"), expected);
81 |     } else {
82 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
83 |       assert_throws(new TypeError(), function() { span.tabIndex = objectValue; });
84 |     }
85 |   }, "assigning { toString: function() { return " + desc + " } } to HTMLElement.tabIndex coerces the value to an IDL long correctly");
86 | }
87 | 
88 | test(function() {
89 |   assert_throws({ name: "SomeError" }, function() { span.tabIndex = { toString: function() { throw { name: "SomeError" }; } }; });
90 | }, "assigning { toString: function() { throw ... } } to HTMLElement.tabIndex will propagate the exception");
91 | </script>
92 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unsigned-long-002.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>unsigned long</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.9 unsigned long
10 | //
11 | // Converting a JS value to an IDL unsigned long uses ECMAScript's ToUint32
12 | // operation.
13 | 
14 | var values = [
15 |   undefined,    0,           "undefined",
16 |   null,         0,           "null",
17 |   false,        0,           "false",
18 |   true,         1,           "true",
19 |   0,            0,           "0",
20 |   1,            1,           "1",
21 |   -1,           4294967295,  "-1",
22 |   0.5,          0,           "0.5",
23 |   Infinity,     0,           "Infinity",
24 |   -Infinity,    0,           "-Infinity",
25 |   NaN,          0,           "NaN",
26 |   -0,           0,           "-0",
27 |   "",           0,           '""',
28 |   "1",          1,           '"1"',
29 |   "hello",      0,           '"hello"',
30 |   { },          0,           "{ }",
31 |   [],           0,           "[]",
32 |   /abc/,        0,           "/abc/",
33 |   document,     0,           "document",
34 |   -2147483648,  2147483648,  "-2147483648",
35 |   -2147483649,  2147483647,  "-2147483649",
36 |   4294967295,   4294967295,  "4294967295",
37 |   4294967296,   0,           "4294967296",
38 |   4294967297,   1,           "4294967297",
39 |   -0.5,         0,           "-0.5",
40 |   -1.5,         4294967295,  "-1.5",
41 |   1.5,          1,           "1.5"
42 | ];
43 | 
44 | // feature: WheelEvent (interface) (with constructor with argument of type unsigned long)
45 | 
46 | for (var i = 0; i < values.length; i += 3) {
47 |   var value = values[i];
48 |   var expected = values[i + 1];
49 |   var desc = values[i + 2];
50 |   test(function() {
51 |     var e = new WheelEvent("test", { deltaMode: value });
52 |     assert_equals(e.deltaMode, expected);
53 |   }, "passing " + desc + " through WheelEvent constructor coerces the value to an IDL unsigned long correctly");
54 | }
55 | 
56 | for (var i = 0; i < values.length; i += 3) {
57 |   var value = values[i];
58 |   var expected = values[i + 1];
59 |   var desc = values[i + 2];
60 |   test(function() {
61 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
62 |     if (value === null || typeof value != "object") {
63 |       var e = new WheelEvent("test", { deltaMode: objectValue });
64 |       assert_equals(e.deltaMode, expected);
65 |     } else {
66 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
67 |       assert_throws(new TypeError(), function() { new WheelEvent("test", { deltaMode: objectValue }); });
68 |     }
69 |   }, "passing { valueOf: function() { return " + desc + " } } through WheelEvent constructor coerces the value to an IDL unsigned long correctly");
70 | }
71 | 
72 | for (var i = 0; i < values.length; i += 3) {
73 |   var value = values[i];
74 |   var expected = values[i + 1];
75 |   var desc = values[i + 2];
76 |   test(function() {
77 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
78 |     if (value === null || typeof value != "object") {
79 |       var e = new WheelEvent("test", { deltaMode: objectValue });
80 |       assert_equals(e.deltaMode, expected);
81 |     } else {
82 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
83 |       assert_throws(new TypeError(), function() { new WheelEvent("test", { deltaMode: objectValue }); });
84 |     }
85 |   }, "passing { toString: function() { return " + desc + " } } through WheelEvent constructor coerces the value to an IDL unsigned long correctly");
86 | }
87 | 
88 | test(function() {
89 |   assert_throws({ name: "SomeError" }, function() { new WheelEvent("test", { deltaMode: { toString: function() { throw { name: "SomeError" }; } } }); });
90 | }, "passing { toString: function() { throw ... } } through WheelEvent constructor will propagate the exception");
91 | </script>
92 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/unsigned-long-001.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <title>unsigned long</title>
 3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
 4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
 5 | <script src="utils.js"></script>
 6 | <div id="log"></div>
 7 | 
 8 | <script>
 9 | // 4.2.9 unsigned long
10 | //
11 | // Converting a JS value to an IDL unsigned long uses ECMAScript's ToUint32
12 | // operation.
13 | 
14 | var values = [
15 |   undefined,    0,           "undefined",
16 |   null,         0,           "null",
17 |   false,        0,           "false",
18 |   true,         1,           "true",
19 |   0,            0,           "0",
20 |   1,            1,           "1",
21 |   -1,           4294967295,  "-1",
22 |   0.5,          0,           "0.5",
23 |   Infinity,     0,           "Infinity",
24 |   -Infinity,    0,           "-Infinity",
25 |   NaN,          0,           "NaN",
26 |   -0,           0,           "-0",
27 |   "",           0,           '""',
28 |   "1",          1,           '"1"',
29 |   "hello",      0,           '"hello"',
30 |   { },          0,           "{ }",
31 |   [],           0,           "[]",
32 |   /abc/,        0,           "/abc/",
33 |   document,     0,           "document",
34 |   -2147483648,  2147483648,  "-2147483648",
35 |   -2147483649,  2147483647,  "-2147483649",
36 |   4294967295,   4294967295,  "4294967295",
37 |   4294967296,   0,           "4294967296",
38 |   4294967297,   1,           "4294967297",
39 |   -0.5,         0,           "-0.5",
40 |   -1.5,         4294967295,  "-1.5",
41 |   1.5,          1,           "1.5"
42 | ];
43 | 
44 | // feature: Document.createNodeIterator (operation) (with argument of type unsigned long)
45 | 
46 | for (var i = 0; i < values.length; i += 3) {
47 |   var value = values[i];
48 |   var expected = values[i + 1];
49 |   var desc = values[i + 2];
50 |   test(function() {
51 |     var it = document.createNodeIterator(document, value, null);
52 |     assert_equals(it.whatToShow, expected);
53 |   }, "passing " + desc + " to Document.createNodeIterator coerces the value to an IDL unsigned long correctly");
54 | }
55 | 
56 | for (var i = 0; i < values.length; i += 3) {
57 |   var value = values[i];
58 |   var expected = values[i + 1];
59 |   var desc = values[i + 2];
60 |   test(function() {
61 |     var objectValue = { valueOf: function() { return value; }, toString: function() { return { } } };
62 |     if (value === null || typeof value != "object") {
63 |       var it = document.createNodeIterator(document, objectValue, null);
64 |       assert_equals(it.whatToShow, expected);
65 |     } else {
66 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
67 |       assert_throws(new TypeError(), function() { document.createNodeIterator(document, objectValue, null); });
68 |     }
69 |   }, "passing { valueOf: function() { return " + desc + " } } to Document.createNodeIterator coerces the value to an IDL unsigned long correctly");
70 | }
71 | 
72 | for (var i = 0; i < values.length; i += 3) {
73 |   var value = values[i];
74 |   var expected = values[i + 1];
75 |   var desc = values[i + 2];
76 |   test(function() {
77 |     var objectValue = { valueOf: function() { return { } }, toString: function() { return value; } };
78 |     if (value === null || typeof value != "object") {
79 |       var it = document.createNodeIterator(document, objectValue, null);
80 |       assert_equals(it.whatToShow, expected);
81 |     } else {
82 |       // ToPrimitive() will throw a TypeError if valueOf and toString both return an object.
83 |       assert_throws(new TypeError(), function() { document.createNodeIterator(document, objectValue, null); });
84 |     }
85 |   }, "passing { toString: function() { return " + desc + " } } to Document.createNodeIterator coerces the value to an IDL unsigned long correctly");
86 | }
87 | 
88 | test(function() {
89 |   assert_throws({ name: "SomeError" }, function() { document.createNodeIterator(document, { toString: function() { throw { name: "SomeError" }; } }, null); });
90 | }, "passing { toString: function() { throw ... } } to Document.createNodeIterator will propagate the exception");
91 | </script>
92 | 


--------------------------------------------------------------------------------
/meetings/18-03-Web-components.md:
--------------------------------------------------------------------------------
 1 | # Web Components meeting
 2 | 
 3 | [Actual agenda used (on etherpad)](https://public.etherpad-mozilla.org/p/web_components_agenda)
 4 | 
 5 | * [Complete Minutes, First Day](https://www.w3.org/2018/03/05-webplat-minutes.html)
 6 |   * [Open issues marked "needing consensus"](https://www.w3.org/2018/03/05-webplat-minutes.html#item04)
 7 |   * [Open issues marked "needs implementor interest](https://www.w3.org/2018/03/05-webplat-minutes.html#item05)
 8 |   * [Pseudo-classes](https://www.w3.org/2018/03/05-webplat-minutes.html#item06)
 9 |   * [Scoped Custom Element Registries](https://www.w3.org/2018/03/05-webplat-minutes.html#item07)
10 |   * [Accessibility and AoM](https://www.w3.org/2018/03/05-webplat-minutes.html#item08)
11 |   * [Form integration](https://www.w3.org/2018/03/05-webplat-minutes.html#item09)
12 | * [Complete Minutes, Second Day](https://www.w3.org/2018/03/06-webplat-minutes.html)
13 |   * [`template` instantiation](https://www.w3.org/2018/03/06-webplat-minutes.html#item01)
14 |   * [`:part` and `:theme`](https://www.w3.org/2018/03/06-webplat-minutes.html#item02)
15 |   * [Lightweight addition of styles](https://www.w3.org/2018/03/06-webplat-minutes.html#item04)
16 |   * [Declarative Shadow DOM](https://www.w3.org/2018/03/06-webplat-minutes.html#item06)
17 |   * [HTML Modules](https://www.w3.org/2018/03/06-webplat-minutes.html#item07)
18 |   * [Declarative Custome Elements](https://www.w3.org/2018/03/06-webplat-minutes.html#item08)
19 | 
20 | ## Tokyo, Japan, 5-6 March 2018
21 | 
22 | * The meeting was hosted by Google, 5 and 6 March 2018, in their offices in Roppongi, Tokyo.
23 | 
24 | ## Attendees
25 | 
26 | * [Takayashi Kochi](https://github.com/TakayoshiKochi) - Google
27 | * [Olli Pettay](https://github.com/smaug----) - Mozilla
28 | * [Jan Miksovsky](https://github.com/JanMiksovsky) - Invited expert (Component Kitchen)
29 | * [Ryosuke Niwa](https://github.com/rniwa) - Apple
30 | * [Tess O'Connor](https://github.com/hober) - Apple
31 | * [Michael[tm] Smith](https://github.com/sideshowbarker) - W3C
32 | * [Hayato Ito](https://github.com/hayatoito) - Google
33 | * [Tomek Wytrębowicz](https://github.com/tomalec) - Invited expert
34 | * [Patrick Kettner](https://github.com/patrickkettner) - Microsoft
35 | * [Justin Fagnani](https://github.com/justinfagnani) - Google
36 | * [Diego Ferreiro Val](https://github.com/diervo) - Salesforce
37 | * [Pierre-Marie Dartus](https://github.com/pmdartus) - Salesforce
38 | * [Eugene Kashida](https://github.com/ekashida) - Salesforce
39 | * [Domenic Denicola](https://github.com/domenic) - Google
40 | * [Anne van Kesteren](https://github.com/annevk) - Mozilla
41 | * [Chris Joel](https://github.com/cdata) - Google
42 | * [Kent Tamura](https://github.com/tkent-google) - Google
43 | * [Fergal Daly](https://github.com/fergald) - Google
44 | * [chaals nevile](https://github.com/chaals) - (WG co-chair)
45 | * [Trey Shugart](https://github.com/treshugart) - Atlassian
46 | * [Sangwhan Moon](https://github.com/cynthia) - Invited expert
47 | * [Rob Wormald](https://github.com/robwormald) - Google (Angular)
48 | * [Adam Bradley](https://github.com/adamdbradley) - (join remotely) ionic and stenciljs
49 | * [Jason Miller](https://github.com/developit) - (join remotely) Google (Preact)
50 | * [Qingqian Tao] - Baidu(MIP)
51 | * [Zhou Shen] - Baidu(MIP)
52 | 
53 | 
54 | ## Agenda
55 | 
56 | 
57 | The following is a draft proposal based on [discussion](https://github.com/w3c/webcomponents/issues/713) - 
58 | feel free to request topics in that issue, or make a pull request against this page.
59 | 
60 | ### Monday
61 | * Agenda building
62 | * Contentious bugs resolution
63 | * [Template instantiation](https://github.com/w3c/webcomponents/blob/gh-pages/proposals/Template-Instantiation.md)
64 | * Unconference 1
65 | 
66 | ### Tuesday
67 | * [HTML modules](https://github.com/w3c/webcomponents/issues/645)
68 | * [Scoped Custom Element Registries](https://github.com/w3c/webcomponents/issues/716) / [Declarative Shadow DOM](https://github.com/w3c/webcomponents/blob/gh-pages/proposals/Declarative-Shadow-DOM.md) - [gh issue](https://github.com/whatwg/dom/issues/510), [discourse](https://discourse.wicg.io/t/declarative-shadow-dom/1904)
69 | * Unconference 2
70 | * Unconference 3
71 | 
72 | 


--------------------------------------------------------------------------------
/implementations/webidl-1/tests/PutForwards-001.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <title>[PutForwards]</title>
  3 | <script src="https://w3c-test.org/resources/testharness.js"></script>
  4 | <script src="https://w3c-test.org/resources/testharnessreport.js"></script>
  5 | <script src="utils.js"></script>
  6 | <div id="log"></div>
  7 | 
  8 | <div id="hidden" style="visibility: hidden; position: absolute; width: 0; height: 0; overflow: hidden">
  9 |   <iframe id="iframe"></iframe>
 10 |   <span id="span1"></span>
 11 |   <span id="span2"></span>
 12 |   <span id="span3"></span>
 13 | </div>
 14 | 
 15 | <script>
 16 | // 4.5.6 Attributes
 17 | //
 18 | // If [PutForwards] is on an attribute, the property will have a setter,
 19 | // and invoking it will forward the assignment to the specified property
 20 | // on the object.
 21 | //
 22 | // Document.location is [Unforgeable], so it is not exposed as an
 23 | // accessor property.  HTMLElement.style is not [Unforgeable], so
 24 | // it will have an accessor property on HTMLElement.prototype.
 25 | 
 26 | // feature: Document.location (attribute) (with [PutForwards])
 27 | 
 28 | async_test(function(t) {
 29 |   var iframe = document.getElementById("iframe");
 30 |   var locationObject = iframe.contentDocument.location;
 31 |   var href = iframe.contentDocument.location.href;
 32 |   var newHref = "data:text/html,hello";
 33 | 
 34 |   iframe.onload = function() {
 35 |     iframe.onload = null;
 36 |     t.step(function() {
 37 |       assert_equals(iframe.contentDocument.location, locationObject);
 38 |       assert_not_equals(iframe.contentDocument.location.href, href);
 39 |       assert_equals(iframe.contentDocument.location.href, newHref);
 40 |       t.done();
 41 |     });
 42 |   };
 43 |   iframe.contentDocument.location = newHref;
 44 | }, "Document.location assignment forwards property assignment");
 45 | 
 46 | // feature: HTMLElement.style (attribute) (with [PutForwards])
 47 | 
 48 | test(function() {
 49 |   var desc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
 50 |   assert_true(!!desc, "!!desc");
 51 |   assert_true(!!desc.set, "!!desc.set");
 52 | }, "HTMLElement.protoype.style has a setter");
 53 | 
 54 | test(function() {
 55 |   var desc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
 56 |   assert_true(!!desc, "!!desc");
 57 |   assert_equals(desc.set.length, 1, "desc.set.length");
 58 | }, "HTMLElement.prototype.style setter has correct length property");
 59 | 
 60 | test(function() {
 61 |   var e = document.getElementById("span1");
 62 |   e.style.color = "red";
 63 | 
 64 |   assert_equals(e.style.color, "red");
 65 | 
 66 |   var styleObject = e.style;
 67 |   var oldStyle = e.style.cssText;
 68 |   var newStyle = "color: green";
 69 | 
 70 |   e.style = newStyle;
 71 | 
 72 |   assert_equals(e.style, styleObject);
 73 |   assert_not_equals(e.style.cssText, oldStyle);
 74 |   assert_equals(e.style.color, "green");
 75 | }, "HTMLElement.prototype.style setter forwards property assignment");
 76 | 
 77 | test(function() {
 78 |   var e = document.getElementById("span1");
 79 |   var desc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
 80 |   assert_true(!!desc, "!!desc");
 81 |   assert_throws(new TypeError(), function() {
 82 |     desc.set.call(e.style);
 83 |   });
 84 | }, "HTMLElement.prototype.style setter throws TypeError when called with no arguments");
 85 | 
 86 | test(function() {
 87 |   var e = document.getElementById("span2");
 88 |   var putInvoked = false;
 89 |   Object.defineProperty(e.style, "cssText", { set: function() { putInvoked = true; } });
 90 |   e.style = "color: pink";
 91 |   assert_true(putInvoked, "putInvoked");
 92 | }, "HTMLElement.prototype.style setter forwards to an object other than a CSSStyleDeclaration");
 93 | 
 94 | test(function() {
 95 |   var e = document.getElementById("span3");
 96 |   var desc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
 97 | 
 98 |   assert_true(!!desc, "!!desc");
 99 | 
100 |   var object = { };
101 |   Object.defineProperty(e, "style", { value: object });
102 | 
103 |   desc.set.call(e, "hello");
104 |   assert_equals(object.cssText, "hello");
105 | }, "HTMLElement.prototype.style setter invokes [[Get]] on the object to find the forwarded-to object");
106 | </script>
107 | 


--------------------------------------------------------------------------------