<!DOCTYPE html>
<!-- DO NOT EDIT! This test has been generated by tools/gentest.py. -->
<title>Canvas test: toDataURL.jpeg.alpha</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/common/canvas-tests.js"></script>
<link rel="stylesheet" href="/common/canvas-tests.css">
<body class="show_output">

<h1>toDataURL.jpeg.alpha</h1>
<p class="desc">toDataURL with JPEG composites onto black</p>


<p class="output">Actual output:</p>
<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
<p class="output expectedtext">Expected output:<p><img src="toDataURL.jpeg.alpha.png" class="output expected" id="expected" alt="">
<ul id="d"></ul>
<script>
var t = async_test("toDataURL with JPEG composites onto black");
_addTest(function(canvas, ctx) {

ctx.fillStyle = 'rgba(128, 255, 128, 0.5)';
ctx.fillRect(0, 0, 100, 50);
ctx.globalCompositeOperation = 'destination-over'; // should be ignored by toDataURL
var data = canvas.toDataURL('image/jpeg');
ctx.globalCompositeOperation = 'source-over';
if (!data.match(/^data:image\/jpeg[;,]/)) {
  _assert(true, "true");
} else {
  ctx.fillStyle = '#f00';
  ctx.fillRect(0, 0, 100, 50);
  var img = new Image();
  deferTest();
  img.onload = t.step_func_done(function ()
  {
      ctx.drawImage(img, 0, 0);
      _assertPixelApprox(canvas, 50,25, 63,127,63,255, "50,25", "63,127,63,255", 8);
  });
  img.src = data;
}


});
</script>

