2dcontext/imagebitmap/createImageBitmap-invalid-args.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>