src/third_party/web_platform_tests/2dcontext/tools/tests2d.yaml

# Copyright (c) 2011 Philip Taylor
# Released under the BSD license and W3C Test Suite License: see LICENSE.txt

- name: 2d.getcontext.exists
  desc: The 2D context is implemented
  testing:
    - context.2d
  code: |
    @assert canvas.getContext('2d') !== null;

- name: 2d.getcontext.extraargs
  desc: The 2D context ignores extra getContext arguments
  testing:
    - context.2d.extraargs
  code: |
    @assert canvas.getContext('2d', false, {}, [], 1, "2") !== null;

- name: 2d.type.exists
  desc: The 2D context interface is a property of 'window'
  notes: &bindings Defined in "Web IDL" (draft)
  testing:
    - context.2d.type
  code: |
    @assert window.CanvasRenderingContext2D;

- name: 2d.type.delete
  desc: window.CanvasRenderingContext2D is Configurable
  notes: *bindings
  testing:
    - context.2d.type
  code: |
    @assert window.CanvasRenderingContext2D !== undefined;
    @assert delete window.CanvasRenderingContext2D === true;
    @assert window.CanvasRenderingContext2D === undefined;

- name: 2d.type.prototype
  desc: window.CanvasRenderingContext2D.prototype are not [[Writable]] and not [[Configurable]], and its methods are [[Configurable]].
  notes: *bindings
  testing:
    - context.2d.type
  code: |
    @assert window.CanvasRenderingContext2D.prototype;
    @assert window.CanvasRenderingContext2D.prototype.fill;
    window.CanvasRenderingContext2D.prototype = null;
    @assert window.CanvasRenderingContext2D.prototype;
    delete window.CanvasRenderingContext2D.prototype;
    @assert window.CanvasRenderingContext2D.prototype;
    window.CanvasRenderingContext2D.prototype.fill = 1;
    @assert window.CanvasRenderingContext2D.prototype.fill === 1;
    delete window.CanvasRenderingContext2D.prototype.fill;
    @assert window.CanvasRenderingContext2D.prototype.fill === undefined;

- name: 2d.type.replace
  desc: Interface methods can be overridden
  notes: *bindings
  testing:
    - context.2d.type
  code: |
    var fillRect = window.CanvasRenderingContext2D.prototype.fillRect;
    window.CanvasRenderingContext2D.prototype.fillRect = function (x, y, w, h)
    {
        this.fillStyle = '#0f0';
        fillRect.call(this, x, y, w, h);
    };
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.type.extend
  desc: Interface methods can be added
  notes: *bindings
  testing:
    - context.2d.type
  code: |
    window.CanvasRenderingContext2D.prototype.fillRectGreen = function (x, y, w, h)
    {
        this.fillStyle = '#0f0';
        this.fillRect(x, y, w, h);
    };
    ctx.fillStyle = '#f00';
    ctx.fillRectGreen(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.getcontext.unique
  desc: getContext('2d') returns the same object
  testing:
    - context.unique
  code: |
    @assert canvas.getContext('2d') === canvas.getContext('2d');

- name: 2d.getcontext.shared
  desc: getContext('2d') returns objects which share canvas state
  testing:
    - context.unique
  code: |
    var ctx2 = canvas.getContext('2d');
    ctx.fillStyle = '#f00';
    ctx2.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.voidreturn
  desc: void methods return undefined
  notes: *bindings
  images:
    - yellow.png
  code: |
    @assert ctx.save() === undefined;
    @assert ctx.restore() === undefined;
    @assert ctx.scale(1, 1) === undefined;
    @assert ctx.rotate(0) === undefined;
    @assert ctx.translate(0, 0) === undefined;
    if (ctx.transform) { // (avoid spurious failures, since the aim here is not to test that all features are supported)
        @assert ctx.transform(1, 0, 0, 1, 0, 0) === undefined;
    }
    if (ctx.setTransform) {
        @assert ctx.setTransform(1, 0, 0, 1, 0, 0) === undefined;
    }
    @assert ctx.clearRect(0, 0, 0, 0) === undefined;
    @assert ctx.fillRect(0, 0, 0, 0) === undefined;
    @assert ctx.strokeRect(0, 0, 0, 0) === undefined;
    @assert ctx.beginPath() === undefined;
    @assert ctx.closePath() === undefined;
    @assert ctx.moveTo(0, 0) === undefined;
    @assert ctx.lineTo(0, 0) === undefined;
    @assert ctx.quadraticCurveTo(0, 0, 0, 0) === undefined;
    @assert ctx.bezierCurveTo(0, 0, 0, 0, 0, 0) === undefined;
    @assert ctx.arcTo(0, 0, 0, 0, 1) === undefined;
    @assert ctx.rect(0, 0, 0, 0) === undefined;
    @assert ctx.arc(0, 0, 1, 0, 0, true) === undefined;
    @assert ctx.fill() === undefined;
    @assert ctx.stroke() === undefined;
    @assert ctx.clip() === undefined;
    if (ctx.fillText) {
        @assert ctx.fillText('test', 0, 0) === undefined;
        @assert ctx.strokeText('test', 0, 0) === undefined;
    }
    if (ctx.putImageData) {
        @assert ctx.putImageData(ctx.getImageData(0, 0, 1, 1), 0, 0) === undefined;
    }
    @assert ctx.drawImage(document.getElementById('yellow.png'), 0, 0, 1, 1, 0, 0, 0, 0) === undefined;
    @assert ctx.drawImage(canvas, 0, 0, 1, 1, 0, 0, 0, 0) === undefined;
    @assert ctx.createLinearGradient(0, 0, 0, 0).addColorStop(0, 'white') === undefined;

- name: 2d.missingargs
  desc: Missing arguments cause TypeError
  code: |
    @assert throws TypeError ctx.scale();
    @assert throws TypeError ctx.scale(1);
    @assert throws TypeError ctx.rotate();
    @assert throws TypeError ctx.translate();
    @assert throws TypeError ctx.translate(0);
    if (ctx.transform) { // (avoid spurious failures, since the aim here is not to test that all features are supported)
        @assert throws TypeError ctx.transform();
        @assert throws TypeError ctx.transform(1);
        @assert throws TypeError ctx.transform(1, 0);
        @assert throws TypeError ctx.transform(1, 0, 0);
        @assert throws TypeError ctx.transform(1, 0, 0, 1);
        @assert throws TypeError ctx.transform(1, 0, 0, 1, 0);
    }
    if (ctx.setTransform) {
        @assert throws TypeError ctx.setTransform();
        @assert throws TypeError ctx.setTransform(1);
        @assert throws TypeError ctx.setTransform(1, 0);
        @assert throws TypeError ctx.setTransform(1, 0, 0);
        @assert throws TypeError ctx.setTransform(1, 0, 0, 1);
        @assert throws TypeError ctx.setTransform(1, 0, 0, 1, 0);
    }
    @assert throws TypeError ctx.createLinearGradient();
    @assert throws TypeError ctx.createLinearGradient(0);
    @assert throws TypeError ctx.createLinearGradient(0, 0);
    @assert throws TypeError ctx.createLinearGradient(0, 0, 1);
    @assert throws TypeError ctx.createRadialGradient();
    @assert throws TypeError ctx.createRadialGradient(0);
    @assert throws TypeError ctx.createRadialGradient(0, 0);
    @assert throws TypeError ctx.createRadialGradient(0, 0, 1);
    @assert throws TypeError ctx.createRadialGradient(0, 0, 1, 0);
    @assert throws TypeError ctx.createRadialGradient(0, 0, 1, 0, 0);
    @assert throws TypeError ctx.createPattern(canvas);
    @assert throws TypeError ctx.clearRect();
    @assert throws TypeError ctx.clearRect(0);
    @assert throws TypeError ctx.clearRect(0, 0);
    @assert throws TypeError ctx.clearRect(0, 0, 0);
    @assert throws TypeError ctx.fillRect();
    @assert throws TypeError ctx.fillRect(0);
    @assert throws TypeError ctx.fillRect(0, 0);
    @assert throws TypeError ctx.fillRect(0, 0, 0);
    @assert throws TypeError ctx.strokeRect();
    @assert throws TypeError ctx.strokeRect(0);
    @assert throws TypeError ctx.strokeRect(0, 0);
    @assert throws TypeError ctx.strokeRect(0, 0, 0);
    @assert throws TypeError ctx.moveTo();
    @assert throws TypeError ctx.moveTo(0);
    @assert throws TypeError ctx.lineTo();
    @assert throws TypeError ctx.lineTo(0);
    @assert throws TypeError ctx.quadraticCurveTo();
    @assert throws TypeError ctx.quadraticCurveTo(0);
    @assert throws TypeError ctx.quadraticCurveTo(0, 0);
    @assert throws TypeError ctx.quadraticCurveTo(0, 0, 0);
    @assert throws TypeError ctx.bezierCurveTo();
    @assert throws TypeError ctx.bezierCurveTo(0);
    @assert throws TypeError ctx.bezierCurveTo(0, 0);
    @assert throws TypeError ctx.bezierCurveTo(0, 0, 0);
    @assert throws TypeError ctx.bezierCurveTo(0, 0, 0, 0);
    @assert throws TypeError ctx.bezierCurveTo(0, 0, 0, 0, 0);
    @assert throws TypeError ctx.arcTo();
    @assert throws TypeError ctx.arcTo(0);
    @assert throws TypeError ctx.arcTo(0, 0);
    @assert throws TypeError ctx.arcTo(0, 0, 0);
    @assert throws TypeError ctx.arcTo(0, 0, 0, 0);
    @assert throws TypeError ctx.rect();
    @assert throws TypeError ctx.rect(0);
    @assert throws TypeError ctx.rect(0, 0);
    @assert throws TypeError ctx.rect(0, 0, 0);
    @assert throws TypeError ctx.arc();
    @assert throws TypeError ctx.arc(0);
    @assert throws TypeError ctx.arc(0, 0);
    @assert throws TypeError ctx.arc(0, 0, 1);
    @assert throws TypeError ctx.arc(0, 0, 1, 0);
    // (6th argument to arc is optional)
    if (ctx.isPointInPath) {
        @assert throws TypeError ctx.isPointInPath();
        @assert throws TypeError ctx.isPointInPath(0);
    }
    if (ctx.drawFocusRing) {
        @assert throws TypeError ctx.drawFocusRing();
        @assert throws TypeError ctx.drawFocusRing(canvas);
        @assert throws TypeError ctx.drawFocusRing(canvas, 0);
    }
    if (ctx.fillText) {
        @assert throws TypeError ctx.fillText();
        @assert throws TypeError ctx.fillText('test');
        @assert throws TypeError ctx.fillText('test', 0);
        @assert throws TypeError ctx.strokeText();
        @assert throws TypeError ctx.strokeText('test');
        @assert throws TypeError ctx.strokeText('test', 0);
        @assert throws TypeError ctx.measureText();
    }
    @assert throws TypeError ctx.drawImage();
    @assert throws TypeError ctx.drawImage(canvas);
    @assert throws TypeError ctx.drawImage(canvas, 0);
    // TODO: n >= 3 args on drawImage could be either a valid overload,
    // or too few for another overload, or too many for another
    // overload - what should happen?
    if (ctx.createImageData) {
        @assert throws TypeError ctx.createImageData();
        @assert throws TypeError ctx.createImageData(1);
    }
    if (ctx.getImageData) {
        @assert throws TypeError ctx.getImageData();
        @assert throws TypeError ctx.getImageData(0);
        @assert throws TypeError ctx.getImageData(0, 0);
        @assert throws TypeError ctx.getImageData(0, 0, 1);
    }
    if (ctx.putImageData) {
        var imgdata = ctx.getImageData(0, 0, 1, 1);
        @assert throws TypeError ctx.putImageData();
        @assert throws TypeError ctx.putImageData(imgdata);
        @assert throws TypeError ctx.putImageData(imgdata, 0);
    }
    var g = ctx.createLinearGradient(0, 0, 0, 0);
    @assert throws TypeError g.addColorStop(); @moz-todo
    @assert throws TypeError g.addColorStop(0); @moz-todo

- name: 2d.coordinatespace
  desc: Coordinate space goes from top-left to bottom-right
  notes: This should not be upside down.
  manual: We can't tell that getPixelData isn't using the wrong coordinate space too.
  testing:
    - 2d.coordinatespace
  code: |
    ctx.fillStyle = '#00f';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#0ff';
    ctx.fillRect(0, 0, 50, 25);
    @assert pixel 25,12 == 0,255,255,255;
    @assert pixel 75,12 == 0,0,255,255;
    @assert pixel 25,37 == 0,0,255,255;
    @assert pixel 75,37 == 0,0,255,255;
  expected: |
    size 100 50
    cr.set_source_rgb(0, 0, 1)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    cr.set_source_rgb(0, 1, 1)
    cr.rectangle(0, 0, 50, 25)
    cr.fill()

- name: 2d.scaled
  desc: CSS-scaled canvases get drawn correctly
  canvas: 'width="50" height="25" style="width: 100px; height: 50px"'
  manual:
  code: |
    ctx.fillStyle = '#00f';
    ctx.fillRect(0, 0, 50, 25);
    ctx.fillStyle = '#0ff';
    ctx.fillRect(0, 0, 25, 10);
  expected: |
    size 100 50
    cr.set_source_rgb(0, 0, 1)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    cr.set_source_rgb(0, 1, 1)
    cr.rectangle(0, 0, 50, 20)
    cr.fill()

- name: 2d.canvas.reference
  desc: CanvasRenderingContext2D.canvas refers back to its canvas
  testing:
    - 2d.canvas
  code: |
    @assert ctx.canvas === canvas;

- name: 2d.canvas.readonly
  desc: CanvasRenderingContext2D.canvas is readonly
  testing:
    - 2d.canvas.attribute
  code: |
    var c = document.createElement('canvas');
    var d = ctx.canvas;
    @assert c !== d;
    ctx.canvas = c;
    @assert ctx.canvas === d;

- meta: |
    state = [ # some non-default values to test with
        ('strokeStyle', '"#ff0000"'),
        ('fillStyle', '"#ff0000"'),
        ('globalAlpha', 0.5),
        ('lineWidth', 0.5),
        ('lineCap', '"round"'),
        ('lineJoin', '"round"'),
        ('miterLimit', 0.5),
        ('shadowOffsetX', 5),
        ('shadowOffsetY', 5),
        ('shadowBlur', 5),
        ('shadowColor', '"#ff0000"'),
        ('globalCompositeOperation', '"copy"'),
        ('font', '"25px serif"'),
        ('textAlign', '"center"'),
        ('textBaseline', '"bottom"'),
    ]
    for key,value in state:
        tests.append( {
            'name': '2d.state.saverestore.%s' % key,
            'desc': 'save()/restore() works for %s' % key,
            'testing': [ '2d.state.%s' % key ],
            'code':
    """// Test that restore() undoes any modifications
    var old = ctx.%(key)s;
    ctx.save();
    ctx.%(key)s = %(value)s;
    ctx.restore();
    @assert ctx.%(key)s === old;

    // Also test that save() doesn't modify the values
    ctx.%(key)s = %(value)s;
    old = ctx.%(key)s;
        // we're not interested in failures caused by get(set(x)) != x (e.g.
        // from rounding), so compare against 'old' instead of against %(value)s
    ctx.save();
    @assert ctx.%(key)s === old;
    ctx.restore();
    """ % { 'key':key, 'value':value }
        } )

    tests.append( {
        'name': 'initial.reset.2dstate',
        'desc': 'Resetting the canvas state resets 2D state variables',
        'testing': [ 'initial.reset' ],
        'code':
    """canvas.width = 100;
    var default_val;
    """ + "".join(
    """
    default_val = ctx.%(key)s;
    ctx.%(key)s = %(value)s;
    canvas.width = 100;
    @assert ctx.%(key)s === default_val;
    """ % { 'key':key, 'value':value }
        for key,value in state),
    } )

- name: 2d.state.saverestore.transformation
  desc: save()/restore() affects the current transformation matrix
  testing:
    - 2d.state.transformation
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.save();
    ctx.translate(200, 0);
    ctx.restore();
    ctx.fillStyle = '#f00';
    ctx.fillRect(-200, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.state.saverestore.clip
  desc: save()/restore() affects the clipping path
  testing:
    - 2d.state.clip
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.save();
    ctx.rect(0, 0, 1, 1);
    ctx.clip();
    ctx.restore();
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.state.saverestore.path
  desc: save()/restore() does not affect the current path
  testing:
    - 2d.state.path
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.save();
    ctx.rect(0, 0, 100, 50);
    ctx.restore();
    ctx.fillStyle = '#0f0';
    ctx.fill();
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.state.saverestore.bitmap
  desc: save()/restore() does not affect the current bitmap
  testing:
    - 2d.state.bitmap
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.save();
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.restore();
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.state.saverestore.stack
  desc: save()/restore() can be nested as a stack
  testing:
    - 2d.state.save
    - 2d.state.restore
  code: |
    ctx.lineWidth = 1;
    ctx.save();
    ctx.lineWidth = 2;
    ctx.save();
    ctx.lineWidth = 3;
    @assert ctx.lineWidth === 3;
    ctx.restore();
    @assert ctx.lineWidth === 2;
    ctx.restore();
    @assert ctx.lineWidth === 1;

- name: 2d.state.saverestore.stackdepth
  desc: save()/restore() stack depth is not unreasonably limited
  testing:
    - 2d.state.save
    - 2d.state.restore
  code: |
    var limit = 512;
    for (var i = 1; i < limit; ++i)
    {
        ctx.save();
        ctx.lineWidth = i;
    }
    for (var i = limit-1; i > 0; --i)
    {
        @assert ctx.lineWidth === i;
        ctx.restore();
    }

- name: 2d.state.saverestore.underflow
  desc: restore() with an empty stack has no effect
  testing:
    - 2d.state.restore.underflow
  code: |
    for (var i = 0; i < 16; ++i)
        ctx.restore();
    ctx.lineWidth = 0.5;
    ctx.restore();
    @assert ctx.lineWidth === 0.5;


- name: 2d.transformation.order
  desc: Transformations are applied in the right order
  testing:
    - 2d.transformation.order
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.scale(2, 1);
    ctx.rotate(Math.PI / 2);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, -50, 50, 50);
    @assert pixel 75,25 == 0,255,0,255;
  expected: green


- name: 2d.transformation.scale.basic
  desc: scale() works
  testing:
    - 2d.transformation.scale
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.scale(2, 4);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 50, 12.5);
    @assert pixel 90,40 == 0,255,0,255;
  expected: green

