<!DOCTYPE html>
<!-- DO NOT EDIT! This test has been generated by tools/gentest.py. -->
<title>OffscreenCanvas test: 2d.imageData.put.wrongtype</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/common/canvas-tests.js"></script>

<h1>2d.imageData.put.wrongtype</h1>
<p class="desc">putImageData() does not accept non-ImageData objects</p>


<script>
var t = async_test("putImageData() does not accept non-ImageData objects");
t.step(function() {

var offscreenCanvas = new OffscreenCanvas(100, 50);
var ctx = offscreenCanvas.getContext('2d');

var imgdata = { width: 1, height: 1, data: [255, 0, 0, 255] };
assert_throws(new TypeError(), function() { ctx.putImageData(imgdata, 0, 0); });
assert_throws(new TypeError(), function() { ctx.putImageData("cheese", 0, 0); });
assert_throws(new TypeError(), function() { ctx.putImageData(42, 0, 0); });

t.done();

});
</script>
