// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// @dart = 2.6
import 'dart:typed_data';

import 'package:test/test.dart';

import 'package:ui/src/engine.dart';
import 'package:ui/ui.dart' as ui;

import 'common.dart';

void main() {
  group('CanvasKit API', () {
    setUpAll(() async {
      await ui.webOnlyInitializePlatform();
    });

    test('Using CanvasKit', () {
      expect(experimentalUseSkia, true);
    });

    _blendModeTests();
    _paintStyleTests();
    _strokeCapTests();
    _strokeJoinTests();
    _filterQualityTests();
    _blurStyleTests();
    _tileModeTests();
    _fillTypeTests();
    _pathOpTests();
    _clipOpTests();
    _pointModeTests();
    _vertexModeTests();
    _imageTests();
    _shaderTests();
    _paintTests();
    _maskFilterTests();
    _colorFilterTests();
    _imageFilterTests();
    _mallocTests();
    _sharedColorTests();
    _toSkPointTests();
    _toSkColorStopsTests();
    _toSkMatrixFromFloat32Tests();
    _skSkRectTests();
    _skVerticesTests();
    group('SkPath', () {
      _pathTests();
    });
    group('SkCanvas', () {
      _canvasTests();
    });
  // TODO: https://github.com/flutter/flutter/issues/60040
  }, skip: isIosSafari);
}

void _blendModeTests() {
  test('blend mode mapping is correct', () {
    expect(canvasKitJs.BlendMode.Clear.value, ui.BlendMode.clear.index);
    expect(canvasKitJs.BlendMode.Src.value, ui.BlendMode.src.index);
    expect(canvasKitJs.BlendMode.Dst.value, ui.BlendMode.dst.index);
    expect(canvasKitJs.BlendMode.SrcOver.value, ui.BlendMode.srcOver.index);
    expect(canvasKitJs.BlendMode.DstOver.value, ui.BlendMode.dstOver.index);
    expect(canvasKitJs.BlendMode.SrcIn.value, ui.BlendMode.srcIn.index);
    expect(canvasKitJs.BlendMode.DstIn.value, ui.BlendMode.dstIn.index);
    expect(canvasKitJs.BlendMode.SrcOut.value, ui.BlendMode.srcOut.index);
    expect(canvasKitJs.BlendMode.DstOut.value, ui.BlendMode.dstOut.index);
    expect(canvasKitJs.BlendMode.SrcATop.value, ui.BlendMode.srcATop.index);
    expect(canvasKitJs.BlendMode.DstATop.value, ui.BlendMode.dstATop.index);
    expect(canvasKitJs.BlendMode.Xor.value, ui.BlendMode.xor.index);
    expect(canvasKitJs.BlendMode.Plus.value, ui.BlendMode.plus.index);
    expect(canvasKitJs.BlendMode.Modulate.value, ui.BlendMode.modulate.index);
    expect(canvasKitJs.BlendMode.Screen.value, ui.BlendMode.screen.index);
    expect(canvasKitJs.BlendMode.Overlay.value, ui.BlendMode.overlay.index);
    expect(canvasKitJs.BlendMode.Darken.value, ui.BlendMode.darken.index);
    expect(canvasKitJs.BlendMode.Lighten.value, ui.BlendMode.lighten.index);
    expect(canvasKitJs.BlendMode.ColorDodge.value, ui.BlendMode.colorDodge.index);
    expect(canvasKitJs.BlendMode.ColorBurn.value, ui.BlendMode.colorBurn.index);
    expect(canvasKitJs.BlendMode.HardLight.value, ui.BlendMode.hardLight.index);
    expect(canvasKitJs.BlendMode.SoftLight.value, ui.BlendMode.softLight.index);
    expect(canvasKitJs.BlendMode.Difference.value, ui.BlendMode.difference.index);
    expect(canvasKitJs.BlendMode.Exclusion.value, ui.BlendMode.exclusion.index);
    expect(canvasKitJs.BlendMode.Multiply.value, ui.BlendMode.multiply.index);
    expect(canvasKitJs.BlendMode.Hue.value, ui.BlendMode.hue.index);
    expect(canvasKitJs.BlendMode.Saturation.value, ui.BlendMode.saturation.index);
    expect(canvasKitJs.BlendMode.Color.value, ui.BlendMode.color.index);
    expect(canvasKitJs.BlendMode.Luminosity.value, ui.BlendMode.luminosity.index);
  });

  test('ui.BlendMode converts to SkBlendMode', () {
    for (ui.BlendMode blendMode in ui.BlendMode.values) {
      expect(toSkBlendMode(blendMode).value, blendMode.index);
    }
  });
}

void _paintStyleTests() {
  test('paint style mapping is correct', () {
    expect(canvasKitJs.PaintStyle.Fill.value, ui.PaintingStyle.fill.index);
    expect(canvasKitJs.PaintStyle.Stroke.value, ui.PaintingStyle.stroke.index);
  });

  test('ui.PaintingStyle converts to SkPaintStyle', () {
    for (ui.PaintingStyle style in ui.PaintingStyle.values) {
      expect(toSkPaintStyle(style).value, style.index);
    }
  });
}