- name: 2d.transformation.scale.zero
  desc: scale() with a scale factor of zero works
  testing:
    - 2d.transformation.scale
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.save();
    ctx.translate(50, 0);
    ctx.scale(0, 1);
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.restore();

    ctx.save();
    ctx.translate(0, 25);
    ctx.scale(1, 0);
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.restore();

    canvas.toDataURL();

    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.scale.negative
  desc: scale() with negative scale factors works
  testing:
    - 2d.transformation.scale
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.save();
    ctx.scale(-1, 1);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(-50, 0, 50, 50);
    ctx.restore();

    ctx.save();
    ctx.scale(1, -1);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(50, -50, 50, 50);
    ctx.restore();
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.scale.large
  desc: scale() with large scale factors works
  notes: Not really that large at all, but it hits the limits in Firefox.
  testing:
    - 2d.transformation.scale
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.scale(1e5, 1e5);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 1, 1);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.scale.nonfinite
  desc: scale() with Infinity/NaN is ignored
  testing:
    - 2d.nonfinite
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.translate(100, 10);
    @nonfinite ctx.scale(<0.1 Infinity -Infinity NaN>, <0.1 Infinity -Infinity NaN>);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -10, 100, 50);

    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.scale.multiple
  desc: Multiple scale()s combine
  testing:
    - 2d.transformation.scale.multiple
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.scale(Math.sqrt(2), Math.sqrt(2));
    ctx.scale(Math.sqrt(2), Math.sqrt(2));
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 50, 25);
    @assert pixel 90,40 == 0,255,0,255;
  expected: green


- name: 2d.transformation.rotate.zero
  desc: rotate() by 0 does nothing
  testing:
    - 2d.transformation.rotate
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.rotate(0);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.rotate.radians
  desc: rotate() uses radians
  testing:
    - 2d.transformation.rotate.radians
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.rotate(Math.PI); // should fail obviously if this is 3.1 degrees
    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -50, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.rotate.direction
  desc: rotate() is clockwise
  testing:
    - 2d.transformation.rotate.direction
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.rotate(Math.PI / 2);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, -100, 50, 100);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.rotate.wrap
  desc: rotate() wraps large positive values correctly
  testing:
    - 2d.transformation.rotate
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.rotate(Math.PI * (1 + 4096)); // == pi (mod 2*pi)
    // We need about pi +/- 0.001 in order to get correct-looking results
    // 32-bit floats can store pi*4097 with precision 2^-10, so that should
    // be safe enough on reasonable implementations
    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -50, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,2 == 0,255,0,255;
    @assert pixel 98,47 == 0,255,0,255;
  expected: green

- name: 2d.transformation.rotate.wrapnegative
  desc: rotate() wraps large negative values correctly
  testing:
    - 2d.transformation.rotate
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.rotate(-Math.PI * (1 + 4096));
    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -50, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,2 == 0,255,0,255;
    @assert pixel 98,47 == 0,255,0,255;
  expected: green

- name: 2d.transformation.rotate.nonfinite
  desc: rotate() with Infinity/NaN is ignored
  testing:
    - 2d.nonfinite
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.translate(100, 10);
    @nonfinite ctx.rotate(<0.1 Infinity -Infinity NaN>);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -10, 100, 50);

    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.translate.basic
  desc: translate() works
  testing:
    - 2d.transformation.translate
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.translate(100, 50);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -50, 100, 50);
    @assert pixel 90,40 == 0,255,0,255;
  expected: green

- name: 2d.transformation.translate.nonfinite
  desc: translate() with Infinity/NaN is ignored
  testing:
    - 2d.nonfinite
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.translate(100, 10);
    @nonfinite ctx.translate(<0.1 Infinity -Infinity NaN>, <0.1 Infinity -Infinity NaN>);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -10, 100, 50);

    @assert pixel 50,25 == 0,255,0,255;
  expected: green


- name: 2d.transformation.transform.identity
  desc: transform() with the identity matrix does nothing
  testing:
    - 2d.transformation.transform
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.transform(1,0, 0,1, 0,0);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.transform.skewed
  desc: transform() with skewy matrix transforms correctly
  testing:
    - 2d.transformation.transform
  code: |
    // Create green with a red square ring inside it
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#f00';
    ctx.fillRect(20, 10, 60, 30);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(40, 20, 20, 10);

    // Draw a skewed shape to fill that gap, to make sure it is aligned correctly
    ctx.transform(1,4, 2,3, 5,6);
    // Post-transform coordinates:
    //   [[20,10],[80,10],[80,40],[20,40],[20,10],[40,20],[40,30],[60,30],[60,20],[40,20],[20,10]];
    // Hence pre-transform coordinates:
    var pts=[[-7.4,11.2],[-43.4,59.2],[-31.4,53.2],[4.6,5.2],[-7.4,11.2],
             [-15.4,25.2],[-11.4,23.2],[-23.4,39.2],[-27.4,41.2],[-15.4,25.2],
             [-7.4,11.2]];
    ctx.beginPath();
    ctx.moveTo(pts[0][0], pts[0][1]);
    for (var i = 0; i < pts.length; ++i)
        ctx.lineTo(pts[i][0], pts[i][1]);
    ctx.fill();
    @assert pixel 21,11 == 0,255,0,255;
    @assert pixel 79,11 == 0,255,0,255;
    @assert pixel 21,39 == 0,255,0,255;
    @assert pixel 79,39 == 0,255,0,255;
    @assert pixel 39,19 == 0,255,0,255;
    @assert pixel 61,19 == 0,255,0,255;
    @assert pixel 39,31 == 0,255,0,255;
    @assert pixel 61,31 == 0,255,0,255;
  expected: green

- name: 2d.transformation.transform.multiply
  desc: transform() multiplies the CTM
  testing:
    - 2d.transformation.transform.multiply
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.transform(1,2, 3,4, 5,6);
    ctx.transform(-2,1, 3/2,-1/2, 1,-2);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.transformation.transform.nonfinite
  desc: transform() with Infinity/NaN is ignored
  testing:
    - 2d.nonfinite
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.translate(100, 10);
    @nonfinite ctx.transform(<0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -10, 100, 50);

    @assert pixel 50,25 == 0,255,0,255;
  expected: green


- name: 2d.transformation.setTransform.skewed
  testing:
    - 2d.transformation.setTransform
  code: |
    // Create green with a red square ring inside it
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#f00';
    ctx.fillRect(20, 10, 60, 30);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(40, 20, 20, 10);

    // Draw a skewed shape to fill that gap, to make sure it is aligned correctly
    ctx.setTransform(1,4, 2,3, 5,6);
    // Post-transform coordinates:
    //   [[20,10],[80,10],[80,40],[20,40],[20,10],[40,20],[40,30],[60,30],[60,20],[40,20],[20,10]];
    // Hence pre-transform coordinates:
    var pts=[[-7.4,11.2],[-43.4,59.2],[-31.4,53.2],[4.6,5.2],[-7.4,11.2],
             [-15.4,25.2],[-11.4,23.2],[-23.4,39.2],[-27.4,41.2],[-15.4,25.2],
             [-7.4,11.2]];
    ctx.beginPath();
    ctx.moveTo(pts[0][0], pts[0][1]);
    for (var i = 0; i < pts.length; ++i)
        ctx.lineTo(pts[i][0], pts[i][1]);
    ctx.fill();
    @assert pixel 21,11 == 0,255,0,255;
    @assert pixel 79,11 == 0,255,0,255;
    @assert pixel 21,39 == 0,255,0,255;
    @assert pixel 79,39 == 0,255,0,255;
    @assert pixel 39,19 == 0,255,0,255;
    @assert pixel 61,19 == 0,255,0,255;
    @assert pixel 39,31 == 0,255,0,255;
    @assert pixel 61,31 == 0,255,0,255;
  expected: green

