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: 8ba8d81fc0a97e9f5332a23d532ee9b40cf3104b authored by moz-wptsync-bot on 11 January 2018, 16:11:49 UTC
P2: Add wpt tests to verify service workers redirect the hash fragment if the redirect URL doesn't have one.
Tip revision: 8ba8d81
createImageBitmap-invalid-args.html 
<!doctype html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="common.js"></script>
<script>

function makeOversizedCanvas() {

  return new Promise(resolve => {
    let canvas = document.createElement('canvas');
    canvas.setAttribute('width', '100000000');
    canvas.setAttribute('height', '100000000');
    resolve(canvas);
  });
}

function makeOversizedOffscreenCanvas() {
  return new Promise(resolve =>{
    let canvas = new OffscreenCanvas(100000000, 100000000);
    resolve(canvas);
  });
}

function makeInvalidBlob() {
  return new Promise(resolve => {
    resolve(new Blob()); // Blob with no data cannot be decoded.
  });
}

function makeBrokenImage() {
  return new Promise(resolve => {
    const image = new Image();
    image.src = "data:,x";
    image.onerror = () => resolve(image);
  });
}

function makeAvailableButBrokenImage() {
  return new Promise((resolve, reject) => {
    const image = new Image();
    image.src = "/images/broken.png";
    image.onload = () => resolve(image);
    image.onerror = reject;
  });
}

testCases = [
  {
    description: 'createImageBitmap with a <sourceType> source and sw set to 0',
    promiseTestFunction:
      (source, t) => {
        return promise_rejects(t, new RangeError(),
            createImageBitmap(source, 0, 0, 0, 10));
      }
  },
  {
    description: 'createImageBitmap with a <sourceType> source and sh set to 0',
    promiseTestFunction:
      (source, t) => {
        return promise_rejects(t, new RangeError(),
            createImageBitmap(source, 0, 0, 10, 0));
      }
  },
  {
    // This case is not explicitly documented in the specification for
    // createImageBitmap, but it is expected that internal failures cause
    // InvalidStateError.
    //
    // Note: https://bugs.chromium.org/p/chromium/issues/detail?id=799025
    description: 'createImageBitmap with a <sourceType> source and oversized ' +
        '(unallocatable) crop region',
    promiseTestFunction:
      (source, t) => {
        return promise_rejects(t, new DOMException('', 'InvalidStateError'),
            createImageBitmap(source, 0, 0, 100000000, 100000000));
      }
  },
];

// Generate the test matrix for each sourceType + testCase combo.
imageSourceTypes.forEach(imageSourceType => {
  testCases.forEach(testCase => {
    let description = testCase.description.replace('<sourceType>',
        imageSourceType.name);
    promise_test( t => {
      return imageSourceType.factory().then(source => {
        return testCase.promiseTestFunction(source, t);
      });
    }, description);
  });
});

promise_test( t => {
  return promise_rejects(t, new TypeError(), createImageBitmap(undefined));
}, "createImageBitmap with undefined image source.");

promise_test( t => {
  return promise_rejects(t, new TypeError(), createImageBitmap(null));
}, "createImageBitmap with null image source.");

promise_test( t => {
  return promise_rejects(t, "InvalidStateError",
    createImageBitmap(new Image()));
}, "createImageBitmap with empty image source.");

promise_test( t => {
  return promise_rejects(t, "InvalidStateError",
    createImageBitmap(document.createElement('video')));
}, "createImageBitmap with empty video source.");

promise_test( t => {
  return makeOversizedCanvas().then(canvas => {
    return promise_rejects(t, "InvalidStateError",
        createImageBitmap(canvas));
  });
}, "createImageBitmap with an oversized canvas source.");

promise_test( t => {
  return makeOversizedOffscreenCanvas().then(offscreenCanvas => {
    return promise_rejects(t, "InvalidStateError",
        createImageBitmap(offscreenCanvas));
  });
}, "createImageBitmap with an invalid OffscreenCanvas source.");

promise_test( t => {
  return makeInvalidBlob().then(blob => {
    return promise_rejects(t, "InvalidStateError",
        createImageBitmap(blob));
  });
}, "createImageBitmap with an undecodable blob source.");

promise_test( t => {
  return makeBrokenImage().then(image => {
    return promise_rejects(t, "InvalidStateError",
        createImageBitmap(image));
  });
}, "createImageBitmap with a broken image source.");

promise_test( t => {
  return makeAvailableButBrokenImage().then(image => {
    return promise_rejects(t, "InvalidStateError",
        createImageBitmap(image));
  });
}, "createImageBitmap with an available but undecodable image source.");

promise_test( t => {
  return makeImageBitmap().then(bitmap => {
    bitmap.close()
    return promise_rejects(t, "InvalidStateError", createImageBitmap(bitmap));
  });
}, "createImageBitmap with a closed ImageBitmap.");
</script>
back to top