void _strokeCapTests() {
  test('stroke cap mapping is correct', () {
    expect(canvasKitJs.StrokeCap.Butt.value, ui.StrokeCap.butt.index);
    expect(canvasKitJs.StrokeCap.Round.value, ui.StrokeCap.round.index);
    expect(canvasKitJs.StrokeCap.Square.value, ui.StrokeCap.square.index);
  });

  test('ui.StrokeCap converts to SkStrokeCap', () {
    for (ui.StrokeCap cap in ui.StrokeCap.values) {
      expect(toSkStrokeCap(cap).value, cap.index);
    }
  });
}

void _strokeJoinTests() {
  test('stroke cap mapping is correct', () {
    expect(canvasKitJs.StrokeJoin.Miter.value, ui.StrokeJoin.miter.index);
    expect(canvasKitJs.StrokeJoin.Round.value, ui.StrokeJoin.round.index);
    expect(canvasKitJs.StrokeJoin.Bevel.value, ui.StrokeJoin.bevel.index);
  });

  test('ui.StrokeJoin converts to SkStrokeJoin', () {
    for (ui.StrokeJoin join in ui.StrokeJoin.values) {
      expect(toSkStrokeJoin(join).value, join.index);
    }
  });
}

void _filterQualityTests() {
  test('filter quality mapping is correct', () {
    expect(canvasKitJs.FilterQuality.None.value, ui.FilterQuality.none.index);
    expect(canvasKitJs.FilterQuality.Low.value, ui.FilterQuality.low.index);
    expect(canvasKitJs.FilterQuality.Medium.value, ui.FilterQuality.medium.index);
    expect(canvasKitJs.FilterQuality.High.value, ui.FilterQuality.high.index);
  });

  test('ui.FilterQuality converts to SkFilterQuality', () {
    for (ui.FilterQuality cap in ui.FilterQuality.values) {
      expect(toSkFilterQuality(cap).value, cap.index);
    }
  });
}

void _blurStyleTests() {
  test('blur style mapping is correct', () {
    expect(canvasKitJs.BlurStyle.Normal.value, ui.BlurStyle.normal.index);
    expect(canvasKitJs.BlurStyle.Solid.value, ui.BlurStyle.solid.index);
    expect(canvasKitJs.BlurStyle.Outer.value, ui.BlurStyle.outer.index);
    expect(canvasKitJs.BlurStyle.Inner.value, ui.BlurStyle.inner.index);
  });

  test('ui.BlurStyle converts to SkBlurStyle', () {
    for (ui.BlurStyle style in ui.BlurStyle.values) {
      expect(toSkBlurStyle(style).value, style.index);
    }
  });
}

void _tileModeTests() {
  test('tile mode mapping is correct', () {
    expect(canvasKitJs.TileMode.Clamp.value, ui.TileMode.clamp.index);
    expect(canvasKitJs.TileMode.Repeat.value, ui.TileMode.repeated.index);
    expect(canvasKitJs.TileMode.Mirror.value, ui.TileMode.mirror.index);
  });

  test('ui.TileMode converts to SkTileMode', () {
    for (ui.TileMode mode in ui.TileMode.values) {
      expect(toSkTileMode(mode).value, mode.index);
    }
  });
}

void _fillTypeTests() {
  test('fill type mapping is correct', () {
    expect(canvasKitJs.FillType.Winding.value, ui.PathFillType.nonZero.index);
    expect(canvasKitJs.FillType.EvenOdd.value, ui.PathFillType.evenOdd.index);
  });

  test('ui.PathFillType converts to SkFillType', () {
    for (ui.PathFillType type in ui.PathFillType.values) {
      expect(toSkFillType(type).value, type.index);
    }
  });
}

void _pathOpTests() {
  // TODO(yjbanov): https://github.com/flutter/flutter/issues/61403
  // test('path op mapping is correct', () {
  //   expect(canvasKitJs.PathOp.Difference.value, ui.PathOperation.difference.index);
  //   expect(canvasKitJs.PathOp.Intersect.value, ui.PathOperation.intersect.index);
  //   expect(canvasKitJs.PathOp.Union.value, ui.PathOperation.union.index);
  //   expect(canvasKitJs.PathOp.XOR.value, ui.PathOperation.xor.index);
  //   expect(canvasKitJs.PathOp.ReverseDifference, ui.PathOperation.reverseDifference.index);
  // });

  // test('ui.PathOperation converts to SkPathOp', () {
  //   for (ui.PathOperation op in ui.PathOperation.values) {
  //     expect(toSkPathOp(op).value, op.index);
  //   }
  // });
}

