Skip to main content

Browse the archive

https://github.com/web-platform-tests/wpt
26 December 2018, 22:31:15 UTC
Raw File
Tip revision: 410ecd8aff1b5ef73898773094339deb2df92a9c authored by moz-wptsync-bot on 16 March 2018, 11:12:05 UTC
WPT should use toString() and not toSource(),
Tip revision: 410ecd8
extendable-event-async-waituntil.https.html 
<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="resources/testharness-helpers.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="resources/test-helpers.sub.js"></script>
<script>

function sync_message(worker, message, transfer) {
  let wait = new Promise((res, rej) => {
    navigator.serviceWorker.addEventListener('message', function(e) {
        if (e.data === 'ACK') {
          res();
        } else {
          rej();
        }
      });
    });
  worker.postMessage(message, transfer);
  return wait;
}

function runTest(test, step, testBody) {
  var scope = './resources/' + step;
  var script = 'resources/extendable-event-async-waituntil.js?' + scope;
  service_worker_unregister_and_register(test, script, scope)
    .then(function(registration) {
        let worker = registration.installing;
        var channel = new MessageChannel();
        var saw_message = new Promise(function(resolve) {
          channel.port1.onmessage = function(e) { resolve(e.data); }
        });

        wait_for_state(test, worker, 'activated')
          .then(function() {
              return sync_message(worker, { step: 'init', port: channel.port2 },
                [channel.port2]);
            })
          .then(function() { return testBody(worker); })
          .then(function() { return saw_message; })
          .then(function(output) {
              assert_equals(output.result, output.expected);
            })
          .then(function() { return sync_message(worker, { step: 'done' }); })
          .then(() => { service_worker_unregister_and_done(test, scope); })
          .catch(unreached_rejection(test));
      });
}

function msg_event_test(scope, test) {
  var testBody = function(worker) {
    return sync_message(worker, { step: scope });
  };
  runTest(test, scope, testBody);
}

async_test(msg_event_test.bind(this, 'no-current-extension-different-task'),
  'Test calling waitUntil in a different task without an existing extension throws');

async_test(msg_event_test.bind(this, 'no-current-extension-different-microtask'),
  'Test calling waitUntil in a different microtask without an existing extension throws');

async_test(msg_event_test.bind(this, 'current-extension-different-task'),
  'Test calling waitUntil in a different task with an existing extension succeeds');

async_test(msg_event_test.bind(this, 'current-extension-expired-same-microtask-turn'),
  'Test calling waitUntil with an existing extension promise handler succeeds');

// The promise handler will queue a new microtask after the check for new
// extensions was performed.
async_test(msg_event_test.bind(this, 'current-extension-expired-same-microtask-turn-extra'),
  'Test calling waitUntil at the end of the microtask turn throws');

async_test(msg_event_test.bind(this, 'current-extension-expired-different-task'),
  'Test calling waitUntil after the current extension expired in a different task fails');

async_test(msg_event_test.bind(this, 'script-extendable-event'),
  'Test calling waitUntil on a script constructed ExtendableEvent throws exception');

async_test(function(t) {
    var testBody = function(worker) {
      return with_iframe('./resources/pending-respondwith-async-waituntil/dummy.html');
    }
    runTest(t, 'pending-respondwith-async-waituntil', testBody);
  }, 'Test calling waitUntil asynchronously with pending respondWith promise.');

async_test(function(t) {
    var testBody = function(worker) {
      return with_iframe('./resources/respondwith-microtask-sync-waituntil/dummy.html');
    }
    runTest(t, 'respondwith-microtask-sync-waituntil', testBody);
  }, 'Test calling waitUntil synchronously inside microtask of respondWith promise.');

async_test(function(t) {
    var testBody = function(worker) {
      return with_iframe('./resources/respondwith-microtask-async-waituntil/dummy.html');
    }
    runTest(t, 'respondwith-microtask-async-waituntil', testBody);
  }, 'Test calling waitUntil asynchronously inside microtask of respondWith promise.');


</script>
back to top