mirror of
https://github.com/servo/servo.git
synced 2025-07-22 23:03:42 +01:00
187 lines
5.5 KiB
HTML
187 lines
5.5 KiB
HTML
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
|
|
<html>
|
|
<head>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
</head>
|
|
<body>
|
|
<script>
|
|
|
|
function makeCanvas() {
|
|
return new Promise(resolve => {
|
|
let canvas = document.createElement('canvas');
|
|
canvas.setAttribute('width', '10');
|
|
canvas.setAttribute('height', '10');
|
|
resolve(canvas);
|
|
});
|
|
}
|
|
|
|
function makeOffscreenCanvas() {
|
|
return new Promise(resolve => {
|
|
let canvas = new OffscreenCanvas(10, 10);
|
|
resolve(canvas);
|
|
});
|
|
}
|
|
|
|
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 makeVideo() {
|
|
return new Promise(resolve => {
|
|
let video = document.createElement('video');
|
|
video.addEventListener('canplaythrough', resolve.bind(undefined, video), false);
|
|
video.src = '/media/A4.ogv';
|
|
});
|
|
}
|
|
|
|
function makeImage() {
|
|
return makeCanvas().then(canvas => {
|
|
let image = new Image();
|
|
image.src = canvas.toDataURL();
|
|
return new Promise(resolve => {
|
|
image.onload = resolve.bind(undefined, image);
|
|
});
|
|
});
|
|
}
|
|
|
|
function makeImageData() {
|
|
return makeCanvas().then(canvas => {
|
|
return new Promise(function(resolve, reject) {
|
|
resolve(canvas.getContext('2d').getImageData(0, 0, 10, 10));
|
|
});
|
|
});
|
|
}
|
|
|
|
function makeImageBitmap() {
|
|
return makeCanvas().then(canvas => {
|
|
return createImageBitmap(canvas);
|
|
});
|
|
}
|
|
|
|
function makeBlob() {
|
|
return makeCanvas().then(canvas => {
|
|
return new Promise(resolve => {
|
|
canvas.toBlob(resolve);
|
|
});
|
|
});
|
|
}
|
|
|
|
function makeInvalidBlob() {
|
|
return new Promise(resolve => {
|
|
resolve(new Blob()); // Blob with no data cannot be decoded.
|
|
});
|
|
}
|
|
|
|
imageSourceTypes = [
|
|
{ name: 'HTMLImageElement', factory: makeImage },
|
|
{ name: 'HTMLVideoElement', factory: makeVideo },
|
|
{ name: 'HTMLCanvasElement', factory: makeCanvas },
|
|
{ name: 'OffscreenCanvas', factory: makeOffscreenCanvas },
|
|
{ name: 'ImageData', factory: makeImageData },
|
|
{ name: 'ImageBitmap', factory: makeImageBitmap },
|
|
{ name: 'Blob', factory: makeBlob },
|
|
];
|
|
|
|
testCases = [
|
|
{
|
|
description: 'createImageBitmap with a <sourceType> source and sw set to ' +
|
|
'0 rejects with a RangeError.',
|
|
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 rejects with a RangeError.',
|
|
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
|
|
//
|
|
description: 'createImageBitmap with a <sourceType> source and oversized ' +
|
|
'(unallocatable) crop region rejects with an InvalidStateError ' +
|
|
'DOMException.',
|
|
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 rejects with a TypeError.");
|
|
|
|
promise_test( t => {
|
|
return promise_rejects(t, new TypeError(), createImageBitmap(null));
|
|
}, "createImageBitmap with null image source rejects with a TypeError.");
|
|
|
|
promise_test( t => {
|
|
return promise_rejects(t, new DOMException('', 'InvalidStateError'),
|
|
createImageBitmap(new Image()));
|
|
}, "createImageBitmap with empty image source rejects with a InvalidStateError.");
|
|
|
|
promise_test( t => {
|
|
return promise_rejects(t, new DOMException('', 'InvalidStateError'),
|
|
createImageBitmap(document.createElement('video')));
|
|
}, "createImageBitmap with empty video source rejects with a InvalidStateError.");
|
|
|
|
promise_test( t => {
|
|
return makeOversizedCanvas().then(canvas => {
|
|
return promise_rejects(t, new DOMException('', 'InvalidStateError'),
|
|
createImageBitmap(canvas));
|
|
});
|
|
}, "createImageBitmap with an oversized canvas source rejects with a RangeError.");
|
|
|
|
promise_test( t => {
|
|
return makeOversizedOffscreenCanvas().then(offscreenCanvas => {
|
|
return promise_rejects(t, new DOMException('', 'InvalidStateError'),
|
|
createImageBitmap(offscreenCanvas));
|
|
});
|
|
}, "createImageBitmap with an invalid OffscreenCanvas source rejects with a RangeError.");
|
|
|
|
promise_test( t => {
|
|
return makeInvalidBlob().then(blob => {
|
|
return promise_rejects(t, new DOMException('', 'InvalidStateError'),
|
|
createImageBitmap(blob));
|
|
});
|
|
}, "createImageBitmap with an undecodable blob source rejects with an InvalidStateError.");
|
|
|
|
</script>
|
|
</body>
|
|
</html>
|