void _clipOpTests() {
  test('clip op mapping is correct', () {
    expect(canvasKitJs.ClipOp.Difference.value, ui.ClipOp.difference.index);
    expect(canvasKitJs.ClipOp.Intersect.value, ui.ClipOp.intersect.index);
  });

  test('ui.ClipOp converts to SkClipOp', () {
    for (ui.ClipOp op in ui.ClipOp.values) {
      expect(toSkClipOp(op).value, op.index);
    }
  });
}

void _pointModeTests() {
  test('point mode mapping is correct', () {
    expect(canvasKitJs.PointMode.Points.value, ui.PointMode.points.index);
    expect(canvasKitJs.PointMode.Lines.value, ui.PointMode.lines.index);
    expect(canvasKitJs.PointMode.Polygon.value, ui.PointMode.polygon.index);
  });

  test('ui.PointMode converts to SkPointMode', () {
    for (ui.PointMode op in ui.PointMode.values) {
      expect(toSkPointMode(op).value, op.index);
    }
  });
}

void _vertexModeTests() {
  test('vertex mode mapping is correct', () {
    expect(canvasKitJs.VertexMode.Triangles.value, ui.VertexMode.triangles.index);
    expect(canvasKitJs.VertexMode.TrianglesStrip.value, ui.VertexMode.triangleStrip.index);
    expect(canvasKitJs.VertexMode.TriangleFan.value, ui.VertexMode.triangleFan.index);
  });

  test('ui.VertexMode converts to SkVertexMode', () {
    for (ui.VertexMode op in ui.VertexMode.values) {
      expect(toSkVertexMode(op).value, op.index);
    }
  });
}

void _imageTests() {
  test('MakeAnimatedImageFromEncoded makes a non-animated image', () {
    final SkAnimatedImage nonAnimated = canvasKitJs.MakeAnimatedImageFromEncoded(kTransparentImage);
    expect(nonAnimated.getFrameCount(), 1);
    expect(nonAnimated.getRepetitionCount(), 0);
    expect(nonAnimated.width(), 1);
    expect(nonAnimated.height(), 1);

    final SkImage frame = nonAnimated.getCurrentFrame();
    expect(frame.width(), 1);
    expect(frame.height(), 1);

    expect(nonAnimated.decodeNextFrame(), -1);
    expect(frame.makeShader(canvasKitJs.TileMode.Repeat, canvasKitJs.TileMode.Mirror), isNotNull);
  });

  test('MakeAnimatedImageFromEncoded makes an animated image', () {
    final SkAnimatedImage animated = canvasKitJs.MakeAnimatedImageFromEncoded(kAnimatedGif);
    expect(animated.getFrameCount(), 3);
    expect(animated.getRepetitionCount(), -1);  // animates forever
    expect(animated.width(), 1);
    expect(animated.height(), 1);
    for (int i = 0; i < 100; i++) {
      final SkImage frame = animated.getCurrentFrame();
      expect(frame.width(), 1);
      expect(frame.height(), 1);
      expect(animated.decodeNextFrame(), 100);
    }
  });
}

void _shaderTests() {
  test('MakeLinearGradient', () {
    expect(_makeTestShader(), isNotNull);
  });

  test('MakeRadialGradient', () {
    expect(canvasKitJs.SkShader.MakeRadialGradient(
      Float32List.fromList([1, 1]),
      10.0,
      <Float32List>[
        Float32List.fromList([0, 0, 0, 1]),
        Float32List.fromList([1, 1, 1, 1]),
      ],
      Float32List.fromList([0, 1]),
      canvasKitJs.TileMode.Repeat,
      toSkMatrixFromFloat32(Matrix4.identity().storage),
      0,
    ), isNotNull);
  });

  test('MakeTwoPointConicalGradient', () {
    expect(canvasKitJs.SkShader.MakeTwoPointConicalGradient(
      Float32List.fromList([1, 1]),
      10.0,
      Float32List.fromList([1, 1]),
      10.0,
      <Float32List>[
        Float32List.fromList([0, 0, 0, 1]),
        Float32List.fromList([1, 1, 1, 1]),
      ],
      Float32List.fromList([0, 1]),
      canvasKitJs.TileMode.Repeat,
      toSkMatrixFromFloat32(Matrix4.identity().storage),
      0,
    ), isNotNull);
  });
}

SkShader _makeTestShader() {
  return canvasKitJs.SkShader.MakeLinearGradient(
    Float32List.fromList([0, 0]),
    Float32List.fromList([1, 1]),
    [
      Float32List.fromList([255, 0, 0, 255]),
    ],
    Float32List.fromList([0, 1]),
    canvasKitJs.TileMode.Repeat,
  );
}

