// Copyright 2014 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.

// This file is run as part of a reduced test set in CI on Mac and Windows
// machines.
@Tags(<String>['reduced-test-set'])
library;

import 'dart:math' as math;

import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';

bool _listDoubleMatches(List<double>? x, List<double>? y) {
  if (x == null && y == null) {
    return true;
  }
  if (x == null || y == null) {
    return false;
  }
  if (x.length != y.length) {
    return false;
  }
  for (var i = 0; i < x.length; i++) {
    if ((x[i] - y[i]).abs() >= 0.0001) {
      return false;
    }
  }
  return true;
}

bool _listColorMatches(List<Color> x, List<Color> y) {
  if (x.length != y.length) {
    return false;
  }
  const double limit = 1 / 255;
  for (var i = 0; i < x.length; i++) {
    if ((x[i].a - y[i].a).abs() >= limit ||
        (x[i].r - y[i].r).abs() >= limit ||
        (x[i].g - y[i].g).abs() >= limit ||
        (x[i].b - y[i].b).abs() >= limit) {
      return false;
    }
  }
  return true;
}

class _LinearGradientMatcher extends Matcher {
  _LinearGradientMatcher(this._target);
  final LinearGradient _target;

  @override
  Description describe(Description description) {
    description.add('expected $_target');
    return description;
  }

  @override
  bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
    return item is LinearGradient &&
        item.begin == _target.begin &&
        item.end == _target.end &&
        item.tileMode == _target.tileMode &&
        item.transform == _target.transform &&
        _listColorMatches(item.colors, _target.colors) &&
        _listDoubleMatches(item.stops, _target.stops);
  }
}

Matcher _matchesLinearGradient(LinearGradient target) => _LinearGradientMatcher(target);

class _RadialGradientMatcher extends Matcher {
  _RadialGradientMatcher(this._target);
  final RadialGradient _target;

  @override
  Description describe(Description description) {
    description.add('expected $_target');
    return description;
  }

  @override
  bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
    if (item is RadialGradient) {
      return item.center == _target.center &&
          item.radius == _target.radius &&
          item.tileMode == _target.tileMode &&
          item.transform == _target.transform &&
          item.focal == _target.focal &&
          item.focalRadius == _target.focalRadius &&
          _listColorMatches(item.colors, _target.colors) &&
          _listDoubleMatches(item.stops, _target.stops);
    } else {
      return false;
    }
  }
}

Matcher _matchesRadialGradient(RadialGradient target) => _RadialGradientMatcher(target);

class _SweepGradientMatcher extends Matcher {
  _SweepGradientMatcher(this._target);
  final SweepGradient _target;

  @override
  Description describe(Description description) {
    description.add('expected $_target');
    return description;
  }

  @override
  bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
    if (item is SweepGradient) {
      return item.center == _target.center &&
          item.startAngle == _target.startAngle &&
          item.endAngle == _target.endAngle &&
          item.tileMode == _target.tileMode &&
          item.transform == _target.transform &&
          _listColorMatches(item.colors, _target.colors) &&
          _listDoubleMatches(item.stops, _target.stops);
    } else {
      return false;
    }
  }
}

Matcher _matchesSweepGradient(SweepGradient target) => _SweepGradientMatcher(target);

