task-signal-any-priority.tentative.any.js

Enable keyboard shortcuts

This test has a WPT meta file that expects 10 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /scheduler/task-signal-any-priority.tentative.any.html - WPT Dashboard Interop Dashboard
- /scheduler/task-signal-any-priority.tentative.any.serviceworker.html - WPT Dashboard Interop Dashboard
- /scheduler/task-signal-any-priority.tentative.any.sharedworker.html - WPT Dashboard Interop Dashboard
- /scheduler/task-signal-any-priority.tentative.any.worker.html - WPT Dashboard Interop Dashboard

// 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");