void _paintTests() {
  test('can make SkPaint', () async {
    final SkPaint paint = SkPaint();
    paint.setBlendMode(canvasKitJs.BlendMode.SrcOut);
    paint.setStyle(canvasKitJs.PaintStyle.Stroke);
    paint.setStrokeWidth(3.0);
    paint.setStrokeCap(canvasKitJs.StrokeCap.Round);
    paint.setStrokeJoin(canvasKitJs.StrokeJoin.Bevel);
    paint.setAntiAlias(true);
    paint.setColorInt(0x00FFCCAA);
    paint.setShader(_makeTestShader());
    paint.setMaskFilter(canvasKitJs.MakeBlurMaskFilter(
      canvasKitJs.BlurStyle.Outer,
      2.0,
      true,
    ));
    paint.setFilterQuality(canvasKitJs.FilterQuality.High);
    paint.setColorFilter(canvasKitJs.SkColorFilter.MakeLinearToSRGBGamma());
    paint.setStrokeMiter(1.4);
    paint.setImageFilter(canvasKitJs.SkImageFilter.MakeBlur(
      1,
      2,
      canvasKitJs.TileMode.Repeat,
      null,
    ));
  });
}

void _maskFilterTests() {
  test('MakeBlurMaskFilter', () {
    expect(canvasKitJs.MakeBlurMaskFilter(
      canvasKitJs.BlurStyle.Outer,
      5.0,
      false,
    ), isNotNull);
  });
}

void _colorFilterTests() {
  test('MakeBlend', () {
    expect(
      canvasKitJs.SkColorFilter.MakeBlend(
        Float32List.fromList([0, 0, 0, 1]),
        canvasKitJs.BlendMode.SrcATop,
      ),
      isNotNull,
    );
  });

  test('MakeMatrix', () {
    expect(
      canvasKitJs.SkColorFilter.MakeMatrix(
        Float32List(20),
      ),
      isNotNull,
    );
  });

  test('MakeSRGBToLinearGamma', () {
    expect(
      canvasKitJs.SkColorFilter.MakeSRGBToLinearGamma(),
      isNotNull,
    );
  });

  test('MakeLinearToSRGBGamma', () {
    expect(
      canvasKitJs.SkColorFilter.MakeLinearToSRGBGamma(),
      isNotNull,
    );
  });
}

void _imageFilterTests() {
  test('MakeBlur', () {
    expect(
      canvasKitJs.SkImageFilter.MakeBlur(1, 2, canvasKitJs.TileMode.Repeat, null),
      isNotNull,
    );
  });

  test('MakeMatrixTransform', () {
    expect(
      canvasKitJs.SkImageFilter.MakeMatrixTransform(
        toSkMatrixFromFloat32(Matrix4.identity().storage),
        canvasKitJs.FilterQuality.Medium,
        null,
      ),
      isNotNull,
    );
  });
}

void _mallocTests() {
  test('SkFloat32List', () {
    for (int size = 0; size < 1000; size++) {
      final SkFloat32List skList = mallocFloat32List(4);
      expect(skList, isNotNull);
      expect(skList.toTypedArray().length, 4);
    }
  });
}

void _sharedColorTests() {
  test('toSharedSkColor1', () {
    expect(
      toSharedSkColor1(const ui.Color(0xAABBCCDD)),
      Float32List(4)
        ..[0] = 0xBB / 255.0
        ..[1] = 0xCC / 255.0
        ..[2] = 0xDD / 255.0
        ..[3] = 0xAA / 255.0,
    );
  });
  test('toSharedSkColor2', () {
    expect(
      toSharedSkColor2(const ui.Color(0xAABBCCDD)),
      Float32List(4)
        ..[0] = 0xBB / 255.0
        ..[1] = 0xCC / 255.0
        ..[2] = 0xDD / 255.0
        ..[3] = 0xAA / 255.0,
    );
  });
  test('toSharedSkColor3', () {
    expect(
      toSharedSkColor3(const ui.Color(0xAABBCCDD)),
      Float32List(4)
        ..[0] = 0xBB / 255.0
        ..[1] = 0xCC / 255.0
        ..[2] = 0xDD / 255.0
        ..[3] = 0xAA / 255.0,
    );
  });
}

void _toSkPointTests() {
  test('toSkPoint', () {
    expect(
      toSkPoint(const ui.Offset(4, 5)),
      Float32List(2)
        ..[0] = 4.0
        ..[1] = 5.0,
    );
  });
}

void _toSkColorStopsTests() {
  test('toSkColorStops default', () {
    expect(
      toSkColorStops(null),
      Float32List(2)
        ..[0] = 0
        ..[1] = 1,
    );
  });

  test('toSkColorStops custom', () {
    expect(
      toSkColorStops(<double>[1, 2, 3, 4]),
      Float32List(4)
        ..[0] = 1
        ..[1] = 2
        ..[2] = 3
        ..[3] = 4,
    );
  });
}

void _toSkMatrixFromFloat32Tests() {
  test('toSkMatrixFromFloat32', () {
    final Matrix4 matrix = Matrix4.identity()
      ..translate(1, 2, 3)
      ..rotateZ(4);
    expect(
      toSkMatrixFromFloat32(matrix.storage),
      Float32List.fromList(<double>[
        -0.6536436080932617,
        0.756802499294281,
        1,
        -0.756802499294281,
        -0.6536436080932617,
        2,
        -0.0,
        0,
        1,
      ])
    );
  });
}

