1 files changed, 213 insertions, 0 deletions
diff --git a/testing/web-platform/tests/scheduler/task-signal-any-priority.tentative.any.js b/testing/web-platform/tests/scheduler/task-signal-any-priority.tentative.any.js
new file mode 100644
index 0000000000..46af80b8b1
--- /dev/null
+++ b/testing/web-platform/tests/scheduler/task-signal-any-priority.tentative.any.js
@@ -0,0 +1,213 @@
+// META: global=window,worker
+
+test((t) => {
+  const signal = TaskSignal.any([]);
+  assert_true(signal instanceof TaskSignal);
+  assert_equals(signal.priority, 'user-visible');
+}, "TaskSignal.any() returns a user-visible TaskSignal when no priority is specified");
+
+test((t) => {
+  let signal = TaskSignal.any([], {priority: 'user-blocking'});
+  assert_equals(signal.priority, 'user-blocking');
+
+  signal = TaskSignal.any([], {priority: 'user-visible'});
+  assert_equals(signal.priority, 'user-visible');
+
+  signal = TaskSignal.any([], {priority: 'background'});
+  assert_equals(signal.priority, 'background');
+}, "TaskSignal.any() returns a signal with the correct priority when intialized with a string");
+
+test((t) => {
+  let controller = new TaskController({priority: 'user-blocking'});
+  let signal = TaskSignal.any([], {priority: controller.signal});
+  assert_equals(signal.priority, 'user-blocking');
+
+  controller = new TaskController({priority: 'user-visible'});
+  signal = TaskSignal.any([], {priority: controller.signal});
+  assert_equals(signal.priority, 'user-visible');
+
+  controller = new TaskController({priority: 'background'});
+  signal = TaskSignal.any([], {priority: controller.signal});
+  assert_equals(signal.priority, 'background');
+}, "TaskSignal.any() returns a signal with the correct priority when intialized with a TaskSignal");
+
+test((t) => {
+  let controller = new TaskController({priority: 'user-blocking'});
+  let signal = TaskSignal.any([], {priority: controller.signal});
+  assert_equals(signal.priority, 'user-blocking');
+
+  controller.setPriority('user-visible');
+  assert_equals(signal.priority, 'user-visible');
+
+  controller.setPriority('background');
+  assert_equals(signal.priority, 'background');
+
+  controller.setPriority('user-blocking');
+  assert_equals(signal.priority, 'user-blocking');
+}, "TaskSignal.any() returns a signal with dynamic priority");
+
+test((t) => {
+  const controller = new TaskController();
+  const signal = TaskSignal.any([], {priority: controller.signal});
+
+  let eventFiredCount = 0;
+  signal.onprioritychange = t.step_func((e) => {
+    assert_equals(e.target, signal,
+        `The event target is the signal returned by TaskSignal.any()`);
+    ++eventFiredCount;
+  });
+
+  controller.setPriority('background');
+  assert_equals(eventFiredCount, 1);
+
+  controller.setPriority('user-visible');
+  assert_equals(eventFiredCount, 2);
+
+  controller.setPriority('user-blocking');
+  assert_equals(eventFiredCount, 3);
+}, "Priority change events fire for composite signals");
+
+
+test((t) => {
+  const controller = new TaskController();
+  let signal = TaskSignal.any([], {priority: controller.signal});
+  signal = TaskSignal.any([], {priority: signal});
+  signal = TaskSignal.any([], {priority: signal});
+  signal = TaskSignal.any([], {priority: signal});
+  signal = TaskSignal.any([], {priority: signal});
+
+  assert_equals(signal.priority, 'user-visible');
+
+  let eventFiredCount = 0;
+  signal.onprioritychange = t.step_func((e) => {
+    assert_equals(e.target, signal,
+        "The event target is the signal returned by TaskSignal.any()");
+    ++eventFiredCount;
+  });
+
+  controller.setPriority('background');
+  assert_equals(eventFiredCount, 1);
+  assert_equals(signal.priority, 'background');
+
+  controller.setPriority('user-visible');
+  assert_equals(eventFiredCount, 2);
+  assert_equals(signal.priority, 'user-visible');
+
+  controller.setPriority('user-blocking');
+  assert_equals(eventFiredCount, 3);
+  assert_equals(signal.priority, 'user-blocking');
+}, "Priority change events fire for composite signals with intermediate sources");
+
+test((t) => {
+  const controller = new TaskController();
+  const signals = [];
+  const results = [];
+
+  let id = 0;
+  for (let i = 0; i < 3; i++) {
+    const signal = TaskSignal.any([], {priority: controller.signal});
+    const eventId = id++;
+    signal.addEventListener('prioritychange', () => {
+      results.push(eventId);
+    });
+    signals.push(signal);
+  }
+  for (let i = 0; i < 3; i++) {
+    const signal = TaskSignal.any([], {priority: signals[i]});
+    const eventId = id++;
+    signal.addEventListener('prioritychange', () => {
+      results.push(eventId);
+    });
+  }
+
+  controller.setPriority('background');
+  assert_equals(results.toString(), '0,1,2,3,4,5')
+
+  controller.setPriority('user-blocking');
+  assert_equals(results.toString(), '0,1,2,3,4,5,0,1,2,3,4,5')
+}, "Priority change propagates to multiple dependent signals in the right order");
+
+test((t) => {
+  const controller = new TaskController();
+  const signal = TaskSignal.any([], {priority: controller.signal});
+
+  let fired = false;
+  signal.onabort = t.step_func(() => {
+    assert_unreached("The signal should not abort");
+    fired = true;
+  });
+
+  controller.abort();
+  assert_false(fired);
+}, "TaskSignal.any() does not propagate abort when not given dependent abort signals");
+
+test((t) => {
+  const taskController = new TaskController();
+  const abortController = new AbortController();
+  const signal = TaskSignal.any([abortController.signal], {priority: taskController.signal});
+
+  let priorityFireCount = 0;
+  signal.onprioritychange = t.step_func(() => {
+    ++priorityFireCount;
+  });
+
+  let abortFired = false;
+  signal.onabort = t.step_func(() => {
+    abortFired = true;
+  });
+
+  taskController.setPriority('background');
+  assert_equals(signal.priority, 'background');
+  assert_equals(priorityFireCount, 1);
+
+  taskController.abort();
+  assert_false(abortFired, "The signal should use abortController for abort");
+
+  abortController.abort();
+  assert_true(abortFired);
+
+  taskController.setPriority('user-visible');
+  assert_equals(signal.priority, 'user-visible');
+  assert_equals(priorityFireCount, 2);
+}, "TaskSignal.any() propagates abort and priority");
+
+
+test((t) => {
+  const controller = new TaskController();
+  const signal = TaskSignal.any([AbortSignal.abort()], {priority: controller.signal});
+
+  let fired = false;
+  signal.onprioritychange = t.step_func(() => {
+    fired = true;
+  });
+
+  controller.setPriority('background');
+  assert_true(fired);
+}, "TaskSignal.any() propagates priority after returning an aborted signal");
+
+test((t) => {
+  // Add a dependent in the initial event dispatch stage.
+  let controller = new TaskController();
+  let fired = false;
+  controller.signal.onprioritychange = t.step_func(() => {
+    fired = true;
+    const newSignal = TaskSignal.any([], {priority: controller.signal});
+    assert_equals(newSignal.priority, 'background');
+    newSignal.onprioritychange = t.unreached_func('onprioritychange called');
+  });
+  controller.setPriority('background');
+  assert_true(fired);
+
+  // Add a dependent while signaling prioritychange on dependents.
+  fired = false;
+  controller = new TaskController();
+  const signal = TaskSignal.any([], {priority: controller.signal});
+  signal.onprioritychange = t.step_func(() => {
+    fired = true;
+    const newSignal = TaskSignal.any([], {priority: signal});
+    assert_equals(newSignal.priority, 'background');
+    newSignal.onprioritychange = t.unreached_func('onprioritychange called');
+  });
+  controller.setPriority('background');
+  assert_true(fired);
+}, "TaskSignal.any() does not fire prioritychange for dependents added during prioritychange");