Enable shadowrealm testing for dom events api

dom/constants.js

@@ -9,3 +9,5 @@ function testConstants(objects, constants, msg) {
     }, "Constants for " + msg + " on " + desc + ".")
   })
 }
+// Expose function even when file imported as a module
+globalThis.testConstants = testConstants;

dom/events/AddEventListenerOptions-once.any.js

@@ -1,3 +1,4 @@
+// META: global=window,dedicatedworker,shadowrealm
 // META: title=AddEventListenerOptions.once
 
 "use strict";

dom/events/AddEventListenerOptions-passive.any.js

@@ -1,3 +1,4 @@
+// META: global=window,dedicatedworker,shadowrealm
 // META: title=AddEventListenerOptions.passive
 
 test(function() {

dom/events/AddEventListenerOptions-signal.any.js

@@ -1,3 +1,4 @@
+// META: global=window,dedicatedworker,shadowrealm
 'use strict';
 
 test(function() {

dom/events/CustomEvent-shadowrealm.any.js

@@ -0,0 +1,36 @@
+// META: global=shadowrealm
+
+// The non-ShadowRealm version of this test is in CustomEvent.html.
+
+test(function() {
+  var type = "foo";
+
+  var target = new EventTarget();
+  target.addEventListener(type, this.step_func(function(evt) {
+    assert_equals(evt.type, type);
+  }), true);
+
+  var fooEvent = new CustomEvent("foo", { bubbles: true, cancelable: true });
+  target.dispatchEvent(fooEvent);
+}, "CustomEvent dispatching.");
+
+test(function () {
+  assert_throws_js(TypeError, function() {
+    new CustomEvent();
+  });
+}, "First parameter to CustomEvent constructor should be mandatory.");
+
+test(function() {
+    var e = new CustomEvent("foo");
+    assert_throws_js(TypeError, function() {
+        e.initCustomEvent();
+    });
+}, "First parameter to initCustomEvent should be mandatory.");
+
+test(function() {
+  var e = new CustomEvent("foo");
+  assert_equals(e.type, "foo", "type");
+  assert_false(e.bubbles, "bubbles");
+  assert_false(e.cancelable, "cancelable");
+  assert_equals(e.detail, null, "detail");
+}, "CustomEvent's default option values.");

dom/events/Event-cancelBubble-shadowrealm.any.js

@@ -0,0 +1,41 @@
+// META: global=shadowrealm
+
+// The non-ShadowRealm version of this test is in Event-cancelBubble.html.
+
+test(function () {
+  // See https://dom.spec.whatwg.org/#stop-propagation-flag
+  var e = new Event("Event");
+  assert_false(e.cancelBubble, "cancelBubble must be false after event creation.");
+}, "cancelBubble must be false when an event is initially created.");
+
+test(function () {
+  // See https://dom.spec.whatwg.org/#dom-event-stoppropagation
+  var e = new Event("Event");
+  e.stopPropagation();
+  assert_true(e.cancelBubble, "stopPropagation() must set cancelBubble to true.");
+}, "stopPropagation() must set cancelBubble to true.");
+
+test(function () {
+  // See https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation
+  var e = new Event("Event");
+  e.stopImmediatePropagation();
+  assert_true(e.cancelBubble, "stopImmediatePropagation() must set cancelBubble to true.");
+}, "stopImmediatePropagation() must set cancelBubble to true.");
+
+test(function () {
+  var one = new Event("Event");
+  one.stopPropagation();
+  one.cancelBubble = false;
+  assert_true(one.cancelBubble, "cancelBubble must still be true after attempting to set it to false.");
+}, "Event.cancelBubble=false must have no effect.");
+
+test(function () {
+  // See https://dom.spec.whatwg.org/#concept-event-dispatch
+  // "14. Unset event’s [...] stop propagation flag,"
+  var e = new Event("foobar", { bubbles: true, cancelable: true });
+  addEventListener("foobar", function listener(e) {
+    e.stopPropagation();
+  });
+  dispatchEvent(e);
+  assert_false(e.cancelBubble, "cancelBubble must be false after an event has been dispatched.");
+}, "cancelBubble must be false after an event has been dispatched.");

dom/events/Event-constants-shadowrealm.any.js

@@ -0,0 +1,16 @@
+// META: global=shadowrealm
+// META: script=/dom/constants.js
+
+// The non-ShadowRealm version of this test is in Event-constants.html.
+
+var objects = [
+  [Event, "Event interface object"],
+  [Event.prototype, "Event prototype object"],
+];
+
+testConstants(objects, [
+  ["NONE", 0],
+  ["CAPTURING_PHASE", 1],
+  ["AT_TARGET", 2],
+  ["BUBBLING_PHASE", 3]
+], "eventPhase");

dom/events/Event-constructors.any.js

@@ -1,3 +1,4 @@
+// META: global=window,dedicatedworker,shadowrealm
 // META: title=Event constructors
 
 test(function() {

dom/events/Event-defaultPrevented-after-dispatch-shadowrealm.any.js

@@ -0,0 +1,36 @@
+// META: global=shadowrealm
+
+// The non-ShadowRealm version of this test is in
+// Event-defaultPrevented-after-dispatch.html.
+
+test(function() {
+    var EVENT = "foo";
+    var TARGET = new EventTarget();
+    var evt = new Event(EVENT, { bubbles: true, cancelable: true });
+
+    TARGET.addEventListener(EVENT, this.step_func(function(e) {
+        e.preventDefault();
+        assert_true(e.defaultPrevented, "during dispatch");
+    }), true);
+    TARGET.dispatchEvent(evt);
+
+    assert_true(evt.defaultPrevented, "after dispatch");
+    assert_equals(evt.target, TARGET);
+    assert_equals(evt.srcElement, TARGET);
+}, "Default prevention via preventDefault");
+
+test(function() {
+    var EVENT = "foo";
+    var TARGET = new EventTarget();
+    var evt = new Event(EVENT, { bubbles: true, cancelable: true });
+
+    TARGET.addEventListener(EVENT, this.step_func(function(e) {
+        e.returnValue = false;
+        assert_true(e.defaultPrevented, "during dispatch");
+    }), true);
+    TARGET.dispatchEvent(evt);
+
+    assert_true(evt.defaultPrevented, "after dispatch");
+    assert_equals(evt.target, TARGET);
+    assert_equals(evt.srcElement, TARGET);
+}, "Default prevention via returnValue");

dom/events/Event-defaultPrevented-shadowrealm.any.js

@@ -0,0 +1,39 @@
+// META: global=shadowrealm
+
+// The non-ShadowRealm version of this test is in Event-defaultPrevented.html.
+
+var ev;
+test(function() {
+  ev = new Event("foo", { bubbles: true, cancelable: false });
+  assert_equals(ev.defaultPrevented, false, "defaultPrevented");
+}, "When an event is created, defaultPrevented should be initialized to false.");
+
+test(function() {
+  assert_equals(ev.cancelable, false, "cancelable (before)");
+  ev.preventDefault();
+  assert_equals(ev.cancelable, false, "cancelable (after)");
+  assert_equals(ev.defaultPrevented, false, "defaultPrevented");
+}, "preventDefault() should not change defaultPrevented if cancelable is false.");
+
+test(function() {
+  assert_equals(ev.cancelable, false, "cancelable (before)");
+  ev.returnValue = false;
+  assert_equals(ev.cancelable, false, "cancelable (after)");
+  assert_equals(ev.defaultPrevented, false, "defaultPrevented");
+}, "returnValue should not change defaultPrevented if cancelable is false.");
+
+test(function() {
+  ev = new Event("foo", { bubbles: true, cancelable: true });
+  assert_equals(ev.cancelable, true, "cancelable (before)");
+  ev.preventDefault();
+  assert_equals(ev.cancelable, true, "cancelable (after)");
+  assert_equals(ev.defaultPrevented, true, "defaultPrevented");
+}, "preventDefault() should change defaultPrevented if cancelable is true.");
+
+test(function() {
+  ev.initEvent("foo", true, true);
+  assert_equals(ev.cancelable, true, "cancelable (before)");
+  ev.returnValue = false;
+  assert_equals(ev.cancelable, true, "cancelable (after)");
+  assert_equals(ev.defaultPrevented, true, "defaultPrevented");
+}, "returnValue should change defaultPrevented if cancelable is true.");

dom/events/Event-init-while-dispatching-shadowrealm.any.js

@@ -0,0 +1,50 @@
+// META: global=shadowrealm
+
+// The non-ShadowRealm version of this test is in
+// Event-init-while-dispatching.html.
+
+var events = {
+  'CustomEvent': {
+    'constructor': function() { return new CustomEvent("type") },
+    'init': function(ev) { ev.initCustomEvent("type2", true, true, 1) },
+    'check': function(ev) {
+      assert_equals(ev.detail, null, "initCustomEvent detail setter should short-circuit");
+    }
+  },
+  'Event': {
+    'constructor': function() { return new Event("type") },
+    'init': function(ev) { ev.initEvent("type2", true, true) },
+    'check': function(ev) {
+      assert_equals(ev.bubbles, false, "initEvent bubbles setter should short-circuit");
+      assert_equals(ev.cancelable, false, "initEvent cancelable setter should short-circuit");
+      assert_equals(ev.type, "type", "initEvent type setter should short-circuit");
+    }
+  }
+};
+
+var names = Object.keys(events);
+for (var i = 0; i < names.length; i++) {
+  var t = async_test("Calling init" + names[i] + " while dispatching.");
+  t.step(function() {
+    var e = events[names[i]].constructor();
+    var called = false;
+
+    var target = new EventTarget();
+    target.addEventListener("type", t.step_func(function() {
+      called = true;
+      events[names[i]].init(e);
+
+      var o = e;
+      while ((o = Object.getPrototypeOf(o))) {
+        if (!(o.constructor.name in events)) {
+          break;
+        }
+        events[o.constructor.name].check(e);
+      }
+    }), false);
+
+    assert_equals(target.dispatchEvent(e), true, "dispatchEvent must return true");
+    assert_true(called, "callback should be called");
+  });
+  t.done();
+}

dom/events/Event-initEvent-shadowrealm.any.js

@@ -0,0 +1,132 @@
+// META: global=shadowrealm
+
+// The non-ShadowRealm version of this test is in Event-initEvent.html.
+
+var booleans = [true, false];
+booleans.forEach(function(bubbles) {
+  booleans.forEach(function(cancelable) {
+    test(function() {
+      var e = new Event("");
+      e.initEvent("type", bubbles, cancelable);
+
+      // Step 2.
+      // Stop (immediate) propagation flag is tested later
+      assert_equals(e.defaultPrevented, false, "defaultPrevented");
+      assert_equals(e.returnValue, true, "returnValue");
+      // Step 3.
+      assert_equals(e.isTrusted, false, "isTrusted");
+      // Step 4.
+      assert_equals(e.target, null, "target");
+      assert_equals(e.srcElement, null, "srcElement");
+      // Step 5.
+      assert_equals(e.type, "type", "type");
+      // Step 6.
+      assert_equals(e.bubbles, bubbles, "bubbles");
+      // Step 7.
+      assert_equals(e.cancelable, cancelable, "cancelable");
+    }, "Properties of initEvent(type, " + bubbles + ", " + cancelable + ")");
+  });
+});
+
+test(function() {
+  var e = new Event("");
+  e.initEvent("type 1", true, false);
+  assert_equals(e.type, "type 1", "type (first init)");
+  assert_equals(e.bubbles, true, "bubbles (first init)");
+  assert_equals(e.cancelable, false, "cancelable (first init)");
+
+  e.initEvent("type 2", false, true);
+  assert_equals(e.type, "type 2", "type (second init)");
+  assert_equals(e.bubbles, false, "bubbles (second init)");
+  assert_equals(e.cancelable, true, "cancelable (second init)");
+}, "Calling initEvent multiple times (getting type).");
+
+test(function() {
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=998809
+  var e = new Event("");
+  e.initEvent("type 1", true, false);
+  assert_equals(e.bubbles, true, "bubbles (first init)");
+  assert_equals(e.cancelable, false, "cancelable (first init)");
+
+  e.initEvent("type 2", false, true);
+  assert_equals(e.type, "type 2", "type (second init)");
+  assert_equals(e.bubbles, false, "bubbles (second init)");
+  assert_equals(e.cancelable, true, "cancelable (second init)");
+}, "Calling initEvent multiple times (not getting type).");
+
+// Step 2.
+async_test(function() {
+  // https://www.w3.org/Bugs/Public/show_bug.cgi?id=17715
+
+  var e = new Event("");
+  e.initEvent("type", false, false);
+  assert_equals(e.type, "type", "type (first init)");
+  assert_equals(e.bubbles, false, "bubbles (first init)");
+  assert_equals(e.cancelable, false, "cancelable (first init)");
+
+  var target = new EventTarget();
+  target.addEventListener("type", this.step_func(function() {
+    e.initEvent("fail", true, true);
+    assert_equals(e.type, "type", "type (second init)");
+    assert_equals(e.bubbles, false, "bubbles (second init)");
+    assert_equals(e.cancelable, false, "cancelable (second init)");
+  }), false);
+
+  assert_equals(target.dispatchEvent(e), true, "dispatchEvent must return true");
+
+  this.done();
+}, "Calling initEvent must not have an effect during dispatching.");
+
+test(function() {
+  var e = new Event("");
+  e.stopPropagation();
+  e.initEvent("type", false, false);
+  var target = new EventTarget();
+  var called = false;
+  target.addEventListener("type", function() { called = true; }, false);
+  assert_false(e.cancelBubble, "cancelBubble must be false");
+  assert_true(target.dispatchEvent(e), "dispatchEvent must return true");
+  assert_true(called, "Listener must be called");
+}, "Calling initEvent must unset the stop propagation flag.");
+
+test(function() {
+  var e = new Event("");
+  e.stopImmediatePropagation();
+  e.initEvent("type", false, false);
+  var target = new EventTarget();
+  var called = false;
+  target.addEventListener("type", function() { called = true; }, false);
+  assert_true(target.dispatchEvent(e), "dispatchEvent must return true");
+  assert_true(called, "Listener must be called");
+}, "Calling initEvent must unset the stop immediate propagation flag.");
+
+async_test(function() {
+  var e = new Event("");
+  e.initEvent("type", false, false);
+
+  var target = new EventTarget();
+  target.addEventListener("type", this.step_func(function() {
+    e.initEvent("type2", true, true);
+    assert_equals(e.type, "type", "initEvent type setter should short-circuit");
+    assert_false(e.bubbles, "initEvent bubbles setter should short-circuit");
+    assert_false(e.cancelable, "initEvent cancelable setter should short-circuit");
+  }), false);
+  assert_equals(target.dispatchEvent(e), true, "dispatchEvent must return true");
+
+  this.done();
+}, "Calling initEvent during propagation.");
+
+test(function() {
+  var e = new Event("");
+  assert_throws_js(TypeError, function() {
+    e.initEvent();
+  });
+}, "First parameter to initEvent should be mandatory.");
+
+test(function() {
+  var e = new Event("");
+  e.initEvent("type");
+  assert_equals(e.type, "type", "type");
+  assert_false(e.bubbles, "bubbles");
+  assert_false(e.cancelable, "cancelable");
+}, "Tests initEvent's default parameter values.");

dom/events/Event-isTrusted.any.js

@@ -1,3 +1,5 @@
+// META: global=window,dedicatedworker,shadowrealm
+
 test(function() {
   var desc1 = Object.getOwnPropertyDescriptor(new Event("x"), "isTrusted");
   assert_not_equals(desc1, undefined);