SkPath _testClosedSkPath() {
  return SkPath()
    ..moveTo(10, 10)
    ..lineTo(20, 10)
    ..lineTo(20, 20)
    ..lineTo(10, 20)
    ..close();
}

void _pathTests() {
  SkPath path;

  setUp(() {
    path = SkPath();
  });

  test('setFillType', () {
    path.setFillType(canvasKitJs.FillType.Winding);
  });

  test('addArc', () {
    path.addArc(
      SkRect(fLeft: 10, fTop: 20, fRight: 30, fBottom: 40),
      1,
      5,
    );
  });

  test('addOval', () {
    path.addOval(
      SkRect(fLeft: 10, fTop: 20, fRight: 30, fBottom: 40),
      false,
      1,
    );
  });

  test('addPath', () {
    path.addPath(_testClosedSkPath(), 1, 0, 0, 0, 1, 0, 0, 0, 0, false);
  });

  test('addPoly', () {
    final SkFloat32List encodedPoints = toMallocedSkPoints(const <ui.Offset>[
      ui.Offset.zero,
      ui.Offset(10, 10),
    ]);
    path.addPoly(encodedPoints.toTypedArray(), true);
    freeFloat32List(encodedPoints);
  });

  test('addRoundRect', () {
    final ui.RRect rrect = ui.RRect.fromRectAndRadius(
      ui.Rect.fromLTRB(10, 10, 20, 20),
      ui.Radius.circular(3),
    );
    final SkFloat32List skRadii = mallocFloat32List(8);
    final Float32List radii = skRadii.toTypedArray();
    radii[0] = rrect.tlRadiusX;
    radii[1] = rrect.tlRadiusY;
    radii[2] = rrect.trRadiusX;
    radii[3] = rrect.trRadiusY;
    radii[4] = rrect.brRadiusX;
    radii[5] = rrect.brRadiusY;
    radii[6] = rrect.blRadiusX;
    radii[7] = rrect.blRadiusY;
    path.addRoundRect(
      toOuterSkRect(rrect),
      radii,
      false,
    );
    freeFloat32List(skRadii);
  });

  test('addRect', () {
    path.addRect(SkRect(fLeft: 1, fTop: 2, fRight: 3, fBottom: 4));
  });

  test('arcTo', () {
    path.arcTo(
      SkRect(fLeft: 1, fTop: 2, fRight: 3, fBottom: 4),
      5,
      40,
      false,
    );
  });

  test('overloaded arcTo (used for arcToPoint)', () {
    final SkPathArcToPointOverload overload = debugJsObjectWrapper.castToSkPathArcToPointOverload(path);
    overload.arcTo(
      1,
      2,
      3,
      false,
      true,
      4,
      5,
    );
  });

  test('close', () {
    _testClosedSkPath();
  });

  test('conicTo', () {
    path.conicTo(1, 2, 3, 4, 5);
  });

  test('contains', () {
    final SkPath testPath = _testClosedSkPath();
    expect(testPath.contains(15, 15), true);
    expect(testPath.contains(100, 100), false);
  });

  test('cubicTo', () {
    path.cubicTo(1, 2, 3, 4, 5, 6);
  });

  test('getBounds', () {
    final SkPath testPath = _testClosedSkPath();
    final ui.Rect bounds = testPath.getBounds().toRect();
    expect(bounds, const ui.Rect.fromLTRB(10, 10, 20, 20));
  });

  test('lineTo', () {
    path.lineTo(10, 10);
  });

  test('moveTo', () {
    path.moveTo(10, 10);
  });

  test('quadTo', () {
    path.quadTo(10, 10, 20, 20);
  });

  test('rArcTo', () {
    path.rArcTo(
      10,
      20,
      30,
      false,
      true,
      40,
      50,
    );
  });

  test('rConicTo', () {
    path.rConicTo(1, 2, 3, 4, 5);
  });

  test('rCubicTo', () {
    path.rCubicTo(1, 2, 3, 4, 5, 6);
  });

  test('rLineTo', () {
    path.rLineTo(10, 10);
  });

  test('rMoveTo', () {
    path.rMoveTo(10, 10);
  });

  test('rQuadTo', () {
    path.rQuadTo(10, 10, 20, 20);
  });

  test('reset', () {
    final SkPath testPath = _testClosedSkPath();
    expect(testPath.getBounds().toRect(), const ui.Rect.fromLTRB(10, 10, 20, 20));
    testPath.reset();
    expect(testPath.getBounds().toRect(), ui.Rect.zero);
  });

  test('toSVGString', () {
    expect(_testClosedSkPath().toSVGString(), 'M10 10L20 10L20 20L10 20L10 10Z');
  });

  test('isEmpty', () {
    expect(SkPath().isEmpty(), true);
    expect(_testClosedSkPath().isEmpty(), false);
  });

  test('copy', () {
    final SkPath original = _testClosedSkPath();
    final SkPath copy = original.copy();
    expect(original.getBounds().toRect(), copy.getBounds().toRect());
  });

  test('transform', () {
    path = _testClosedSkPath();
    path.transform(2, 0, 10, 0, 2, 10, 0, 0, 0);
    final ui.Rect transformedBounds = path.getBounds().toRect();
    expect(transformedBounds, ui.Rect.fromLTRB(30, 30, 50, 50));
  });

  test('SkContourMeasureIter/SkContourMeasure', () {
    final SkContourMeasureIter iter = SkContourMeasureIter(_testClosedSkPath(), false, 0);
    final SkContourMeasure measure1 = iter.next();
    expect(measure1.length(), 40);
    expect(measure1.getPosTan(5), Float32List.fromList(<double>[15, 10, 1, 0]));
    expect(measure1.getPosTan(15), Float32List.fromList(<double>[20, 15, 0, 1]));
    expect(measure1.isClosed(), true);

    // Starting with a box path:
    //
    //    10         20
    // 10 +-----------+
    //    |           |
    //    |           |
    //    |           |
    //    |           |
    //    |           |
    // 20 +-----------+
    //
    // Cut out the top-right quadrant:
    //
    //    10    15   20
    // 10 +-----+=====+
    //    |     ║+++++║
    //    |     ║+++++║
    //    |     +=====+ 15
    //    |           |
    //    |           |
    // 20 +-----------+
    final SkPath segment = measure1.getSegment(5, 15, true);
    expect(segment.getBounds().toRect(), ui.Rect.fromLTRB(15, 10, 20, 15));

    final SkContourMeasure measure2 = iter.next();
    expect(measure2, isNull);
  });
}