- name: 2d.transformation.setTransform.multiple
  testing:
    - 2d.transformation.setTransform.identity
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.setTransform(1/2,0, 0,1/2, 0,0);
    ctx.setTransform(2,0, 0,2, 0,0);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 50, 25);
    @assert pixel 75,35 == 0,255,0,255;
  expected: green

- name: 2d.transformation.setTransform.nonfinite
  desc: setTransform() with Infinity/NaN is ignored
  testing:
    - 2d.nonfinite
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.translate(100, 10);
    @nonfinite ctx.setTransform(<0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(-100, -10, 100, 50);

    @assert pixel 50,25 == 0,255,0,255;
  expected: green


- name: 2d.composite.globalAlpha.range
  testing:
    - 2d.composite.globalAlpha.range
  code: |
    ctx.globalAlpha = 0.5;
    var a = ctx.globalAlpha; // might not be exactly 0.5, if it is rounded/quantised, so remember for future comparisons
    ctx.globalAlpha = 1.1;
    @assert ctx.globalAlpha === a;
    ctx.globalAlpha = -0.1;
    @assert ctx.globalAlpha === a;
    ctx.globalAlpha = 0;
    @assert ctx.globalAlpha === 0;
    ctx.globalAlpha = 1;
    @assert ctx.globalAlpha === 1;

- name: 2d.composite.globalAlpha.invalid
  testing:
    - 2d.composite.globalAlpha.range
  code: |
    ctx.globalAlpha = 0.5;
    var a = ctx.globalAlpha; // might not be exactly 0.5, if it is rounded/quantised, so remember for future comparisons
    ctx.globalAlpha = Infinity;
    @assert ctx.globalAlpha === a;
    ctx.globalAlpha = -Infinity;
    @assert ctx.globalAlpha === a;
    ctx.globalAlpha = NaN;
    @assert ctx.globalAlpha === a;

- name: 2d.composite.globalAlpha.default
  testing:
    - 2d.composite.globalAlpha.default
  code: |
    @assert ctx.globalAlpha === 1.0;

- name: 2d.composite.globalAlpha.fill
  testing:
    - 2d.composite.globalAlpha.shape
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalAlpha = 0.01; // avoid any potential alpha=0 optimisations
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ 2,253,0,255;
  expected: green

- name: 2d.composite.globalAlpha.image
  testing:
    - 2d.composite.globalAlpha.image
  images:
    - red.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalAlpha = 0.01; // avoid any potential alpha=0 optimisations
    ctx.drawImage(document.getElementById('red.png'), 0, 0);
    @assert pixel 50,25 ==~ 2,253,0,255;
  expected: green

- name: 2d.composite.globalAlpha.canvas
  testing:
    - 2d.composite.globalAlpha.image
  code: |
    var canvas2 = document.createElement('canvas');
    canvas2.width = 100;
    canvas2.height = 50;
    var ctx2 = canvas2.getContext('2d');
    ctx2.fillStyle = '#f00';
    ctx2.fillRect(0, 0, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalAlpha = 0.01; // avoid any potential alpha=0 optimisations
    ctx.drawImage(canvas2, 0, 0);
    @assert pixel 50,25 ==~ 2,253,0,255;
  expected: green

- name: 2d.composite.globalAlpha.imagepattern
  testing:
    - 2d.composite.globalAlpha.image
  images:
    - red.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = ctx.createPattern(document.getElementById('red.png'), 'no-repeat');
    ctx.globalAlpha = 0.01; // avoid any potential alpha=0 optimisations
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ 2,253,0,255;
  expected: green

- name: 2d.composite.globalAlpha.canvaspattern
  testing:
    - 2d.composite.globalAlpha.image
  code: |
    var canvas2 = document.createElement('canvas');
    canvas2.width = 100;
    canvas2.height = 50;
    var ctx2 = canvas2.getContext('2d');
    ctx2.fillStyle = '#f00';
    ctx2.fillRect(0, 0, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = ctx.createPattern(canvas2, 'no-repeat');
    ctx.globalAlpha = 0.01; // avoid any potential alpha=0 optimisations
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ 2,253,0,255;
  expected: green


- meta: |
    # Composite operation tests
    # <http://lists.whatwg.org/htdig.cgi/whatwg-whatwg.org/2007-March/010608.html>
    ops = [
        # name               FA      FB
        ('source-over',      '1',    '1-aA'),
        ('destination-over', '1-aB', '1'),
        ('source-in',        'aB',   '0'),
        ('destination-in',   '0',    'aA'),
        ('source-out',       '1-aB', '0'),
        ('destination-out',  '0',    '1-aA'),
        ('source-atop',      'aB',   '1-aA'),
        ('destination-atop', '1-aB', 'aA'),
        ('xor',              '1-aB', '1-aA'),
        ('copy',             '1',    '0'),
        ('lighter',          '1',    '1'),
    ]

    # The ones that change the output when src = (0,0,0,0):
    ops_trans = [ 'source-in', 'destination-in', 'source-out', 'destination-atop', 'copy' ];

    def calc_output((RA, GA, BA, aA), (RB, GB, BB, aB), FA_code, FB_code):
        rA, gA, bA = RA*aA, GA*aA, BA*aA
        rB, gB, bB = RB*aB, GB*aB, BB*aB

        FA = eval(FA_code)
        FB = eval(FB_code)

        rO = rA*FA + rB*FB
        gO = gA*FA + gB*FB
        bO = bA*FA + bB*FB
        aO = aA*FA + aB*FB

        rO = min(255, rO)
        gO = min(255, gO)
        bO = min(255, bO)
        aO = min(1, aO)

        if aO:
            RO = rO / aO
            GO = gO / aO
            BO = bO / aO
        else: RO = GO = BO = 0

        return (RO, GO, BO, aO)

    def to_test((r,g,b,a)):
        return '%d,%d,%d,%d' % (round(r), round(g), round(b), round(a*255))
    def to_cairo((r,g,b,a)):
        return '%f,%f,%f,%f' % (r/255., g/255., b/255., a)

    for (name, src, dest) in [
        ('solid', (255, 255, 0, 1.0), (0, 255, 255, 1.0)),
        ('transparent', (0, 0, 255, 0.75), (0, 255, 0, 0.5)),
            # catches the atop, xor and lighter bugs in Opera 9.10
    ]:
        for op, FA_code, FB_code in ops:
            expected = calc_output(src, dest, FA_code, FB_code)
            tests.append( {
                'name': '2d.composite.%s.%s' % (name, op),
                'testing': [ '2d.composite.%s' % op ],
                'code': """
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ %s +/- 5;
    """ % (dest, op, src, to_test(expected)),
                'expected': """size 100 50
    cr.set_source_rgba(%s)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % to_cairo(expected),
            } )

    for (name, src, dest) in [ ('image', (255, 255, 0, 0.75), (0, 255, 255, 0.5)) ]:
        for op, FA_code, FB_code in ops:
            expected = calc_output(src, dest, FA_code, FB_code)
            tests.append( {
                'name': '2d.composite.%s.%s' % (name, op),
                'testing': [ '2d.composite.%s' % op ],
                'images': [ 'yellow75.png' ],
                'code': """
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    ctx.drawImage(document.getElementById('yellow75.png'), 0, 0);
    @assert pixel 50,25 ==~ %s +/- 5;
    """ % (dest, op, to_test(expected)),
                'expected': """size 100 50
    cr.set_source_rgba(%s)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % to_cairo(expected),
            } )

    for (name, src, dest) in [ ('canvas', (255, 255, 0, 0.75), (0, 255, 255, 0.5)) ]:
        for op, FA_code, FB_code in ops:
            expected = calc_output(src, dest, FA_code, FB_code)
            tests.append( {
                'name': '2d.composite.%s.%s' % (name, op),
                'testing': [ '2d.composite.%s' % op ],
                'images': [ 'yellow75.png' ],
                'code': """
    var canvas2 = document.createElement('canvas');
    canvas2.width = canvas.width;
    canvas2.height = canvas.height;
    var ctx2 = canvas2.getContext('2d');
    ctx2.drawImage(document.getElementById('yellow75.png'), 0, 0);
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    ctx.drawImage(canvas2, 0, 0);
    @assert pixel 50,25 ==~ %s +/- 5;
    """ % (dest, op, to_test(expected)),
                'expected': """size 100 50
    cr.set_source_rgba(%s)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % to_cairo(expected),
            } )


    for (name, src, dest) in [ ('uncovered.fill', (0, 0, 255, 0.75), (0, 255, 0, 0.5)) ]:
        for op, FA_code, FB_code in ops:
            if op not in ops_trans: continue
            expected0 = calc_output((0,0,0,0.0), dest, FA_code, FB_code)
            tests.append( {
                'name': '2d.composite.%s.%s' % (name, op),
                'desc': 'fill() draws pixels not covered by the source object as (0,0,0,0), and does not leave the pixels unchanged.',
                'testing': [ '2d.composite.%s' % op ],
                'code': """
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    ctx.fillStyle = 'rgba%s';
    ctx.translate(0, 25);
    ctx.fillRect(0, 50, 100, 50);
    @assert pixel 50,25 ==~ %s +/- 5;
    """ % (dest, op, src, to_test(expected0)),
                'expected': """size 100 50
    cr.set_source_rgba(%s)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % (to_cairo(expected0)),
            } )

    for (name, src, dest) in [ ('uncovered.image', (255, 255, 0, 1.0), (0, 255, 255, 0.5)) ]:
        for op, FA_code, FB_code in ops:
            if op not in ops_trans: continue
            expected0 = calc_output((0,0,0,0.0), dest, FA_code, FB_code)
            tests.append( {
                'name': '2d.composite.%s.%s' % (name, op),
                'desc': 'drawImage() draws pixels not covered by the source object as (0,0,0,0), and does not leave the pixels unchanged.',
                'testing': [ '2d.composite.%s' % op ],
                'images': [ 'yellow.png' ],
                'code': """
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    ctx.drawImage(document.getElementById('yellow.png'), 40, 40, 10, 10, 40, 50, 10, 10);
    @assert pixel 15,15 ==~ %s +/- 5;
    @assert pixel 50,25 ==~ %s +/- 5;
    """ % (dest, op, to_test(expected0), to_test(expected0)),
                'expected': """size 100 50
    cr.set_source_rgba(%s)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % (to_cairo(expected0)),
            } )

    for (name, src, dest) in [ ('uncovered.nocontext', (255, 255, 0, 1.0), (0, 255, 255, 0.5)) ]:
        for op, FA_code, FB_code in ops:
            if op not in ops_trans: continue
            expected0 = calc_output((0,0,0,0.0), dest, FA_code, FB_code)
            tests.append( {
                'name': '2d.composite.%s.%s' % (name, op),
                'desc': 'drawImage() of a canvas with no context draws pixels as (0,0,0,0), and does not leave the pixels unchanged.',
                'testing': [ '2d.composite.%s' % op ],
                'code': """
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    var canvas2 = document.createElement('canvas');
    ctx.drawImage(canvas2, 0, 0);
    @assert pixel 50,25 ==~ %s +/- 5;
    """ % (dest, op, to_test(expected0)),
                'expected': """size 100 50
    cr.set_source_rgba(%s)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % (to_cairo(expected0)),
            } )

    for (name, src, dest) in [ ('uncovered.pattern', (255, 255, 0, 1.0), (0, 255, 255, 0.5)) ]:
        for op, FA_code, FB_code in ops:
            if op not in ops_trans: continue
            expected0 = calc_output((0,0,0,0.0), dest, FA_code, FB_code)
            tests.append( {
                'name': '2d.composite.%s.%s' % (name, op),
                'desc': 'Pattern fill() draws pixels not covered by the source object as (0,0,0,0), and does not leave the pixels unchanged.',
                'testing': [ '2d.composite.%s' % op ],
                'images': [ 'yellow.png' ],
                'code': """
    ctx.fillStyle = 'rgba%s';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    ctx.fillStyle = ctx.createPattern(document.getElementById('yellow.png'), 'no-repeat');
    ctx.fillRect(0, 50, 100, 50);
    @assert pixel 50,25 ==~ %s +/- 5;
    """ % (dest, op, to_test(expected0)),
                'expected': """size 100 50
    cr.set_source_rgba(%s)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % (to_cairo(expected0)),
            } )

    for op, FA_code, FB_code in ops:
        tests.append( {
            'name': '2d.composite.clip.%s' % (op),
            'desc': 'fill() does not affect pixels outside the clip region.',
            'testing': [ '2d.composite.%s' % op ],
            'code': """
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.globalCompositeOperation = '%s';
    ctx.rect(-20, -20, 10, 10);
    ctx.clip();
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 50, 50);
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
    """ % (op),
                'expected': 'green'
        } )

- name: 2d.composite.operation.get
  testing:
    - 2d.composite.operation
  code: |
    var modes = ['source-atop', 'source-in', 'source-out', 'source-over',
        'destination-atop', 'destination-in', 'destination-out', 'destination-over',
        'lighter', 'copy', 'xor'];
    for (var i = 0; i < modes.length; ++i)
    {
        ctx.globalCompositeOperation = modes[i];
        @assert ctx.globalCompositeOperation === modes[i];
    }

- name: 2d.composite.operation.unrecognised
  testing:
    - 2d.composite.operation.unrecognised
  code: |
    ctx.globalCompositeOperation = 'xor';
    ctx.globalCompositeOperation = 'nonexistent';
    @assert ctx.globalCompositeOperation === 'xor';

- name: 2d.composite.operation.darker
  testing:
    - 2d.composite.operation.unrecognised
  code: |
    ctx.globalCompositeOperation = 'xor';
    ctx.globalCompositeOperation = 'darker';
    @assert ctx.globalCompositeOperation === 'xor';

- name: 2d.composite.operation.over
  testing:
    - 2d.composite.operation.unrecognised
  code: |
    ctx.globalCompositeOperation = 'xor';
    ctx.globalCompositeOperation = 'over';
    @assert ctx.globalCompositeOperation === 'xor';

- name: 2d.composite.operation.clear
  testing:
    - 2d.composite.operation.unrecognised
  code: |
    ctx.globalCompositeOperation = 'xor';
    ctx.globalCompositeOperation = 'clear';
    @assert ctx.globalCompositeOperation === 'xor';

- name: 2d.composite.operation.highlight
  testing:
    - 2d.composite.operation.unrecognised
  code: |
    ctx.globalCompositeOperation = 'xor';
    ctx.globalCompositeOperation = 'highlight';
    @assert ctx.globalCompositeOperation === 'xor';

- name: 2d.composite.operation.nullsuffix
  testing:
    - 2d.composite.operation.exact
  code: |
    ctx.globalCompositeOperation = 'xor';
    ctx.globalCompositeOperation = 'source-over\0';
    @assert ctx.globalCompositeOperation === 'xor';

- name: 2d.composite.operation.casesensitive
  testing:
    - 2d.composite.operation.casesensitive
  code: |
    ctx.globalCompositeOperation = 'xor';
    ctx.globalCompositeOperation = 'Source-over';
    @assert ctx.globalCompositeOperation === 'xor';

- name: 2d.composite.operation.default
  testing:
    - 2d.composite.operation.default
  code: |
    @assert ctx.globalCompositeOperation === 'source-over';


- meta: |
    # Colour parsing tests

    # Try most of the CSS3 Color <color> values - http://www.w3.org/TR/css3-color/#colorunits
    big_float = '1' + ('0' * 39)
    big_double = '1' + ('0' * 310)
    for name, string, r,g,b,a, notes in [
        ('html4', 'limE', 0,255,0,255, ""),
        ('hex3', '#0f0', 0,255,0,255, ""),
        ('hex4', '#0f0f', 0,255,0,255, ""),
        ('hex6', '#00fF00', 0,255,0,255, ""),
        ('hex8', '#00ff00ff', 0,255,0,255, ""),
        ('rgb-num', 'rgb(0,255,0)', 0,255,0,255, ""),
        ('rgb-clamp-1', 'rgb(-1000, 1000, -1000)', 0,255,0,255, 'Assumes colours are clamped to [0,255].'),
        ('rgb-clamp-2', 'rgb(-200%, 200%, -200%)', 0,255,0,255, 'Assumes colours are clamped to [0,255].'),
        ('rgb-clamp-3', 'rgb(-2147483649, 4294967298, -18446744073709551619)', 0,255,0,255, 'Assumes colours are clamped to [0,255].'),
        ('rgb-clamp-4', 'rgb(-'+big_float+', '+big_float+', -'+big_float+')', 0,255,0,255, 'Assumes colours are clamped to [0,255].'),
        ('rgb-clamp-5', 'rgb(-'+big_double+', '+big_double+', -'+big_double+')', 0,255,0,255, 'Assumes colours are clamped to [0,255].'),
        ('rgb-percent', 'rgb(0% ,100% ,0%)', 0,255,0,255, 'CSS3 Color says "The integer value 255 corresponds to 100%". (In particular, it is not 254...)'),
        ('rgb-eof', 'rgb(0, 255, 0', 0,255,0,255, ""), # see CSS2.1 4.2 "Unexpected end of style sheet"
        ('rgba-solid-1', 'rgba(  0  ,  255  ,  0  ,  1  )', 0,255,0,255, ""),
        ('rgba-solid-2', 'rgba(  0  ,  255  ,  0  ,  1.0  )', 0,255,0,255, ""),
        ('rgba-solid-3', 'rgba(  0  ,  255  ,  0  , +1  )', 0,255,0,255, ""),
        ('rgba-solid-4', 'rgba( -0  ,  255  , +0  ,  1  )', 0,255,0,255, ""),
        ('rgba-num-1', 'rgba(  0  ,  255  ,  0  ,  .499  )', 0,255,0,127, ""),
        ('rgba-num-2', 'rgba(  0  ,  255  ,  0  ,  0.499  )', 0,255,0,127, ""),
        ('rgba-percent', 'rgba(0%,100%,0%,0.499)', 0,255,0,127, ""), # 0.499*255 rounds to 127, both down and nearest, so it should be safe
        ('rgba-clamp-1', 'rgba(0, 255, 0, -2)', 0,0,0,0, ""),
        ('rgba-clamp-2', 'rgba(0, 255, 0, 2)', 0,255,0,255, ""),
        ('rgba-eof', 'rgba(0, 255, 0, 1', 0,255,0,255, ""),
        ('transparent-1', 'transparent', 0,0,0,0, ""),
        ('transparent-2', 'TrAnSpArEnT', 0,0,0,0, ""),
        ('hsl-1', 'hsl(120, 100%, 50%)', 0,255,0,255, ""),
        ('hsl-2', 'hsl( -240 , 100% , 50% )', 0,255,0,255, ""),
        ('hsl-3', 'hsl(360120, 100%, 50%)', 0,255,0,255, ""),
        ('hsl-4', 'hsl(-360240, 100%, 50%)', 0,255,0,255, ""),
        ('hsl-5', 'hsl(120.0, 100.0%, 50.0%)', 0,255,0,255, ""),
        ('hsl-6', 'hsl(+120, +100%, +50%)', 0,255,0,255, ""),
        ('hsl-clamp-1', 'hsl(120, 200%, 50%)', 0,255,0,255, ""),
        ('hsl-clamp-2', 'hsl(120, -200%, 49.9%)', 127,127,127,255, ""),
        ('hsl-clamp-3', 'hsl(120, 100%, 200%)', 255,255,255,255, ""),
        ('hsl-clamp-4', 'hsl(120, 100%, -200%)', 0,0,0,255, ""),
        ('hsla-1', 'hsla(120, 100%, 50%, 0.499)', 0,255,0,127, ""),
        ('hsla-2', 'hsla( 120.0 , 100.0% , 50.0% , 1 )', 0,255,0,255, ""),
        ('hsla-clamp-1', 'hsla(120, 200%, 50%, 1)', 0,255,0,255, ""),
        ('hsla-clamp-2', 'hsla(120, -200%, 49.9%, 1)', 127,127,127,255, ""),
        ('hsla-clamp-3', 'hsla(120, 100%, 200%, 1)', 255,255,255,255, ""),
        ('hsla-clamp-4', 'hsla(120, 100%, -200%, 1)', 0,0,0,255, ""),
        ('hsla-clamp-5', 'hsla(120, 100%, 50%, 2)', 0,255,0,255, ""),
        ('hsla-clamp-6', 'hsla(120, 100%, 0%, -2)', 0,0,0,0, ""),
        ('svg-1', 'gray', 128,128,128,255, ""),
        ('svg-2', 'grey', 128,128,128,255, ""),
        # currentColor is handled later
    ]:
        # TODO: test by retrieving fillStyle, instead of actually drawing?
        # TODO: test strokeStyle, shadowColor in the same way
        test = {
            'name': '2d.fillStyle.parse.%s' % name,
            'testing': [ '2d.colours.parse' ],
            'notes': notes,
            'code': """
    ctx.fillStyle = '#f00';
    ctx.fillStyle = '%s';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == %d,%d,%d,%d;
    """ % (string, r,g,b,a),
            'expected': """size 100 50
    cr.set_source_rgba(%f, %f, %f, %f)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()
    """ % (r/255., g/255., b/255., a/255.),
        }
        tests.append(test)

    # Also test that invalid colours are ignored
    for name, string in [
        ('hex1', '#f'),
        ('hex2', '#f0'),
        ('hex3', '#g00'),
        ('hex4', '#fg00'),
        ('hex5', '#ff000'),
        ('hex6', '#fg0000'),
        ('hex7', '#ff0000f'),
        ('hex8', '#fg0000ff'),
        ('rgb-1', 'rgb(255.0, 0, 0)'),
        ('rgb-2', 'rgb(255, 0.0, 0)'),
        ('rgb-3', 'rgb(255.0, 0, 0,)'),
        ('rgb-4', 'rgb(100%, 0, 0)'),
        ('rgb-5', 'rgb(255 0 0)'),
        ('rgb-6', 'rgb(255, - 1, 0)'),
        ('rgb-7', 'rgb(255, 0, 0, 1)'),
        ('rgba-1', 'rgba(255, 0, 0)'),
        ('rgba-2', 'rgba(255.0, 0, 0, 1)'),
        ('rgba-3', 'rgba(100%, 0, 0, 1)'),
        ('rgba-4', 'rgba(255, 0, 0, 100%)'),
        ('rgba-5', 'rgba(255, 0, 0, 1. 0)'),
        ('rgba-6', 'rgba(255, 0, 0, 1.)'),
        ('rgba-7', 'rgba(255, 0, 0, '),
        ('hsl-1', 'hsl(0%, 100%, 50%)'),
        ('hsl-2', 'hsl(z, 100%, 50%)'),
        ('hsl-3', 'hsl(0, 0, 50%)'),
        ('hsl-4', 'hsl(0, 100%, 0)'),
        ('hsl-5', 'hsl(0, 100%, 100%, 1)'),
        ('hsl-6', 'hsl(0, 100.%, 50%)'),
        ('hsla-1', 'hsla(0%, 100%, 50%, 1)'),
        ('hsla-2', 'hsla(0, 0, 50%, 1)'),
        ('name-1', 'darkbrown'),
        ('name-2', 'firebrick1'),
        ('name-3', 'red blue'),
        ('name-4', '"red"'),
        ('name-5', '"red'),
    ]:
        test = {
            'name': '2d.fillStyle.parse.invalid.%s' % name,
            'testing': [ '2d.colours.parse' ],
            'code': """
    ctx.fillStyle = '#0f0';
    try { ctx.fillStyle = '%s'; } catch (e) { } // this shouldn't throw, but it shouldn't matter here if it does
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
    """ % string,
            'expected': 'green'
        }
        tests.append(test)

    # Some can't have positive tests, only negative tests, because we don't know what colour they're meant to be
    for name, string in [
        ('system', 'ThreeDDarkShadow'),
        #('flavor', 'flavor'), # removed from latest CSS3 Color drafts
    ]:
        test = {
            'name': '2d.fillStyle.parse.%s' % name,
            'testing': [ '2d.colours.parse' ],
            'code': """
    ctx.fillStyle = '#f00';
    ctx.fillStyle = '%s';
    @assert ctx.fillStyle =~ /^#(?!(FF0000|ff0000|f00)$)/; // test that it's not red
    """ % (string,),
        }
        tests.append(test)

- name: 2d.fillStyle.parse.current.basic
  desc: currentColor is computed from the canvas element
  testing:
    - 2d.colours.parse
    - 2d.currentColor.onset
  code: |
    canvas.setAttribute('style', 'color: #0f0');
    ctx.fillStyle = '#f00';
    ctx.fillStyle = 'currentColor';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.fillStyle.parse.current.changed
  desc: currentColor is computed when the attribute is set, not when it is painted
  testing:
    - 2d.colours.parse
    - 2d.currentColor.onset
  code: |
    canvas.setAttribute('style', 'color: #0f0');
    ctx.fillStyle = '#f00';
    ctx.fillStyle = 'currentColor';
    canvas.setAttribute('style', 'color: #f00');
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.fillStyle.parse.current.removed
  desc: currentColor is solid black when the canvas element is not in a document
  testing:
    - 2d.colours.parse
    - 2d.currentColor.outofdoc
  code: |
    // Try not to let it undetectably incorrectly pick up opaque-black
    // from other parts of the document:
    document.body.parentNode.setAttribute('style', 'color: #f00');
    document.body.setAttribute('style', 'color: #f00');
    canvas.setAttribute('style', 'color: #f00');

    var canvas2 = document.createElement('canvas');
    var ctx2 = canvas2.getContext('2d');
    ctx2.fillStyle = '#f00';
    ctx2.fillStyle = 'currentColor';
    ctx2.fillRect(0, 0, 100, 50);
    ctx.drawImage(canvas2, 0, 0);

    document.body.parentNode.removeAttribute('style');
    document.body.removeAttribute('style');

    @assert pixel 50,25 == 0,0,0,255;
  expected: |
    size 100 50
    cr.set_source_rgb(0, 0, 0)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()

- name: 2d.fillStyle.invalidstring
  testing:
    - 2d.colours.invalidstring
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#0f0';
    ctx.fillStyle = 'invalid';
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.fillStyle.invalidtype
  testing:
    - 2d.colours.invalidtype
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#0f0';
    ctx.fillStyle = null;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.fillStyle.get.solid
  testing:
    - 2d.colours.getcolour
    - 2d.serializecolour.solid
  code: |
    ctx.fillStyle = '#fa0';
    @assert ctx.fillStyle === '#ffaa00';

- name: 2d.fillStyle.get.semitransparent
  testing:
    - 2d.colours.getcolour
    - 2d.serializecolour.transparent
  code: |
    ctx.fillStyle = 'rgba(255,255,255,0.45)';
    @assert ctx.fillStyle =~ /^rgba\(255, 255, 255, 0\.4\d+\)$/;

- name: 2d.fillStyle.get.transparent
  testing:
    - 2d.colours.getcolour
    - 2d.serializecolour.transparent
  code: |
    ctx.fillStyle = 'rgba(0,0,0,0)';
    @assert ctx.fillStyle === 'rgba(0, 0, 0, 0)';

- name: 2d.fillStyle.default
  testing:
    - 2d.colours.default
  code: |
    @assert ctx.fillStyle === '#000000';

- name: 2d.strokeStyle.default
  testing:
    - 2d.colours.default
  code: |
    @assert ctx.strokeStyle === '#000000';


- name: 2d.gradient.object.type
  desc: window.CanvasGradient exists and has the right properties
  testing:
    - 2d.canvasGradient.type
  notes: *bindings
  code: |
    @assert window.CanvasGradient !== undefined;
    @assert window.CanvasGradient.prototype.addColorStop !== undefined;

- name: 2d.gradient.object.return
  desc: createLinearGradient() and createRadialGradient() returns objects implementing CanvasGradient
  testing:
    - 2d.gradient.linear.return
    - 2d.gradient.radial.return
  code: |
    window.CanvasGradient.prototype.thisImplementsCanvasGradient = true;

    var g1 = ctx.createLinearGradient(0, 0, 100, 0);
    @assert g1.addColorStop !== undefined;
    @assert g1.thisImplementsCanvasGradient === true;

    var g2 = ctx.createRadialGradient(0, 0, 10, 0, 0, 20);
    @assert g2.addColorStop !== undefined;
    @assert g2.thisImplementsCanvasGradient === true;

- name: 2d.gradient.interpolate.solid
  testing:
    - 2d.gradient.interpolate.linear
  code: |
    var g = ctx.createLinearGradient(0, 0, 100, 0);
    g.addColorStop(0, '#0f0');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.gradient.interpolate.colour
  testing:
    - 2d.gradient.interpolate.linear
  code: |
    var g = ctx.createLinearGradient(0, 0, 100, 0);
    g.addColorStop(0, '#ff0');
    g.addColorStop(1, '#00f');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 25,25 ==~ 191,191,63,255 +/- 3;
    @assert pixel 50,25 ==~ 127,127,127,255 +/- 3;
    @assert pixel 75,25 ==~ 63,63,191,255 +/- 3;
  expected: |
    size 100 50
    g = cairo.LinearGradient(0, 0, 100, 0)
    g.add_color_stop_rgb(0, 1,1,0)
    g.add_color_stop_rgb(1, 0,0,1)
    cr.set_source(g)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()

- name: 2d.gradient.interpolate.alpha
  testing:
    - 2d.gradient.interpolate.linear
  code: |
    ctx.fillStyle = '#ff0';
    ctx.fillRect(0, 0, 100, 50);
    var g = ctx.createLinearGradient(0, 0, 100, 0);
    g.addColorStop(0, 'rgba(0,0,255, 0)');
    g.addColorStop(1, 'rgba(0,0,255, 1)');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 25,25 ==~ 191,191,63,255 +/- 3;
    @assert pixel 50,25 ==~ 127,127,127,255 +/- 3;
    @assert pixel 75,25 ==~ 63,63,191,255 +/- 3;
  expected: |
    size 100 50
    g = cairo.LinearGradient(0, 0, 100, 0)
    g.add_color_stop_rgb(0, 1,1,0)
    g.add_color_stop_rgb(1, 0,0,1)
    cr.set_source(g)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()

- name: 2d.gradient.interpolate.colouralpha
  testing:
    - 2d.gradient.interpolate.alpha
  code: |
    var g = ctx.createLinearGradient(0, 0, 100, 0);
    g.addColorStop(0, 'rgba(255,255,0, 0)');
    g.addColorStop(1, 'rgba(0,0,255, 1)');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 25,25 ==~ 191,191,63,63 +/- 3;
    @assert pixel 50,25 ==~ 127,127,127,127 +/- 3;
    @assert pixel 75,25 ==~ 63,63,191,191 +/- 3;
  expected: |
    size 100 50
    g = cairo.LinearGradient(0, 0, 100, 0)
    g.add_color_stop_rgba(0, 1,1,0, 0)
    g.add_color_stop_rgba(1, 0,0,1, 1)
    cr.set_source(g)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()

- name: 2d.gradient.interpolate.outside
  testing:
    - 2d.gradient.outside.first
    - 2d.gradient.outside.last
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(25, 0, 75, 0);
    g.addColorStop(0.4, '#0f0');
    g.addColorStop(0.6, '#0f0');

    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 20,25 ==~ 0,255,0,255;
    @assert pixel 50,25 ==~ 0,255,0,255;
    @assert pixel 80,25 ==~ 0,255,0,255;
  expected: green

- name: 2d.gradient.interpolate.zerosize.fill
  testing:
    - 2d.gradient.linear.zerosize
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(50, 25, 50, 25); // zero-length line (undefined direction)
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.rect(0, 0, 100, 50);
    ctx.fill();
    @assert pixel 40,20 == 0,255,0,255;
  expected: green

- name: 2d.gradient.interpolate.zerosize.stroke
  testing:
    - 2d.gradient.linear.zerosize
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(50, 25, 50, 25); // zero-length line (undefined direction)
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.strokeStyle = g;
    ctx.rect(20, 20, 60, 10);
    ctx.stroke();
    @assert pixel 19,19 == 0,255,0,255;
    @assert pixel 20,19 == 0,255,0,255;
    @assert pixel 21,19 == 0,255,0,255;
    @assert pixel 19,20 == 0,255,0,255;
    @assert pixel 20,20 == 0,255,0,255;
    @assert pixel 21,20 == 0,255,0,255;
    @assert pixel 19,21 == 0,255,0,255;
    @assert pixel 20,21 == 0,255,0,255;
    @assert pixel 21,21 == 0,255,0,255;
  expected: green

- name: 2d.gradient.interpolate.zerosize.fillRect
  testing:
    - 2d.gradient.linear.zerosize
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(50, 25, 50, 25); // zero-length line (undefined direction)
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 40,20 == 0,255,0,255; @moz-todo
  expected: green

- name: 2d.gradient.interpolate.zerosize.strokeRect
  testing:
    - 2d.gradient.linear.zerosize
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(50, 25, 50, 25); // zero-length line (undefined direction)
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.strokeStyle = g;
    ctx.strokeRect(20, 20, 60, 10);
    @assert pixel 19,19 == 0,255,0,255;
    @assert pixel 20,19 == 0,255,0,255;
    @assert pixel 21,19 == 0,255,0,255;
    @assert pixel 19,20 == 0,255,0,255;
    @assert pixel 20,20 == 0,255,0,255;
    @assert pixel 21,20 == 0,255,0,255;
    @assert pixel 19,21 == 0,255,0,255;
    @assert pixel 20,21 == 0,255,0,255;
    @assert pixel 21,21 == 0,255,0,255;
  expected: green

- name: 2d.gradient.interpolate.zerosize.fillText
  testing:
    - 2d.gradient.linear.zerosize
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(50, 25, 50, 25); // zero-length line (undefined direction)
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.font = '100px sans-serif';
    ctx.fillText("AA", 0, 50);
    _assertGreen(ctx, 100, 50);
  expected: green

- name: 2d.gradient.interpolate.zerosize.strokeText
  testing:
    - 2d.gradient.linear.zerosize
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(50, 25, 50, 25); // zero-length line (undefined direction)
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.strokeStyle = g;
    ctx.font = '100px sans-serif';
    ctx.strokeText("AA", 0, 50);
    _assertGreen(ctx, 100, 50);
  expected: green


- name: 2d.gradient.interpolate.vertical
  testing:
    - 2d.gradient.interpolate.linear
  code: |
    var g = ctx.createLinearGradient(0, 0, 0, 50);
    g.addColorStop(0, '#ff0');
    g.addColorStop(1, '#00f');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,12 ==~ 191,191,63,255 +/- 10;
    @assert pixel 50,25 ==~ 127,127,127,255 +/- 5;
    @assert pixel 50,37 ==~ 63,63,191,255 +/- 10;
  expected: |
    size 100 50
    g = cairo.LinearGradient(0, 0, 0, 50)
    g.add_color_stop_rgb(0, 1,1,0)
    g.add_color_stop_rgb(1, 0,0,1)
    cr.set_source(g)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()

- name: 2d.gradient.interpolate.multiple
  testing:
    - 2d.gradient.interpolate.linear
  code: |
    canvas.width = 200;
    var g = ctx.createLinearGradient(0, 0, 200, 0);
    g.addColorStop(0, '#ff0');
    g.addColorStop(0.5, '#0ff');
    g.addColorStop(1, '#f0f');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 200, 50);
    @assert pixel 50,25 ==~ 127,255,127,255 +/- 3;
    @assert pixel 100,25 ==~ 0,255,255,255 +/- 3;
    @assert pixel 150,25 ==~ 127,127,255,255 +/- 3;
  expected: |
    size 200 50
    g = cairo.LinearGradient(0, 0, 200, 0)
    g.add_color_stop_rgb(0.0, 1,1,0)
    g.add_color_stop_rgb(0.5, 0,1,1)
    g.add_color_stop_rgb(1.0, 1,0,1)
    cr.set_source(g)
    cr.rectangle(0, 0, 200, 50)
    cr.fill()

- name: 2d.gradient.interpolate.overlap
  testing:
    - 2d.gradient.interpolate.overlap
  code: |
    canvas.width = 200;
    var g = ctx.createLinearGradient(0, 0, 200, 0);
    g.addColorStop(0, '#f00');
    g.addColorStop(0, '#ff0');
    g.addColorStop(0.25, '#00f');
    g.addColorStop(0.25, '#0f0');
    g.addColorStop(0.25, '#0f0');
    g.addColorStop(0.25, '#0f0');
    g.addColorStop(0.25, '#ff0');
    g.addColorStop(0.5, '#00f');
    g.addColorStop(0.5, '#0f0');
    g.addColorStop(0.75, '#00f');
    g.addColorStop(0.75, '#f00');
    g.addColorStop(0.75, '#ff0');
    g.addColorStop(0.5, '#0f0');
    g.addColorStop(0.5, '#0f0');
    g.addColorStop(0.5, '#ff0');
    g.addColorStop(1, '#00f');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 200, 50);
    @assert pixel 49,25 ==~ 0,0,255,255 +/- 16;
    @assert pixel 51,25 ==~ 255,255,0,255 +/- 16;
    @assert pixel 99,25 ==~ 0,0,255,255 +/- 16;
    @assert pixel 101,25 ==~ 255,255,0,255 +/- 16;
    @assert pixel 149,25 ==~ 0,0,255,255 +/- 16;
    @assert pixel 151,25 ==~ 255,255,0,255 +/- 16;
  expected: |
    size 200 50
    g = cairo.LinearGradient(0, 0, 50, 0)
    g.add_color_stop_rgb(0, 1,1,0)
    g.add_color_stop_rgb(1, 0,0,1)
    cr.set_source(g)
    cr.rectangle(0, 0, 50, 50)
    cr.fill()

    g = cairo.LinearGradient(50, 0, 100, 0)
    g.add_color_stop_rgb(0, 1,1,0)
    g.add_color_stop_rgb(1, 0,0,1)
    cr.set_source(g)
    cr.rectangle(50, 0, 50, 50)
    cr.fill()

    g = cairo.LinearGradient(100, 0, 150, 0)
    g.add_color_stop_rgb(0, 1,1,0)
    g.add_color_stop_rgb(1, 0,0,1)
    cr.set_source(g)
    cr.rectangle(100, 0, 50, 50)
    cr.fill()

    g = cairo.LinearGradient(150, 0, 200, 0)
    g.add_color_stop_rgb(0, 1,1,0)
    g.add_color_stop_rgb(1, 0,0,1)
    cr.set_source(g)
    cr.rectangle(150, 0, 50, 50)
    cr.fill()

- name: 2d.gradient.interpolate.overlap2
  testing:
    - 2d.gradient.interpolate.overlap
  code: |
    var g = ctx.createLinearGradient(0, 0, 100, 0);
    var ps = [ 0, 1/10, 1/4, 1/3, 1/2, 3/4, 1 ];
    for (var p = 0; p < ps.length; ++p)
    {
            g.addColorStop(ps[p], '#0f0');
            for (var i = 0; i < 15; ++i)
                    g.addColorStop(ps[p], '#f00');
            g.addColorStop(ps[p], '#0f0');
    }
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 30,25 == 0,255,0,255;
    @assert pixel 40,25 == 0,255,0,255;
    @assert pixel 60,25 == 0,255,0,255;
    @assert pixel 80,25 == 0,255,0,255;
  expected: green

- name: 2d.gradient.empty
  testing:
    - 2d.gradient.empty
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    var g = ctx.createLinearGradient(0, 0, 0, 50);
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ 0,255,0,255;
  expected: green

- name: 2d.gradient.object.update
  testing:
    - 2d.gradient.update
  code: |
    var g = ctx.createLinearGradient(-100, 0, 200, 0);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    g.addColorStop(0.1, '#0f0');
    g.addColorStop(0.9, '#0f0');
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ 0,255,0,255;
  expected: green

- name: 2d.gradient.object.compare
  testing:
    - 2d.gradient.object
  code: |
    var g1 = ctx.createLinearGradient(0, 0, 100, 0);
    var g2 = ctx.createLinearGradient(0, 0, 100, 0);
    @assert g1 !== g2;
    ctx.fillStyle = g1;
    @assert ctx.fillStyle === g1;

- name: 2d.gradient.object.crosscanvas
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    var g = document.createElement('canvas').getContext('2d').createLinearGradient(0, 0, 100, 0);
    g.addColorStop(0, '#0f0');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ 0,255,0,255;
  expected: green

- name: 2d.gradient.object.current
  testing:
    - 2d.currentColor.gradient
  code: |
    canvas.setAttribute('style', 'color: #f00');

    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createLinearGradient(0, 0, 100, 0);
    g.addColorStop(0, 'currentColor');
    g.addColorStop(1, 'currentColor');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    @assert pixel 50,25 ==~ 0,0,0,255;
  expected: |
    size 100 50
    cr.set_source_rgb(0, 0, 0)
    cr.rectangle(0, 0, 100, 50)
    cr.fill()

- name: 2d.gradient.object.invalidoffset
  testing:
    - 2d.gradient.invalidoffset
  code: |
    var g = ctx.createLinearGradient(0, 0, 100, 0);
    @assert throws INDEX_SIZE_ERR g.addColorStop(-1, '#000');
    @assert throws INDEX_SIZE_ERR g.addColorStop(2, '#000');
    @assert throws TypeError g.addColorStop(Infinity, '#000');
    @assert throws TypeError g.addColorStop(-Infinity, '#000');
    @assert throws TypeError g.addColorStop(NaN, '#000');

- name: 2d.gradient.object.invalidcolour
  testing:
    - 2d.gradient.invalidcolour
  code: |
    var g = ctx.createLinearGradient(0, 0, 100, 0);
    @assert throws SYNTAX_ERR g.addColorStop(0, "");
    @assert throws SYNTAX_ERR g.addColorStop(0, 'null');
    @assert throws SYNTAX_ERR g.addColorStop(0, 'undefined');
    @assert throws SYNTAX_ERR g.addColorStop(0, null);
    @assert throws SYNTAX_ERR g.addColorStop(0, undefined);


- name: 2d.gradient.linear.nonfinite
  desc: createLinearGradient() throws TypeError if arguments are not finite
  notes: *bindings
  testing:
    - 2d.gradient.linear.nonfinite
  code: |
    @nonfinite @assert throws TypeError ctx.createLinearGradient(<0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <1 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>);

- name: 2d.gradient.linear.transform.1
  desc: Linear gradient coordinates are relative to the coordinate space at the time of filling
  testing:
    - 2d.gradient.linear.transform
  code: |
    var g = ctx.createLinearGradient(0, 0, 200, 0);
    g.addColorStop(0, '#f00');
    g.addColorStop(0.25, '#0f0');
    g.addColorStop(0.75, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.translate(-50, 0);
    ctx.fillRect(50, 0, 100, 50);
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
  expected: green

- name: 2d.gradient.linear.transform.2
  desc: Linear gradient coordinates are relative to the coordinate space at the time of filling
  testing:
    - 2d.gradient.linear.transform
  code: |
    ctx.translate(100, 0);
    var g = ctx.createLinearGradient(0, 0, 200, 0);
    g.addColorStop(0, '#f00');
    g.addColorStop(0.25, '#0f0');
    g.addColorStop(0.75, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.translate(-150, 0);
    ctx.fillRect(50, 0, 100, 50);
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
  expected: green

- name: 2d.gradient.linear.transform.3
  desc: Linear gradient transforms do not experience broken caching effects
  testing:
    - 2d.gradient.linear.transform
  code: |
    var g = ctx.createLinearGradient(0, 0, 200, 0);
    g.addColorStop(0, '#f00');
    g.addColorStop(0.25, '#0f0');
    g.addColorStop(0.75, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    ctx.translate(-50, 0);
    ctx.fillRect(50, 0, 100, 50);
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.negative
  desc: createRadialGradient() throws INDEX_SIZE_ERR if either radius is negative
  testing:
    - 2d.gradient.radial.negative
  code: |
    @assert throws INDEX_SIZE_ERR ctx.createRadialGradient(0, 0, -0.1, 0, 0, 1);
    @assert throws INDEX_SIZE_ERR ctx.createRadialGradient(0, 0, 1, 0, 0, -0.1);
    @assert throws INDEX_SIZE_ERR ctx.createRadialGradient(0, 0, -0.1, 0, 0, -0.1);

- name: 2d.gradient.radial.nonfinite
  desc: createRadialGradient() throws TypeError if arguments are not finite
  notes: *bindings
  testing:
    - 2d.gradient.radial.nonfinite
  code: |
    @nonfinite @assert throws TypeError ctx.createRadialGradient(<0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <1 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <0 Infinity -Infinity NaN>, <1 Infinity -Infinity NaN>);

- name: 2d.gradient.radial.inside1
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(50, 25, 100, 50, 25, 200);
    g.addColorStop(0, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.inside2
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(50, 25, 200, 50, 25, 100);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.inside3
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(50, 25, 200, 50, 25, 100);
    g.addColorStop(0, '#f00');
    g.addColorStop(0.993, '#f00');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.outside1
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(200, 25, 10, 200, 25, 20);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.outside2
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(200, 25, 20, 200, 25, 10);
    g.addColorStop(0, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.outside3
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(200, 25, 20, 200, 25, 10);
    g.addColorStop(0, '#0f0');
    g.addColorStop(0.001, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.touch1
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(150, 25, 50, 200, 25, 100);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255; @moz-todo
    @assert pixel 50,1 == 0,255,0,255; @moz-todo
    @assert pixel 98,1 == 0,255,0,255; @moz-todo
    @assert pixel 1,25 == 0,255,0,255; @moz-todo
    @assert pixel 50,25 == 0,255,0,255; @moz-todo
    @assert pixel 98,25 == 0,255,0,255; @moz-todo
    @assert pixel 1,48 == 0,255,0,255; @moz-todo
    @assert pixel 50,48 == 0,255,0,255; @moz-todo
    @assert pixel 98,48 == 0,255,0,255; @moz-todo
  expected: green

- name: 2d.gradient.radial.touch2
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(-80, 25, 70, 0, 25, 150);
    g.addColorStop(0, '#f00');
    g.addColorStop(0.01, '#0f0');
    g.addColorStop(0.99, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.touch3
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(120, -15, 25, 140, -30, 50);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255; @moz-todo
    @assert pixel 50,1 == 0,255,0,255; @moz-todo
    @assert pixel 98,1 == 0,255,0,255; @moz-todo
    @assert pixel 1,25 == 0,255,0,255; @moz-todo
    @assert pixel 50,25 == 0,255,0,255; @moz-todo
    @assert pixel 98,25 == 0,255,0,255; @moz-todo
    @assert pixel 1,48 == 0,255,0,255; @moz-todo
    @assert pixel 50,48 == 0,255,0,255; @moz-todo
    @assert pixel 98,48 == 0,255,0,255; @moz-todo
  expected: green

- name: 2d.gradient.radial.equal
  testing:
    - 2d.gradient.radial.equal
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(50, 25, 20, 50, 25, 20);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255; @moz-todo
    @assert pixel 50,1 == 0,255,0,255; @moz-todo
    @assert pixel 98,1 == 0,255,0,255; @moz-todo
    @assert pixel 1,25 == 0,255,0,255; @moz-todo
    @assert pixel 50,25 == 0,255,0,255; @moz-todo
    @assert pixel 98,25 == 0,255,0,255; @moz-todo
    @assert pixel 1,48 == 0,255,0,255; @moz-todo
    @assert pixel 50,48 == 0,255,0,255; @moz-todo
    @assert pixel 98,48 == 0,255,0,255; @moz-todo
  expected: green

- name: 2d.gradient.radial.cone.behind
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(120, 25, 10, 211, 25, 100);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255; @moz-todo
    @assert pixel 50,1 == 0,255,0,255; @moz-todo
    @assert pixel 98,1 == 0,255,0,255; @moz-todo
    @assert pixel 1,25 == 0,255,0,255; @moz-todo
    @assert pixel 50,25 == 0,255,0,255; @moz-todo
    @assert pixel 98,25 == 0,255,0,255; @moz-todo
    @assert pixel 1,48 == 0,255,0,255; @moz-todo
    @assert pixel 50,48 == 0,255,0,255; @moz-todo
    @assert pixel 98,48 == 0,255,0,255; @moz-todo
  expected: green

- name: 2d.gradient.radial.cone.front
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(311, 25, 10, 210, 25, 100);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.cone.bottom
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(210, 25, 100, 230, 25, 101);
    g.addColorStop(0, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.cone.top
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(230, 25, 100, 100, 25, 101);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.cone.beside
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(0, 100, 40, 100, 100, 50);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255; @moz-todo
    @assert pixel 50,1 == 0,255,0,255; @moz-todo
    @assert pixel 98,1 == 0,255,0,255; @moz-todo
    @assert pixel 1,25 == 0,255,0,255; @moz-todo
    @assert pixel 50,25 == 0,255,0,255; @moz-todo
    @assert pixel 98,25 == 0,255,0,255; @moz-todo
    @assert pixel 1,48 == 0,255,0,255; @moz-todo
    @assert pixel 50,48 == 0,255,0,255; @moz-todo
    @assert pixel 98,48 == 0,255,0,255; @moz-todo
  expected: green

- name: 2d.gradient.radial.cone.cylinder
  testing:
    - 2d.gradient.radial.rendering
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(210, 25, 100, 230, 25, 100);
    g.addColorStop(0, '#0f0');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.cone.shape1
  testing:
    - 2d.gradient.radial.rendering
  code: |
    var tol = 1; // tolerance to avoid antialiasing artifacts

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.fillStyle = '#f00';
    ctx.beginPath();
    ctx.moveTo(30+tol, 40);
    ctx.lineTo(110, -20+tol);
    ctx.lineTo(110, 100-tol);
    ctx.fill();

    var g = ctx.createRadialGradient(30+10*5/2, 40, 10*3/2, 30+10*15/4, 40, 10*9/4);
    g.addColorStop(0, '#0f0');
    g.addColorStop(1, '#0f0');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.cone.shape2
  testing:
    - 2d.gradient.radial.rendering
  code: |
    var tol = 1; // tolerance to avoid antialiasing artifacts

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var g = ctx.createRadialGradient(30+10*5/2, 40, 10*3/2, 30+10*15/4, 40, 10*9/4);
    g.addColorStop(0, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.beginPath();
    ctx.moveTo(30-tol, 40);
    ctx.lineTo(110, -20-tol);
    ctx.lineTo(110, 100+tol);
    ctx.fill();

    @assert pixel 1,1 == 0,255,0,255; @moz-todo
    @assert pixel 50,1 == 0,255,0,255; @moz-todo
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255; @moz-todo
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255; @moz-todo
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.transform.1
  desc: Radial gradient coordinates are relative to the coordinate space at the time of filling
  testing:
    - 2d.gradient.radial.transform
  code: |
    var g = ctx.createRadialGradient(0, 0, 0, 0, 0, 11.2);
    g.addColorStop(0, '#0f0');
    g.addColorStop(0.5, '#0f0');
    g.addColorStop(0.51, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.translate(50, 25);
    ctx.scale(10, 10);
    ctx.fillRect(-5, -2.5, 10, 5);
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.transform.2
  desc: Radial gradient coordinates are relative to the coordinate space at the time of filling
  testing:
    - 2d.gradient.radial.transform
  code: |
    ctx.translate(100, 0);
    var g = ctx.createRadialGradient(0, 0, 0, 0, 0, 11.2);
    g.addColorStop(0, '#0f0');
    g.addColorStop(0.5, '#0f0');
    g.addColorStop(0.51, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.translate(-50, 25);
    ctx.scale(10, 10);
    ctx.fillRect(-5, -2.5, 10, 5);
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
  expected: green

- name: 2d.gradient.radial.transform.3
  desc: Radial gradient transforms do not experience broken caching effects
  testing:
    - 2d.gradient.radial.transform
  code: |
    var g = ctx.createRadialGradient(0, 0, 0, 0, 0, 11.2);
    g.addColorStop(0, '#0f0');
    g.addColorStop(0.5, '#0f0');
    g.addColorStop(0.51, '#f00');
    g.addColorStop(1, '#f00');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, 100, 50);
    ctx.translate(50, 25);
    ctx.scale(10, 10);
    ctx.fillRect(-5, -2.5, 10, 5);
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
  expected: green






- name: 2d.pattern.basic.type
  testing:
    - 2d.pattern.return
  images:
    - green.png
  code: |
    @assert window.CanvasPattern !== undefined;

    window.CanvasPattern.prototype.thisImplementsCanvasPattern = true;

    var img = document.getElementById('green.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    @assert pattern.thisImplementsCanvasPattern;

- name: 2d.pattern.basic.image
  testing:
    - 2d.pattern.painting
  images:
    - green.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    var img = document.getElementById('green.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.basic.canvas
  testing:
    - 2d.pattern.painting
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var canvas2 = document.createElement('canvas');
    canvas2.width = 100;
    canvas2.height = 50;
    var ctx2 = canvas2.getContext('2d');
    ctx2.fillStyle = '#0f0';
    ctx2.fillRect(0, 0, 100, 50);

    var pattern = ctx.createPattern(canvas2, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.basic.zerocanvas
  testing:
    - 2d.pattern.zerocanvas
  code: |
    canvas.width = 0;
    canvas.height = 10;
    @assert canvas.width === 0;
    @assert canvas.height === 10;
    @assert throws INVALID_STATE_ERR ctx.createPattern(canvas, 'repeat');

    canvas.width = 10;
    canvas.height = 0;
    @assert canvas.width === 10;
    @assert canvas.height === 0;
    @assert throws INVALID_STATE_ERR ctx.createPattern(canvas, 'repeat');

    canvas.width = 0;
    canvas.height = 0;
    @assert canvas.width === 0;
    @assert canvas.height === 0;
    @assert throws INVALID_STATE_ERR ctx.createPattern(canvas, 'repeat');

- name: 2d.pattern.basic.nocontext
  testing:
    - 2d.pattern.painting
  code: |
    var canvas2 = document.createElement('canvas');
    canvas2.width = 100;
    canvas2.height = 50;
    var pattern = ctx.createPattern(canvas2, 'no-repeat');

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#f00';
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.image.undefined
  testing:
    - 2d.pattern.IDL
  notes: *bindings
  code: |
    @assert throws TypeError ctx.createPattern(undefined, 'repeat');

- name: 2d.pattern.image.null
  testing:
    - 2d.pattern.IDL
  notes: *bindings
  code: |
    @assert throws TypeError ctx.createPattern(null, 'repeat');

- name: 2d.pattern.image.string
  testing:
    - 2d.pattern.IDL
  notes: *bindings
  code: |
    @assert throws TypeError ctx.createPattern('../images/red.png', 'repeat');

- name: 2d.pattern.image.incomplete.nosrc
  testing:
    - 2d.pattern.incomplete.image
  mozilla: { throws }
  code: |
    var img = new Image();
    @assert ctx.createPattern(img, 'repeat') === null;

- name: 2d.pattern.image.incomplete.immediate
  testing:
    - 2d.pattern.incomplete.image
  images:
    - red.png
  code: |
    var img = new Image();
    img.src = '../images/red.png';
    // This triggers the "update the image data" algorithm.
    // The image will not go to the "completely available" state
    // until a fetch task in the networking task source is processed,
    // so the image must not be fully decodable yet:
    @assert ctx.createPattern(img, 'repeat') === null; @moz-todo

- name: 2d.pattern.image.incomplete.reload
  testing:
    - 2d.pattern.incomplete.image
  images:
    - yellow.png
    - red.png
  code: |
    var img = document.getElementById('yellow.png');
    img.src = '../images/red.png';
    // This triggers the "update the image data" algorithm,
    // and resets the image to the "unavailable" state.
    // The image will not go to the "completely available" state
    // until a fetch task in the networking task source is processed,
    // so the image must not be fully decodable yet:
    @assert ctx.createPattern(img, 'repeat') === null; @moz-todo

- name: 2d.pattern.image.incomplete.emptysrc
  testing:
    - 2d.pattern.incomplete.image
  images:
    - red.png
  mozilla: { throws }
  code: |
    var img = document.getElementById('red.png');
    img.src = "";
    @assert ctx.createPattern(img, 'repeat') === null;

- name: 2d.pattern.image.incomplete.removedsrc
  testing:
    - 2d.pattern.incomplete.image
  images:
    - red.png
  mozilla: { throws }
  code: |
    var img = document.getElementById('red.png');
    img.removeAttribute('src');
    @assert ctx.createPattern(img, 'repeat') === null;

- name: 2d.pattern.image.broken
  testing:
    - 2d.pattern.incomplete.image
  images:
    - broken.png
  code: |
    var img = document.getElementById('broken.png');
    @assert throws INVALID_STATE_ERR ctx.createPattern(img, 'repeat');

- name: 2d.pattern.repeat.empty
  testing:
    - 2d.pattern.missing
  images:
    - green-1x1.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    var img = document.getElementById('green-1x1.png');
    var pattern = ctx.createPattern(img, "");
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 200, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.repeat.null
  testing:
    - 2d.pattern.unrecognised
  code: |
    @assert ctx.createPattern(canvas, null) != null;

- name: 2d.pattern.repeat.undefined
  testing:
    - 2d.pattern.unrecognised
  code: |
    @assert throws SYNTAX_ERR ctx.createPattern(canvas, undefined);

- name: 2d.pattern.repeat.unrecognised
  testing:
    - 2d.pattern.unrecognised
  code: |
    @assert throws SYNTAX_ERR ctx.createPattern(canvas, "invalid");

- name: 2d.pattern.repeat.unrecognisednull
  testing:
    - 2d.pattern.unrecognised
  code: |
    @assert throws SYNTAX_ERR ctx.createPattern(canvas, "null");

- name: 2d.pattern.repeat.case
  testing:
    - 2d.pattern.exact
  code: |
    @assert throws SYNTAX_ERR ctx.createPattern(canvas, "Repeat");

- name: 2d.pattern.repeat.nullsuffix
  testing:
    - 2d.pattern.exact
  code: |
    @assert throws SYNTAX_ERR ctx.createPattern(canvas, "repeat\0");

- name: 2d.pattern.modify.image1
  testing:
    - 2d.pattern.modify
  images:
    - green.png
  code: |
    var img = document.getElementById('green.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    deferTest();
    img.onload = t.step_func_done(function ()
    {
        ctx.fillStyle = pattern;
        ctx.fillRect(0, 0, 100, 50);

        @assert pixel 1,1 == 0,255,0,255;
        @assert pixel 98,1 == 0,255,0,255;
        @assert pixel 1,48 == 0,255,0,255;
        @assert pixel 98,48 == 0,255,0,255;
    });
    img.src = '/images/red.png';
  expected: green

- name: 2d.pattern.modify.image2
  testing:
    - 2d.pattern.modify
  images:
    - green.png
  code: |
    var img = document.getElementById('green.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#00f';
    ctx.fillRect(0, 0, 100, 50);
    deferTest();
    img.onload = t.step_func_done(function ()
    {
        ctx.fillStyle = pattern;
        ctx.fillRect(0, 0, 100, 50);

        @assert pixel 1,1 == 0,255,0,255;
        @assert pixel 98,1 == 0,255,0,255;
        @assert pixel 1,48 == 0,255,0,255;
        @assert pixel 98,48 == 0,255,0,255;
    });
    img.src = '/images/red.png';
  expected: green

- name: 2d.pattern.modify.canvas1
  testing:
    - 2d.pattern.modify
  code: |
    var canvas2 = document.createElement('canvas');
    canvas2.width = 100;
    canvas2.height = 50;
    var ctx2 = canvas2.getContext('2d');
    ctx2.fillStyle = '#0f0';
    ctx2.fillRect(0, 0, 100, 50);

    var pattern = ctx.createPattern(canvas2, 'no-repeat');

    ctx2.fillStyle = '#f00';
    ctx2.fillRect(0, 0, 100, 50);

    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.modify.canvas2
  testing:
    - 2d.pattern.modify
  code: |
    var canvas2 = document.createElement('canvas');
    canvas2.width = 100;
    canvas2.height = 50;
    var ctx2 = canvas2.getContext('2d');
    ctx2.fillStyle = '#0f0';
    ctx2.fillRect(0, 0, 100, 50);

    var pattern = ctx.createPattern(canvas2, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx2.fillStyle = '#f00';
    ctx2.fillRect(0, 0, 100, 50);

    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.crosscanvas
  images:
    - green.png
  code: |
    var img = document.getElementById('green.png');

    var pattern = document.createElement('canvas').getContext('2d').createPattern(img, 'no-repeat');
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 50,25 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.norepeat.basic
  testing:
    - 2d.pattern.painting
  images:
    - green.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('green.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.norepeat.outside
  testing:
    - 2d.pattern.painting
  images:
    - red.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('red.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.fillStyle = pattern;
    ctx.fillRect(0, -50, 100, 50);
    ctx.fillRect(-100, 0, 100, 50);
    ctx.fillRect(0, 50, 100, 50);
    ctx.fillRect(100, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.norepeat.coord1
  testing:
    - 2d.pattern.painting
  images:
    - green.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 50, 50);
    ctx.fillStyle = '#f00';
    ctx.fillRect(50, 0, 50, 50);

    var img = document.getElementById('green.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.translate(50, 0);
    ctx.fillRect(-50, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.norepeat.coord2
  testing:
    - 2d.pattern.painting
  images:
    - green.png
  code: |
    var img = document.getElementById('green.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 50, 50);

    ctx.fillStyle = '#f00';
    ctx.fillRect(50, 0, 50, 50);

    ctx.fillStyle = pattern;
    ctx.translate(50, 0);
    ctx.fillRect(-50, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.norepeat.coord3
  testing:
    - 2d.pattern.painting
  images:
    - red.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('red.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.translate(50, 25);
    ctx.fillRect(-50, -25, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 50, 25);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeat.basic
  testing:
    - 2d.pattern.painting
  images:
    - green-16x16.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('green-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeat.outside
  testing:
    - 2d.pattern.painting
  images:
    - green-16x16.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('green-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat');
    ctx.fillStyle = pattern;
    ctx.translate(50, 25);
    ctx.fillRect(-50, -25, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeat.coord1
  testing:
    - 2d.pattern.painting
  images:
    - rgrg-256x256.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('rgrg-256x256.png');
    var pattern = ctx.createPattern(img, 'repeat');
    ctx.fillStyle = pattern;
    ctx.translate(-128, -78);
    ctx.fillRect(128, 78, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeat.coord2
  testing:
    - 2d.pattern.painting
  images:
    - ggrr-256x256.png
  code: |
    var img = document.getElementById('ggrr-256x256.png');
    var pattern = ctx.createPattern(img, 'repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeat.coord3
  testing:
    - 2d.pattern.painting
  images:
    - rgrg-256x256.png
  code: |
    var img = document.getElementById('rgrg-256x256.png');
    var pattern = ctx.createPattern(img, 'repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    ctx.translate(-128, -78);
    ctx.fillRect(128, 78, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeatx.basic
  testing:
    - 2d.pattern.painting
  images:
    - green-16x16.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 16);

    var img = document.getElementById('green-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat-x');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeatx.outside
  testing:
    - 2d.pattern.painting
  images:
    - red-16x16.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('red-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat-x');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 16);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeatx.coord1
  testing:
    - 2d.pattern.painting
  images:
    - red-16x16.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('red-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat-x');
    ctx.fillStyle = pattern;
    ctx.translate(0, 16);
    ctx.fillRect(0, -16, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 16);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,25 == 0,255,0,255;
    @assert pixel 98,25 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeaty.basic
  testing:
    - 2d.pattern.painting
  images:
    - green-16x16.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 16, 50);

    var img = document.getElementById('green-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat-y');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeaty.outside
  testing:
    - 2d.pattern.painting
  images:
    - red-16x16.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('red-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat-y');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 16, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.repeaty.coord1
  testing:
    - 2d.pattern.painting
  images:
    - red-16x16.png
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('red-16x16.png');
    var pattern = ctx.createPattern(img, 'repeat-y');
    ctx.fillStyle = pattern;
    ctx.translate(48, 0);
    ctx.fillRect(-48, 0, 100, 50);

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 16, 50);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 50,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 50,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.orientation.image
  desc: Image patterns do not get flipped when painted
  testing:
    - 2d.pattern.painting
  images:
    - rrgg-256x256.png
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var img = document.getElementById('rrgg-256x256.png');
    var pattern = ctx.createPattern(img, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.save();
    ctx.translate(0, -103);
    ctx.fillRect(0, 103, 100, 50);
    ctx.restore();

    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 25);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green

- name: 2d.pattern.paint.orientation.canvas
  desc: Canvas patterns do not get flipped when painted
  testing:
    - 2d.pattern.painting
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    var canvas2 = document.createElement('canvas');
    canvas2.width = 100;
    canvas2.height = 50;
    var ctx2 = canvas2.getContext('2d');
    ctx2.fillStyle = '#f00';
    ctx2.fillRect(0, 0, 100, 25);
    ctx2.fillStyle = '#0f0';
    ctx2.fillRect(0, 25, 100, 25);

    var pattern = ctx.createPattern(canvas2, 'no-repeat');
    ctx.fillStyle = pattern;
    ctx.fillRect(0, 0, 100, 50);
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 25);

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 98,1 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
    @assert pixel 98,48 == 0,255,0,255;
  expected: green


- name: 2d.pattern.animated.gif
  desc: createPattern() of an animated GIF draws the first frame
  testing:
    - 2d.pattern.animated.image
  images:
    - anim-gr.gif
  code: |
    deferTest();
    setTimeout(function () {
        var pattern = ctx.createPattern(document.getElementById('anim-gr.gif'), 'repeat');
        ctx.fillStyle = pattern;
        ctx.fillRect(0, 0, 50, 50);
        setTimeout(t.step_func_done(function () {
            ctx.fillRect(50, 0, 50, 50);
            @assert pixel 25,25 ==~ 0,255,0,255;
            @assert pixel 75,25 ==~ 0,255,0,255;
        }), 250);
    }, 250);
  expected: green




- name: 2d.line.defaults
  testing:
    - 2d.lineWidth.default
    - 2d.lineCap.default
    - 2d.lineJoin.default
    - 2d.miterLimit.default
  code: |
    @assert ctx.lineWidth === 1;
    @assert ctx.lineCap === 'butt';
    @assert ctx.lineJoin === 'miter';
    @assert ctx.miterLimit === 10;

- name: 2d.line.width.basic
  desc: lineWidth determines the width of line strokes
  testing:
    - 2d.lineWidth
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.lineWidth = 20;
    // Draw a green line over a red box, to check the line is not too small
    ctx.fillStyle = '#f00';
    ctx.strokeStyle = '#0f0';
    ctx.fillRect(15, 15, 20, 20);
    ctx.beginPath();
    ctx.moveTo(25, 15);
    ctx.lineTo(25, 35);
    ctx.stroke();

    // Draw a green box over a red line, to check the line is not too large
    ctx.fillStyle = '#0f0';
    ctx.strokeStyle = '#f00';
    ctx.beginPath();
    ctx.moveTo(75, 15);
    ctx.lineTo(75, 35);
    ctx.stroke();
    ctx.fillRect(65, 15, 20, 20);

    @assert pixel 14,25 == 0,255,0,255;
    @assert pixel 15,25 == 0,255,0,255;
    @assert pixel 16,25 == 0,255,0,255;
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 34,25 == 0,255,0,255;
    @assert pixel 35,25 == 0,255,0,255;
    @assert pixel 36,25 == 0,255,0,255;

    @assert pixel 64,25 == 0,255,0,255;
    @assert pixel 65,25 == 0,255,0,255;
    @assert pixel 66,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
    @assert pixel 84,25 == 0,255,0,255;
    @assert pixel 85,25 == 0,255,0,255;
    @assert pixel 86,25 == 0,255,0,255;
  expected: green

- name: 2d.line.width.transformed
  desc: Line stroke widths are affected by scale transformations
  testing:
    - 2d.lineWidth
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.lineWidth = 4;
    // Draw a green line over a red box, to check the line is not too small
    ctx.fillStyle = '#f00';
    ctx.strokeStyle = '#0f0';
    ctx.fillRect(15, 15, 20, 20);
    ctx.save();
     ctx.scale(5, 1);
     ctx.beginPath();
     ctx.moveTo(5, 15);
     ctx.lineTo(5, 35);
     ctx.stroke();
    ctx.restore();

    // Draw a green box over a red line, to check the line is not too large
    ctx.fillStyle = '#0f0';
    ctx.strokeStyle = '#f00';
    ctx.save();
     ctx.scale(-5, 1);
     ctx.beginPath();
     ctx.moveTo(-15, 15);
     ctx.lineTo(-15, 35);
     ctx.stroke();
    ctx.restore();
    ctx.fillRect(65, 15, 20, 20);

    @assert pixel 14,25 == 0,255,0,255;
    @assert pixel 15,25 == 0,255,0,255;
    @assert pixel 16,25 == 0,255,0,255;
    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 34,25 == 0,255,0,255;
    @assert pixel 35,25 == 0,255,0,255;
    @assert pixel 36,25 == 0,255,0,255;

    @assert pixel 64,25 == 0,255,0,255;
    @assert pixel 65,25 == 0,255,0,255;
    @assert pixel 66,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
    @assert pixel 84,25 == 0,255,0,255;
    @assert pixel 85,25 == 0,255,0,255;
    @assert pixel 86,25 == 0,255,0,255;
  expected: green

- name: 2d.line.width.scaledefault
  desc: Default lineWidth strokes are affected by scale transformations
  testing:
    - 2d.lineWidth
  code: |
    ctx.fillStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.scale(50, 50);
    ctx.strokeStyle = '#0f0';
    ctx.moveTo(0, 0.5);
    ctx.lineTo(2, 0.5);
    ctx.stroke();

    @assert pixel 25,25 == 0,255,0,255;
    @assert pixel 50,25 == 0,255,0,255;
    @assert pixel 75,25 == 0,255,0,255;
    @assert pixel 50,5 == 0,255,0,255;
    @assert pixel 50,45 == 0,255,0,255;
  expected: green

- name: 2d.line.width.valid
  desc: Setting lineWidth to valid values works
  testing:
    - 2d.lineWidth.set
    - 2d.lineWidth.get
  code: |
    ctx.lineWidth = 1.5;
    @assert ctx.lineWidth === 1.5;

    ctx.lineWidth = "1e1";
    @assert ctx.lineWidth === 10;

    ctx.lineWidth = 1/1024;
    @assert ctx.lineWidth === 1/1024;

    ctx.lineWidth = 1000;
    @assert ctx.lineWidth === 1000;

- name: 2d.line.width.invalid
  desc: Setting lineWidth to invalid values is ignored
  testing:
    - 2d.lineWidth.invalid
  code: |
    ctx.lineWidth = 1.5;
    @assert ctx.lineWidth === 1.5;

    ctx.lineWidth = 1.5;
    ctx.lineWidth = 0;
    @assert ctx.lineWidth === 1.5;

    ctx.lineWidth = 1.5;
    ctx.lineWidth = -1;
    @assert ctx.lineWidth === 1.5;

    ctx.lineWidth = 1.5;
    ctx.lineWidth = Infinity;
    @assert ctx.lineWidth === 1.5;

    ctx.lineWidth = 1.5;
    ctx.lineWidth = -Infinity;
    @assert ctx.lineWidth === 1.5;

    ctx.lineWidth = 1.5;
    ctx.lineWidth = NaN;
    @assert ctx.lineWidth === 1.5;

- name: 2d.line.cap.butt
  desc: lineCap 'butt' is rendered correctly
  testing:
    - 2d.lineCap.butt
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.lineCap = 'butt';
    ctx.lineWidth = 20;

    ctx.fillStyle = '#f00';
    ctx.strokeStyle = '#0f0';
    ctx.fillRect(15, 15, 20, 20);
    ctx.beginPath();
    ctx.moveTo(25, 15);
    ctx.lineTo(25, 35);
    ctx.stroke();

    ctx.fillStyle = '#0f0';
    ctx.strokeStyle = '#f00';
    ctx.beginPath();
    ctx.moveTo(75, 15);
    ctx.lineTo(75, 35);
    ctx.stroke();
    ctx.fillRect(65, 15, 20, 20);

    @assert pixel 25,14 == 0,255,0,255;
    @assert pixel 25,15 == 0,255,0,255;
    @assert pixel 25,16 == 0,255,0,255;
    @assert pixel 25,34 == 0,255,0,255;
    @assert pixel 25,35 == 0,255,0,255;
    @assert pixel 25,36 == 0,255,0,255;

    @assert pixel 75,14 == 0,255,0,255;
    @assert pixel 75,15 == 0,255,0,255;
    @assert pixel 75,16 == 0,255,0,255;
    @assert pixel 75,34 == 0,255,0,255;
    @assert pixel 75,35 == 0,255,0,255;
    @assert pixel 75,36 == 0,255,0,255;
  expected: green

- name: 2d.line.cap.round
  desc: lineCap 'round' is rendered correctly
  testing:
    - 2d.lineCap.round
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    var tol = 1; // tolerance to avoid antialiasing artifacts

    ctx.lineCap = 'round';
    ctx.lineWidth = 20;


    ctx.fillStyle = '#f00';
    ctx.strokeStyle = '#0f0';

    ctx.beginPath();
    ctx.moveTo(35-tol, 15);
    ctx.arc(25, 15, 10-tol, 0, Math.PI, true);
    ctx.arc(25, 35, 10-tol, Math.PI, 0, true);
    ctx.fill();

    ctx.beginPath();
    ctx.moveTo(25, 15);
    ctx.lineTo(25, 35);
    ctx.stroke();


    ctx.fillStyle = '#0f0';
    ctx.strokeStyle = '#f00';

    ctx.beginPath();
    ctx.moveTo(75, 15);
    ctx.lineTo(75, 35);
    ctx.stroke();

    ctx.beginPath();
    ctx.moveTo(85+tol, 15);
    ctx.arc(75, 15, 10+tol, 0, Math.PI, true);
    ctx.arc(75, 35, 10+tol, Math.PI, 0, true);
    ctx.fill();

    @assert pixel 17,6 == 0,255,0,255;
    @assert pixel 25,6 == 0,255,0,255;
    @assert pixel 32,6 == 0,255,0,255;
    @assert pixel 17,43 == 0,255,0,255;
    @assert pixel 25,43 == 0,255,0,255;
    @assert pixel 32,43 == 0,255,0,255;

    @assert pixel 67,6 == 0,255,0,255;
    @assert pixel 75,6 == 0,255,0,255;
    @assert pixel 82,6 == 0,255,0,255;
    @assert pixel 67,43 == 0,255,0,255;
    @assert pixel 75,43 == 0,255,0,255;
    @assert pixel 82,43 == 0,255,0,255;
  expected: green

- name: 2d.line.cap.square
  desc: lineCap 'square' is rendered correctly
  testing:
    - 2d.lineCap.square
  code: |
    ctx.fillStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.lineCap = 'square';
    ctx.lineWidth = 20;

    ctx.fillStyle = '#f00';
    ctx.strokeStyle = '#0f0';
    ctx.fillRect(15, 5, 20, 40);
    ctx.beginPath();
    ctx.moveTo(25, 15);
    ctx.lineTo(25, 35);
    ctx.stroke();

    ctx.fillStyle = '#0f0';
    ctx.strokeStyle = '#f00';
    ctx.beginPath();
    ctx.moveTo(75, 15);
    ctx.lineTo(75, 35);
    ctx.stroke();
    ctx.fillRect(65, 5, 20, 40);

    @assert pixel 25,4 == 0,255,0,255;
    @assert pixel 25,5 == 0,255,0,255;
    @assert pixel 25,6 == 0,255,0,255;
    @assert pixel 25,44 == 0,255,0,255;
    @assert pixel 25,45 == 0,255,0,255;
    @assert pixel 25,46 == 0,255,0,255;

    @assert pixel 75,4 == 0,255,0,255;
    @assert pixel 75,5 == 0,255,0,255;
    @assert pixel 75,6 == 0,255,0,255;
    @assert pixel 75,44 == 0,255,0,255;
    @assert pixel 75,45 == 0,255,0,255;
    @assert pixel 75,46 == 0,255,0,255;
  expected: green

- name: 2d.line.cap.open
  desc: Line caps are drawn at the corners of an unclosed rectangle
  testing:
    - 2d.lineCap.end
  code: |
    ctx.fillStyle = '#f00';
    ctx.strokeStyle = '#0f0';
    ctx.fillRect(0, 0, 100, 50);

    ctx.lineJoin = 'bevel';
    ctx.lineCap = 'square';
    ctx.lineWidth = 400;

    ctx.beginPath();
    ctx.moveTo(200, 200);
    ctx.lineTo(200, 1000);
    ctx.lineTo(1000, 1000);
    ctx.lineTo(1000, 200);
    ctx.lineTo(200, 200);
    ctx.stroke();

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 48,1 == 0,255,0,255;
    @assert pixel 48,48 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
  expected: green

- name: 2d.line.cap.closed
  desc: Line caps are not drawn at the corners of an unclosed rectangle
  testing:
    - 2d.lineCap.end
  code: |
    ctx.fillStyle = '#0f0';
    ctx.strokeStyle = '#f00';
    ctx.fillRect(0, 0, 100, 50);

    ctx.lineJoin = 'bevel';
    ctx.lineCap = 'square';
    ctx.lineWidth = 400;

    ctx.beginPath();
    ctx.moveTo(200, 200);
    ctx.lineTo(200, 1000);
    ctx.lineTo(1000, 1000);
    ctx.lineTo(1000, 200);
    ctx.closePath();
    ctx.stroke();

    @assert pixel 1,1 == 0,255,0,255;
    @assert pixel 48,1 == 0,255,0,255;
    @assert pixel 48,48 == 0,255,0,255;
    @assert pixel 1,48 == 0,255,0,255;
  expected: green

- name: 2d.line.cap.valid
  desc: Setting lineCap to valid values works
  testing:
    - 2d.lineCap.set
    - 2d.lineCap.get
  code: |
    ctx.lineCap = 'butt'
    @assert ctx.lineCap === 'butt';

    ctx.lineCap = 'round';
    @assert ctx.lineCap === 'round';

    ctx.lineCap = 'square';
    @assert ctx.lineCap === 'square';

- name: 2d.line.cap.invalid
  desc: Setting lineCap to invalid values is ignored
  testing:
    - 2d.lineCap.invalid
  code: |
    ctx.lineCap = 'butt'
    @assert ctx.lineCap === 'butt';

    ctx.lineCap = 'butt';
    ctx.lineCap = 'invalid';
    @assert ctx.lineCap === 'butt';

    ctx.lineCap = 'butt';
    ctx.lineCap = 'ROUND';
    @assert ctx.lineCap