void main() {
  test('LinearGradient scale test', () {
    const testGradient = LinearGradient(
      begin: Alignment.bottomRight,
      end: Alignment(0.7, 1.0),
      colors: <Color>[Color(0x00FFFFFF), Color(0x11777777), Color(0x44444444)],
    );
    final LinearGradient? actual = LinearGradient.lerp(null, testGradient, 0.25);

    expect(
      actual,
      _matchesLinearGradient(
        const LinearGradient(
          begin: Alignment.bottomRight,
          end: Alignment(0.7, 1.0),
          colors: <Color>[Color(0x00FFFFFF), Color(0x04777777), Color(0x11444444)],
        ),
      ),
    );
  });

  test('LinearGradient lerp test', () {
    const testGradient1 = LinearGradient(
      begin: Alignment.topLeft,
      end: Alignment.bottomLeft,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );
    const testGradient2 = LinearGradient(
      begin: Alignment.topRight,
      end: Alignment.topLeft,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
    );

    final LinearGradient? actual = LinearGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesLinearGradient(
        const LinearGradient(
          begin: Alignment.topCenter,
          end: Alignment.centerLeft,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x77777777)],
          stops: <double>[0, 1],
        ),
      ),
    );
  });

  test('LinearGradient.lerp identical a,b', () {
    expect(LinearGradient.lerp(null, null, 0), null);
    const gradient = LinearGradient(colors: <Color>[Color(0x33333333), Color(0x66666666)]);
    expect(identical(LinearGradient.lerp(gradient, gradient, 0.5), gradient), true);
  });

  test('LinearGradient lerp test with stops', () {
    const testGradient1 = LinearGradient(
      begin: Alignment.topLeft,
      end: Alignment.bottomLeft,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0.0, 0.5],
    );
    const testGradient2 = LinearGradient(
      begin: Alignment.topRight,
      end: Alignment.topLeft,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
      stops: <double>[0.5, 1.0],
    );

    final LinearGradient? actual = LinearGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesLinearGradient(
        const LinearGradient(
          begin: Alignment.topCenter,
          end: Alignment.centerLeft,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x55555555), Color(0x77777777)],
          stops: <double>[0.0, 0.5, 1.0],
        ),
      ),
    );
  });

  test('LinearGradient lerp test with unequal number of colors', () {
    const testGradient1 = LinearGradient(colors: <Color>[Color(0x22222222), Color(0x66666666)]);
    const testGradient2 = LinearGradient(
      colors: <Color>[Color(0x44444444), Color(0x66666666), Color(0x88888888)],
    );

    final LinearGradient? actual = LinearGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesLinearGradient(
        const LinearGradient(
          colors: <Color>[Color(0x33333333), Color(0x55555555), Color(0x77777777)],
          stops: <double>[0.0, 0.5, 1.0],
        ),
      ),
    );
  });

  test('LinearGradient lerp test with stops and unequal number of colors', () {
    const testGradient1 = LinearGradient(
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0.0, 0.5],
    );
    const testGradient2 = LinearGradient(
      colors: <Color>[Color(0x44444444), Color(0x48484848), Color(0x88888888)],
      stops: <double>[0.5, 0.7, 1.0],
    );

    final LinearGradient? actual = LinearGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesLinearGradient(
        const LinearGradient(
          colors: <Color>[
            Color(0x3B3B3B3B),
            Color(0x55555555),
            Color(0x57575757),
            Color(0x77777777),
          ],
          stops: <double>[0.0, 0.5, 0.7, 1.0],
        ),
      ),
    );
  });

  test('LinearGradient lerp test with transforms', () {
    const testGradient1 = LinearGradient(
      transform: GradientRotation(math.pi / 4),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0, 1],
    );
    const testGradient2 = LinearGradient(
      transform: GradientRotation(math.pi / 2),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0, 1],
    );

    final LinearGradient? actual0 = LinearGradient.lerp(testGradient1, testGradient2, 0.0);
    final LinearGradient? actual1 = LinearGradient.lerp(testGradient1, testGradient2, 1.0);
    final LinearGradient? actual2 = LinearGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(testGradient1, equals(actual0));
    expect(testGradient2, equals(actual1));
    expect(testGradient2, equals(actual2));
  });

  test('LinearGradient toString', () {
    expect(
      const LinearGradient(
        begin: Alignment.topLeft,
        end: Alignment.bottomLeft,
        transform: GradientRotation(1.6),
        colors: <Color>[Color(0x33333333), Color(0x66666666)],
      ).toString(),
      equals(
        'LinearGradient(begin: Alignment.topLeft, end: Alignment.bottomLeft, colors: [${const Color(0x33333333)}, ${const Color(0x66666666)}], tileMode: TileMode.clamp, transform: GradientRotation(radians: 1.6))',
      ),
    );
  });

  test('LinearGradient with different transforms', () {
    const testGradient1 = LinearGradient(
      transform: GradientRotation(math.pi / 4),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );
    const testGradient1Copy = LinearGradient(
      transform: GradientRotation(math.pi / 4),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );
    const testGradient2 = LinearGradient(
      transform: GradientRotation(math.pi / 2),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );

    expect(testGradient1, equals(testGradient1Copy));
    expect(testGradient1, isNot(equals(testGradient2)));
  });

  test('LinearGradient with AlignmentDirectional', () {
    expect(() {
      return const LinearGradient(
        begin: AlignmentDirectional.topStart,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0));
    }, throwsAssertionError);
    expect(() {
      return const LinearGradient(
        begin: AlignmentDirectional.topStart,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0), textDirection: TextDirection.rtl);
    }, returnsNormally);
    expect(() {
      return const LinearGradient(
        begin: AlignmentDirectional.topStart,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0), textDirection: TextDirection.ltr);
    }, returnsNormally);
    expect(() {
      return const LinearGradient(
        begin: Alignment.topLeft,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0));
    }, returnsNormally);
  });

  test('LinearGradient withOpacity test', () {
    const testGradient = LinearGradient(
      begin: Alignment.bottomRight,
      end: Alignment.topCenter,
      colors: <Color>[Color(0xFFFFFFFF), Color(0xAF777777), Color(0x44444444)],
    );
    final LinearGradient actual = testGradient.withOpacity(0.5);

    expect(
      actual,
      const LinearGradient(
        begin: Alignment.bottomRight,
        end: Alignment.topCenter,
        colors: <Color>[Color(0x80FFFFFF), Color(0x80777777), Color(0x80444444)],
      ),
    );
  });

  test('LinearGradient withOpacity() preserves transform', () {
    const testGradient = LinearGradient(
      begin: Alignment.bottomRight,
      end: Alignment.topCenter,
      colors: <Color>[Color(0xFFFFFFFF), Color(0xAF777777), Color(0x44444444)],
      transform: GradientRotation(1),
    );
    final LinearGradient actual = testGradient.withOpacity(0.5);

    expect(
      actual,
      const LinearGradient(
        begin: Alignment.bottomRight,
        end: Alignment.topCenter,
        colors: <Color>[Color(0x80FFFFFF), Color(0x80777777), Color(0x80444444)],
        transform: GradientRotation(1),
      ),
    );
  });

  test('LinearGradient.scale preserves transform', () {
    const testGradient = LinearGradient(
      begin: Alignment.bottomRight,
      end: Alignment.topLeft,
      stops: [0, 0.5, 1],
      colors: <Color>[Color(0xFFFF0000), Color(0xFF00FF00), Color(0xFF0000FF)],
      tileMode: TileMode.decal,
      transform: GradientRotation(math.pi / 4),
    );
    final LinearGradient actual = testGradient.scale(0.5);

    expect(
      actual,
      _matchesLinearGradient(
        const LinearGradient(
          begin: Alignment.bottomRight,
          end: Alignment.topLeft,
          stops: [0, 0.5, 1],
          colors: <Color>[Color(0x80FF0000), Color(0x8000FF00), Color(0x800000FF)],
          tileMode: TileMode.decal,
          transform: GradientRotation(math.pi / 4),
        ),
      ),
    );
  });

  test('RadialGradient with AlignmentDirectional', () {
    expect(() {
      return const RadialGradient(
        center: AlignmentDirectional.topStart,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0));
    }, throwsAssertionError);

    expect(() {
      return const RadialGradient(
        center: AlignmentDirectional.topStart,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0), textDirection: TextDirection.rtl);
    }, returnsNormally);
    expect(() {
      return const RadialGradient(
        center: AlignmentDirectional.topStart,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0), textDirection: TextDirection.ltr);
    }, returnsNormally);
    expect(() {
      return const RadialGradient(
        center: Alignment.topLeft,
        colors: <Color>[Color(0xFFFFFFFF), Color(0xFFFFFFFF)],
      ).createShader(const Rect.fromLTWH(0.0, 0.0, 100.0, 100.0));
    }, returnsNormally);
  });

  test('RadialGradient lerp test', () {
    const testGradient1 = RadialGradient(
      center: Alignment.topLeft,
      radius: 20.0,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );
    const testGradient2 = RadialGradient(
      center: Alignment.topRight,
      radius: 10.0,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
    );

    final RadialGradient? actual = RadialGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesRadialGradient(
        const RadialGradient(
          center: Alignment.topCenter,
          radius: 15.0,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x77777777)],
          stops: <double>[0.0, 1.0],
        ),
      ),
    );
  });

  test('RadialGradient.lerp identical a,b', () {
    expect(RadialGradient.lerp(null, null, 0), null);
    const gradient = RadialGradient(colors: <Color>[Color(0x33333333), Color(0x66666666)]);
    expect(identical(RadialGradient.lerp(gradient, gradient, 0.5), gradient), true);
  });

  test('RadialGradient lerp test with stops', () {
    const testGradient1 = RadialGradient(
      center: Alignment.topLeft,
      radius: 20.0,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0.0, 0.5],
    );
    const testGradient2 = RadialGradient(
      center: Alignment.topRight,
      radius: 10.0,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
      stops: <double>[0.5, 1.0],
    );

    final RadialGradient? actual = RadialGradient.lerp(testGradient1, testGradient2, 0.5);

    expect(
      actual,
      _matchesRadialGradient(
        const RadialGradient(
          center: Alignment.topCenter,
          radius: 15.0,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x55555555), Color(0x77777777)],
          stops: <double>[0.0, 0.5, 1.0],
        ),
      ),
    );

    expect(actual!.focal, isNull);
  });

  test('RadialGradient lerp test with unequal number of colors', () {
    const testGradient1 = RadialGradient(colors: <Color>[Color(0x22222222), Color(0x66666666)]);
    const testGradient2 = RadialGradient(
      colors: <Color>[Color(0x44444444), Color(0x66666666), Color(0x88888888)],
    );

    final RadialGradient? actual = RadialGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesRadialGradient(
        const RadialGradient(
          colors: <Color>[Color(0x33333333), Color(0x55555555), Color(0x77777777)],
          stops: <double>[0.0, 0.5, 1.0],
        ),
      ),
    );
  });

  test('RadialGradient lerp test with stops and unequal number of colors', () {
    const testGradient1 = RadialGradient(
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0.0, 0.5],
    );
    const testGradient2 = RadialGradient(
      colors: <Color>[Color(0x44444444), Color(0x48484848), Color(0x88888888)],
      stops: <double>[0.5, 0.7, 1.0],
    );

    final RadialGradient? actual = RadialGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesRadialGradient(
        const RadialGradient(
          colors: <Color>[
            Color(0x3B3B3B3B),
            Color(0x55555555),
            Color(0x57575757),
            Color(0x77777777),
          ],
          stops: <double>[0.0, 0.5, 0.7, 1.0],
        ),
      ),
    );
  });

  test('RadialGradient lerp test with transforms', () {
    const testGradient1 = RadialGradient(
      transform: GradientRotation(math.pi / 4),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0, 1],
    );
    const testGradient2 = RadialGradient(
      transform: GradientRotation(math.pi / 2),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0, 1],
    );

    final RadialGradient? actual0 = RadialGradient.lerp(testGradient1, testGradient2, 0.0);
    final RadialGradient? actual1 = RadialGradient.lerp(testGradient1, testGradient2, 1.0);
    final RadialGradient? actual2 = RadialGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(testGradient1, equals(actual0));
    expect(testGradient2, equals(actual1));
    expect(testGradient2, equals(actual2));
  });

  test('RadialGradient lerp test with focal', () {
    const testGradient1 = RadialGradient(
      center: Alignment.topLeft,
      focal: Alignment.centerLeft,
      radius: 20.0,
      focalRadius: 10.0,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );
    const testGradient2 = RadialGradient(
      center: Alignment.topRight,
      focal: Alignment.centerRight,
      radius: 10.0,
      focalRadius: 5.0,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
    );
    const testGradient3 = RadialGradient(
      center: Alignment.topRight,
      radius: 10.0,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
    );

    final RadialGradient? actual = RadialGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesRadialGradient(
        const RadialGradient(
          center: Alignment.topCenter,
          focal: Alignment.center,
          radius: 15.0,
          focalRadius: 7.5,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x77777777)],
          stops: <double>[0.0, 1.0],
        ),
      ),
    );

    final RadialGradient? actual2 = RadialGradient.lerp(testGradient1, testGradient3, 0.5);
    expect(
      actual2,
      _matchesRadialGradient(
        const RadialGradient(
          center: Alignment.topCenter,
          focal: Alignment(-0.5, 0.0),
          radius: 15.0,
          focalRadius: 5.0,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x77777777)],
          stops: <double>[0.0, 1.0],
        ),
      ),
    );
  });

  test('RadialGradient withOpacity test', () {
    const testGradient = RadialGradient(
      center: Alignment.topLeft,
      focal: Alignment.centerLeft,
      radius: 20.0,
      focalRadius: 10.0,
      colors: <Color>[Color(0xFFFFFFFF), Color(0xAF777777), Color(0x44444444)],
    );
    final RadialGradient actual = testGradient.withOpacity(0.5);

    expect(
      actual,
      const RadialGradient(
        center: Alignment.topLeft,
        focal: Alignment.centerLeft,
        radius: 20.0,
        focalRadius: 10.0,
        colors: <Color>[Color(0x80FFFFFF), Color(0x80777777), Color(0x80444444)],
      ),
    );
  });

  test('RadialGradient withOpacity() preserves transform', () {
    const testGradient = RadialGradient(
      center: Alignment.topLeft,
      focal: Alignment.centerLeft,
      radius: 20.0,
      focalRadius: 10.0,
      colors: <Color>[Color(0xFFFFFFFF), Color(0xAF777777), Color(0x44444444)],
      transform: GradientRotation(1),
    );
    final RadialGradient actual = testGradient.withOpacity(0.5);

    expect(
      actual,
      const RadialGradient(
        center: Alignment.topLeft,
        focal: Alignment.centerLeft,
        radius: 20.0,
        focalRadius: 10.0,
        colors: <Color>[Color(0x80FFFFFF), Color(0x80777777), Color(0x80444444)],
        transform: GradientRotation(1),
      ),
    );
  });

  test('RadialGradient.scale preserves transform', () {
    const testGradient = RadialGradient(
      center: Alignment.topLeft,
      focal: Alignment.centerLeft,
      radius: 20.0,
      focalRadius: 10.0,
      stops: [0, 0.5, 1],
      colors: <Color>[Color(0xFFFF0000), Color(0xFF00FF00), Color(0xFF0000FF)],
      tileMode: TileMode.decal,
      transform: GradientRotation(math.pi / 4),
    );
    final RadialGradient actual = testGradient.scale(0.5);

    expect(
      actual,
      _matchesRadialGradient(
        const RadialGradient(
          center: Alignment.topLeft,
          focal: Alignment.centerLeft,
          radius: 20.0,
          focalRadius: 10.0,
          stops: [0, 0.5, 1],
          colors: <Color>[Color(0x80FF0000), Color(0x8000FF00), Color(0x800000FF)],
          tileMode: TileMode.decal,
          transform: GradientRotation(math.pi / 4),
        ),
      ),
    );
  });

  test('SweepGradient lerp test', () {
    const testGradient1 = SweepGradient(
      center: Alignment.topLeft,
      endAngle: math.pi / 2,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );
    const testGradient2 = SweepGradient(
      center: Alignment.topRight,
      startAngle: math.pi / 2,
      endAngle: math.pi,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
    );

    final SweepGradient? actual = SweepGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesSweepGradient(
        const SweepGradient(
          center: Alignment.topCenter,
          startAngle: math.pi / 4,
          endAngle: math.pi * 3 / 4,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x77777777)],
          stops: <double>[0.0, 1.0],
        ),
      ),
    );
  });

  test('SweepGradient.lerp identical a,b', () {
    expect(SweepGradient.lerp(null, null, 0), null);
    const gradient = SweepGradient(colors: <Color>[Color(0x33333333), Color(0x66666666)]);
    expect(identical(SweepGradient.lerp(gradient, gradient, 0.5), gradient), true);
  });

  test('SweepGradient lerp test with stops', () {
    const testGradient1 = SweepGradient(
      center: Alignment.topLeft,
      endAngle: math.pi / 2,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0.0, 0.5],
    );
    const testGradient2 = SweepGradient(
      center: Alignment.topRight,
      startAngle: math.pi / 2,
      endAngle: math.pi,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
      stops: <double>[0.5, 1.0],
    );

    final SweepGradient? actual = SweepGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesSweepGradient(
        const SweepGradient(
          center: Alignment.topCenter,
          startAngle: math.pi / 4,
          endAngle: math.pi * 3 / 4,
          colors: <Color>[Color(0x3B3B3B3B), Color(0x55555555), Color(0x77777777)],
          stops: <double>[0.0, 0.5, 1.0],
        ),
      ),
    );
  });

  test('SweepGradient lerp test with unequal number of colors', () {
    const testGradient1 = SweepGradient(colors: <Color>[Color(0x22222222), Color(0x66666666)]);
    const testGradient2 = SweepGradient(
      colors: <Color>[Color(0x44444444), Color(0x66666666), Color(0x88888888)],
    );

    final SweepGradient? actual = SweepGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesSweepGradient(
        const SweepGradient(
          colors: <Color>[Color(0x33333333), Color(0x55555555), Color(0x77777777)],
          stops: <double>[0.0, 0.5, 1.0],
        ),
      ),
    );
  });

  test('SweepGradient lerp test with stops and unequal number of colors', () {
    const testGradient1 = SweepGradient(
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0.0, 0.5],
    );
    const testGradient2 = SweepGradient(
      colors: <Color>[Color(0x44444444), Color(0x48484848), Color(0x88888888)],
      stops: <double>[0.5, 0.7, 1.0],
    );

    final SweepGradient? actual = SweepGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(
      actual,
      _matchesSweepGradient(
        const SweepGradient(
          colors: <Color>[
            Color(0x3B3B3B3B),
            Color(0x55555555),
            Color(0x57575757),
            Color(0x77777777),
          ],
          stops: <double>[0.0, 0.5, 0.7, 1.0],
        ),
      ),
    );
  });

  test('SweepGradient lerp test with transforms', () {
    const testGradient1 = SweepGradient(
      transform: GradientRotation(math.pi / 4),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0, 1],
    );
    const testGradient2 = SweepGradient(
      transform: GradientRotation(math.pi / 2),
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0, 1],
    );

    final SweepGradient? actual0 = SweepGradient.lerp(testGradient1, testGradient2, 0.0);
    final SweepGradient? actual1 = SweepGradient.lerp(testGradient1, testGradient2, 1.0);
    final SweepGradient? actual2 = SweepGradient.lerp(testGradient1, testGradient2, 0.5);
    expect(testGradient1, equals(actual0));
    expect(testGradient2, equals(actual1));
    expect(testGradient2, equals(actual2));
  });

  test('SweepGradient scale test)', () {
    const testGradient = SweepGradient(
      center: Alignment.topLeft,
      endAngle: math.pi / 2,
      colors: <Color>[Color(0xff333333), Color(0xff666666)],
    );

    final SweepGradient actual = testGradient.scale(0.5);

    expect(
      actual,
      _matchesSweepGradient(
        const SweepGradient(
          center: Alignment.topLeft,
          endAngle: math.pi / 2,
          colors: <Color>[Color(0x80333333), Color(0x80666666)],
        ),
      ),
    );
  });

  test('SweepGradient withOpacity test', () {
    const testGradient = SweepGradient(
      center: Alignment.topLeft,
      endAngle: math.pi / 2,
      colors: <Color>[Color(0xFFFFFFFF), Color(0xAF777777), Color(0x44444444)],
    );
    final SweepGradient actual = testGradient.withOpacity(0.5);

    expect(
      actual,
      const SweepGradient(
        center: Alignment.topLeft,
        endAngle: math.pi / 2,
        colors: <Color>[Color(0x80FFFFFF), Color(0x80777777), Color(0x80444444)],
      ),
    );
  });

  test('SweepGradient withOpacity() preserves transform', () {
    const testGradient = SweepGradient(
      center: Alignment.topLeft,
      endAngle: math.pi / 2,
      colors: <Color>[Color(0xFFFFFFFF), Color(0xAF777777), Color(0x44444444)],
      transform: GradientRotation(1),
    );
    final SweepGradient actual = testGradient.withOpacity(0.5);

    expect(
      actual,
      const SweepGradient(
        center: Alignment.topLeft,
        endAngle: math.pi / 2,
        colors: <Color>[Color(0x80FFFFFF), Color(0x80777777), Color(0x80444444)],
        transform: GradientRotation(1),
      ),
    );
  });

  test('SweepGradient.scale preserves transform', () {
    const testGradient = SweepGradient(
      center: Alignment.topLeft,
      startAngle: math.pi / 4,
      endAngle: math.pi * 3 / 4,
      stops: [0, 0.5, 1],
      colors: <Color>[Color(0xFFFF0000), Color(0xFF00FF00), Color(0xFF0000FF)],
      tileMode: TileMode.decal,
      transform: GradientRotation(math.pi / 4),
    );
    final SweepGradient actual = testGradient.scale(0.5);

    expect(
      actual,
      _matchesSweepGradient(
        const SweepGradient(
          center: Alignment.topLeft,
          startAngle: math.pi / 4,
          endAngle: math.pi * 3 / 4,
          stops: [0, 0.5, 1],
          colors: <Color>[Color(0x80FF0000), Color(0x8000FF00), Color(0x800000FF)],
          tileMode: TileMode.decal,
          transform: GradientRotation(math.pi / 4),
        ),
      ),
    );
  });

  test('Gradient lerp test (with RadialGradient)', () {
    const testGradient1 = RadialGradient(
      center: Alignment.topLeft,
      radius: 20.0,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
      stops: <double>[0.0, 1.0],
    );
    const testGradient2 = RadialGradient(
      center: Alignment.topCenter,
      radius: 15.0,
      colors: <Color>[Color(0x3B3B3B3B), Color(0x77777777)],
      stops: <double>[0.0, 1.0],
    );
    const testGradient3 = RadialGradient(
      center: Alignment.topRight,
      radius: 10.0,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
      stops: <double>[0.0, 1.0],
    );

    expect(Gradient.lerp(testGradient1, testGradient3, 0.0), _matchesRadialGradient(testGradient1));
    expect(Gradient.lerp(testGradient1, testGradient3, 0.5), _matchesRadialGradient(testGradient2));
    expect(Gradient.lerp(testGradient1, testGradient3, 1.0), _matchesRadialGradient(testGradient3));
    expect(Gradient.lerp(testGradient3, testGradient1, 0.0), _matchesRadialGradient(testGradient3));
    expect(Gradient.lerp(testGradient3, testGradient1, 0.5), _matchesRadialGradient(testGradient2));
    expect(Gradient.lerp(testGradient3, testGradient1, 1.0), _matchesRadialGradient(testGradient1));
  });

  test('Gradient lerp test (LinearGradient to RadialGradient)', () {
    const testGradient1 = LinearGradient(
      begin: Alignment.topLeft,
      end: Alignment.bottomRight,
      colors: <Color>[Color(0x33333333), Color(0x66666666)],
    );
    const testGradient2 = RadialGradient(
      radius: 20.0,
      colors: <Color>[Color(0x44444444), Color(0x88888888)],
    );

    expect(Gradient.lerp(testGradient1, testGradient2, 0.0), testGradient1);
    expect(Gradient.lerp(testGradient1, testGradient2, 1.0), testGradient2);
    expect(Gradient.lerp(testGradient1, testGradient2, 0.5), testGradient2.scale(0.0));
  });

  test('Gradients can handle missing stops and report mismatched stops', () {
    const test1a = LinearGradient(
      colors: <Color>[Color(0x11111111), Color(0x22222222), Color(0x33333333)],
    );
    const test1b = RadialGradient(
      colors: <Color>[Color(0x11111111), Color(0x22222222), Color(0x33333333)],
    );
    const test2a = LinearGradient(
      colors: <Color>[Color(0x11111111), Color(0x22222222), Color(0x33333333)],
      stops: <double>[0.0, 1.0],
    );
    const test2b = RadialGradient(
      colors: <Color>[Color(0x11111111), Color(0x22222222), Color(0x33333333)],
      stops: <double>[0.0, 1.0],
    );
    const rect = Rect.fromLTWH(1.0, 2.0, 3.0, 4.0);
    expect(test1a.createShader(rect), isNotNull);
    expect(test1b.createShader(rect), isNotNull);
    expect(() {
      test2a.createShader(rect);
    }, throwsArgumentError);
    expect(() {
      test2b.createShader(rect);
    }, throwsArgumentError);
  });

  group('Transforms', () {
    const colors = <Color>[Color(0xFFFFFFFF), Color(0xFF000088)];
    const rect = Rect.fromLTWH(0.0, 0.0, 300.0, 400.0);
    const gradients45 = <Gradient>[
      LinearGradient(colors: colors, transform: GradientRotation(math.pi / 4)),
      // A radial gradient won't be interesting to rotate unless the center is changed.
      RadialGradient(
        colors: colors,
        center: Alignment.topCenter,
        transform: GradientRotation(math.pi / 4),
      ),
      SweepGradient(colors: colors, transform: GradientRotation(math.pi / 4)),
    ];
    const gradients90 = <Gradient>[
      LinearGradient(colors: colors, transform: GradientRotation(math.pi / 2)),
      // A radial gradient won't be interesting to rotate unless the center is changed.
      RadialGradient(
        colors: colors,
        center: Alignment.topCenter,
        transform: GradientRotation(math.pi / 2),
      ),
      SweepGradient(colors: colors, transform: GradientRotation(math.pi / 2)),
    ];

    const gradientSnakeCase = <Type, String>{
      LinearGradient: 'linear_gradient',
      RadialGradient: 'radial_gradient',
      SweepGradient: 'sweep_gradient',
    };

    Future<void> runTest(WidgetTester tester, Gradient gradient, double degrees) async {
      final goldenName = '${gradientSnakeCase[gradient.runtimeType]}_$degrees.png';
      final Shader shader = gradient.createShader(rect);
      final Key painterKey = UniqueKey();
      await tester.pumpWidget(
        Center(
          child: SizedBox.fromSize(
            size: rect.size,
            child: RepaintBoundary(
              key: painterKey,
              child: CustomPaint(painter: GradientPainter(shader, rect)),
            ),
          ),
        ),
      );
      await expectLater(find.byKey(painterKey), matchesGoldenFile(goldenName));
    }

    group('Gradients - 45 degrees', () {
      for (final gradient in gradients45) {
        testWidgets('$gradient', (WidgetTester tester) async {
          await runTest(tester, gradient, 45);
        });
      }
    });

    group('Gradients - 90 degrees', () {
      for (final gradient in gradients90) {
        testWidgets('$gradient', (WidgetTester tester) async {
          await runTest(tester, gradient, 90);
        });
      }
    });
  });
}

class GradientPainter extends CustomPainter {
  const GradientPainter(this.shader, this.rect);

  final Shader shader;
  final Rect rect;

  @override
  void paint(Canvas canvas, Size size) {
    canvas.drawRect(rect, Paint()..shader = shader);
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => true;
}