void _skSkRectTests() {
  test('SkRect', () {
    final SkRect rect = SkRect(fLeft: 1, fTop: 2, fRight: 3, fBottom: 4);
    expect(rect.fLeft, 1);
    expect(rect.fTop, 2);
    expect(rect.fRight, 3);
    expect(rect.fBottom, 4);

    final ui.Rect uiRect = rect.toRect();
    expect(uiRect.left, 1);
    expect(uiRect.top, 2);
    expect(uiRect.right, 3);
    expect(uiRect.bottom, 4);
  });
}

SkVertices _testVertices() {
  return canvasKitJs.MakeSkVertices(
    canvasKitJs.VertexMode.Triangles,
    [
      Float32List.fromList([0, 0]),
      Float32List.fromList([10, 10]),
      Float32List.fromList([0, 20]),
    ],
    [
      Float32List.fromList([0, 0]),
      Float32List.fromList([10, 10]),
      Float32List.fromList([0, 20]),
    ],
    [
      Float32List.fromList([255, 0, 0, 255]),
      Float32List.fromList([0, 255, 0, 255]),
      Float32List.fromList([0, 0, 255, 255]),
    ],
    Uint16List.fromList([0, 1, 2]),
  );
}

void _skVerticesTests() {
  test('SkVertices', () {
    expect(_testVertices(), isNotNull);
  });
}

void _canvasTests() {
  SkPictureRecorder recorder;
  SkCanvas canvas;

  setUp(() {
    recorder = SkPictureRecorder();
    canvas = recorder.beginRecording(SkRect(
      fLeft: 0,
      fTop: 0,
      fRight: 100,
      fBottom: 100,
    ));
  });

  tearDown(() {
    expect(recorder.finishRecordingAsPicture(), isNotNull);
  });

  test('save/getSaveCount/restore/restoreToCount', () {
    expect(canvas.save(), 1);
    expect(canvas.save(), 2);
    expect(canvas.save(), 3);
    expect(canvas.save(), 4);
    expect(canvas.getSaveCount(), 5);
    canvas.restoreToCount(2);
    expect(canvas.getSaveCount(), 2);
    canvas.restore();
    expect(canvas.getSaveCount(), 1);
  });

  test('saveLayer', () {
    canvas.saveLayer(
      SkRect(
        fLeft: 0,
        fTop: 0,
        fRight: 100,
        fBottom: 100,
      ),
      SkPaint(),
    );
  });

  test('SkCanvasSaveLayerWithoutBoundsOverride.saveLayer', () {
    final SkCanvasSaveLayerWithoutBoundsOverride override = debugJsObjectWrapper.castToSkCanvasSaveLayerWithoutBoundsOverride(canvas);
    override.saveLayer(SkPaint());
  });

  test('SkCanvasSaveLayerWithFilterOverride.saveLayer', () {
    final SkCanvasSaveLayerWithFilterOverride override = debugJsObjectWrapper.castToSkCanvasSaveLayerWithFilterOverride(canvas);
    override.saveLayer(
      SkPaint(),
      canvasKitJs.SkImageFilter.MakeBlur(1, 2, canvasKitJs.TileMode.Repeat, null),
      0,
      SkRect(
        fLeft: 0,
        fTop: 0,
        fRight: 100,
        fBottom: 100,
      ),
    );
  });

  test('clear', () {
    canvas.clear(Float32List.fromList([0, 0, 0, 0]));
  });

  test('clipPath', () {
    canvas.clipPath(
      _testClosedSkPath(),
      canvasKitJs.ClipOp.Intersect,
      true,
    );
  });

  test('clipRRect', () {
    canvas.clipRRect(
      SkRRect(
        rect: SkRect(
          fLeft: 0,
          fTop: 0,
          fRight: 100,
          fBottom: 100,
        ),
        rx1: 1,
        ry1: 2,
        rx2: 3,
        ry2: 4,
        rx3: 5,
        ry3: 6,
        rx4: 7,
        ry4: 8,
      ),
      canvasKitJs.ClipOp.Intersect,
      true,
    );
  });

  test('clipRect', () {
    canvas.clipRect(
      SkRect(
        fLeft: 0,
        fTop: 0,
        fRight: 100,
        fBottom: 100,
      ),
      canvasKitJs.ClipOp.Intersect,
      true,
    );
  });

  test('drawArc', () {
    canvas.drawArc(
      SkRect(
        fLeft: 0,
        fTop: 0,
        fRight: 100,
        fBottom: 50,
      ),
      0,
      100,
      true,
      SkPaint(),
    );
  });

  test('drawAtlas', () {
    final SkAnimatedImage image = canvasKitJs.MakeAnimatedImageFromEncoded(kTransparentImage);
    canvas.drawAtlas(
      image.getCurrentFrame(),
      Float32List.fromList([0, 0, 1, 1]),
      Float32List.fromList([1, 0, 2, 3]),
      SkPaint(),
      canvasKitJs.BlendMode.SrcOver,
      [
        Float32List.fromList([0, 0, 0, 1]),
        Float32List.fromList([1, 1, 1, 1]),
      ],
    );
  });

  test('drawCircle', () {
    canvas.drawCircle(1, 2, 3, SkPaint());
  });

  test('drawColorInt', () {
    canvas.drawColorInt(0xFFFFFFFF, canvasKitJs.BlendMode.SoftLight);
  });

  test('drawDRRect', () {
    canvas.drawDRRect(
      SkRRect(
        rect: SkRect(
          fLeft: 0,
          fTop: 0,
          fRight: 100,
          fBottom: 100,
        ),
        rx1: 1,
        ry1: 2,
        rx2: 3,
        ry2: 4,
        rx3: 5,
        ry3: 6,
        rx4: 7,
        ry4: 8,
      ),
      SkRRect(
        rect: SkRect(
          fLeft: 20,
          fTop: 20,
          fRight: 80,
          fBottom: 80,
        ),
        rx1: 1,
        ry1: 2,
        rx2: 3,
        ry2: 4,
        rx3: 5,
        ry3: 6,
        rx4: 7,
        ry4: 8,
      ),
      SkPaint(),
    );
  });

  test('drawImage', () {
    final SkAnimatedImage image = canvasKitJs.MakeAnimatedImageFromEncoded(kTransparentImage);
    canvas.drawImage(
      image.getCurrentFrame(),
      10,
      20,
      SkPaint(),
    );
  });

  test('drawImageRect', () {
    final SkAnimatedImage image = canvasKitJs.MakeAnimatedImageFromEncoded(kTransparentImage);
    canvas.drawImageRect(
      image.getCurrentFrame(),
      SkRect(fLeft: 0, fTop: 0, fRight: 1, fBottom: 1),
      SkRect(fLeft: 0, fTop: 0, fRight: 1, fBottom: 1),
      SkPaint(),
      false,
    );
  });

  test('drawImageNine', () {
    final SkAnimatedImage image = canvasKitJs.MakeAnimatedImageFromEncoded(kTransparentImage);
    canvas.drawImageNine(
      image.getCurrentFrame(),
      SkRect(fLeft: 0, fTop: 0, fRight: 1, fBottom: 1),
      SkRect(fLeft: 0, fTop: 0, fRight: 1, fBottom: 1),
      SkPaint(),
    );
  });

  test('drawLine', () {
    canvas.drawLine(0, 1, 2, 3, SkPaint());
  });

  test('drawOval', () {
    canvas.drawOval(SkRect(fLeft: 0, fTop: 0, fRight: 1, fBottom: 1), SkPaint());
  });

  test('drawPaint', () {
    canvas.drawPaint(SkPaint());
  });

  test('drawPath', () {
    canvas.drawPath(
      _testClosedSkPath(),
      SkPaint(),
    );
  });

  test('drawPoints', () {
    canvas.drawPoints(
      canvasKitJs.PointMode.Lines,
      Float32List.fromList([0, 0, 10, 10, 0, 10]),
      SkPaint(),
    );
  });

  test('drawRRect', () {
    canvas.drawRRect(
      SkRRect(
        rect: SkRect(
          fLeft: 0,
          fTop: 0,
          fRight: 100,
          fBottom: 100,
        ),
        rx1: 1,
        ry1: 2,
        rx2: 3,
        ry2: 4,
        rx3: 5,
        ry3: 6,
        rx4: 7,
        ry4: 8,
      ),
      SkPaint(),
    );
  });

  test('drawRect', () {
    canvas.drawRect(
      SkRect(
        fLeft: 0,
        fTop: 0,
        fRight: 100,
        fBottom: 100,
      ),
      SkPaint(),
    );
  });

  test('drawShadow', () {
    for (int flags in const <int>[0x01, 0x00]) {
      const double devicePixelRatio = 2.0;
      const double elevation = 4.0;
      const double ambientAlpha = 0.039;
      const double spotAlpha = 0.25;

      final SkPath path = _testClosedSkPath();
      final ui.Rect bounds = path.getBounds().toRect();
      final double shadowX = (bounds.left + bounds.right) / 2.0;
      final double shadowY = bounds.top - 600.0;

      const ui.Color color = ui.Color(0xAABBCCDD);
      ui.Color inAmbient = color.withAlpha((color.alpha * ambientAlpha).round());
      ui.Color inSpot = color.withAlpha((color.alpha * spotAlpha).round());

      final SkTonalColors inTonalColors = SkTonalColors(
        ambient: makeFreshSkColor(inAmbient),
        spot: makeFreshSkColor(inSpot),
      );

      final SkTonalColors tonalColors =
          canvasKitJs.computeTonalColors(inTonalColors);

      canvas.drawShadow(
        path,
        Float32List(3)
          ..[2] = devicePixelRatio * elevation,
        Float32List(3)
          ..[0] = shadowX
          ..[1] = shadowY
          ..[2] = devicePixelRatio * kLightHeight,
        devicePixelRatio * kLightRadius,
        tonalColors.ambient,
        tonalColors.spot,
        flags,
      );
    }
  });

  test('drawVertices', () {
    canvas.drawVertices(
      _testVertices(),
      canvasKitJs.BlendMode.SrcOver,
      SkPaint(),
    );
  });

  test('rotate', () {
    canvas.rotate(5, 10, 20);
  });

  test('scale', () {
    canvas.scale(2, 3);
  });

  test('skew', () {
    canvas.skew(4, 5);
  });

  test('concat', () {
    canvas.concat(toSkMatrixFromFloat32(Matrix4.identity().storage));
  });

  test('translate', () {
    canvas.translate(4, 5);
  });

  test('flush', () {
    canvas.flush();
  });

  test('drawPicture', () {
    final SkPictureRecorder otherRecorder = SkPictureRecorder();
    final SkCanvas otherCanvas = otherRecorder.beginRecording(SkRect(
      fLeft: 0,
      fTop: 0,
      fRight: 100,
      fBottom: 100,
    ));
    otherCanvas.drawLine(0, 0, 10, 10, SkPaint());
    canvas.drawPicture(otherRecorder.finishRecordingAsPicture());
  });

  test('drawParagraph', () {
    final CkParagraphBuilder builder = CkParagraphBuilder(
      CkParagraphStyle(),
    );
    builder.addText('Hello');
    final CkParagraph paragraph = builder.build();
    paragraph.layout(const ui.ParagraphConstraints(width: 100));
    canvas.drawParagraph(
      debugJsObjectWrapper.unwrapSkParagraph(paragraph.legacySkiaObject),
      10,
      20,
    );
  });
}

final Uint8List kTransparentImage = Uint8List.fromList(<int>[
  0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49,
  0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06,
  0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4, 0x89, 0x00, 0x00, 0x00, 0x0A, 0x49, 0x44,
  0x41, 0x54, 0x78, 0x9C, 0x63, 0x00, 0x01, 0x00, 0x00, 0x05, 0x00, 0x01, 0x0D,
  0x0A, 0x2D, 0xB4, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE,
]);

/// An animated GIF image with 3 1x1 pixel frames (a red, green, and blue
/// frames). The GIF animates forever, and each frame has a 100ms delay.
final Uint8List kAnimatedGif = Uint8List.fromList(<int> [
  0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00, 0xa1, 0x03, 0x00,
  0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x21,
  0xff, 0x0b, 0x4e, 0x45, 0x54, 0x53, 0x43, 0x41, 0x50, 0x45, 0x32, 0x2e, 0x30,
  0x03, 0x01, 0x00, 0x00, 0x00, 0x21, 0xf9, 0x04, 0x00, 0x0a, 0x00, 0xff, 0x00,
  0x2c, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x4c,
  0x01, 0x00, 0x21, 0xf9, 0x04, 0x00, 0x0a, 0x00, 0xff, 0x00, 0x2c, 0x00, 0x00,
  0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x54, 0x01, 0x00, 0x21,
  0xf9, 0x04, 0x00, 0x0a, 0x00, 0xff, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x01,
  0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x44, 0x01, 0x00, 0x3b,
]);