dev/tools/vitool/test/vitool_test.dart - mirrors/flutter - Git at Google

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

 import 'dart:math';

 import 'package:collection/collection.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:path/path.dart' as path;
 import 'package:vitool/vitool.dart';

 void main() {

   test('parsePixels', () {
     expect(parsePixels('23px'), 23);
     expect(parsePixels('9px'), 9);
     expect(() { parsePixels('9pt'); }, throwsArgumentError);
   });

   test('parsePoints', () {
     expect(parsePoints('1.0, 2.0'),
         const <Point<double>>[Point<double>(1.0, 2.0)],
     );
     expect(parsePoints('12.0, 34.0 5.0, 6.6'),
         const <Point<double>>[
           Point<double>(12.0, 34.0),
           Point<double>(5.0, 6.6),
         ],
     );
     expect(parsePoints('12.0 34.0 5.0 6.6'),
         const <Point<double>>[
           Point<double>(12.0, 34.0),
           Point<double>(5.0, 6.6),
         ],
     );
   });

   group('parseSvg', () {
     test('empty SVGs', () {
       interpretSvg(testAsset('empty_svg_1_48x48.svg'));
       interpretSvg(testAsset('empty_svg_2_100x50.svg'));
     });

     test('illegal SVGs', () {
       expect(
         () { interpretSvg(testAsset('illegal_svg_multiple_roots.svg')); },
         throwsA(anything),
       );
     });

     test('SVG size', () {
       expect(
           interpretSvg(testAsset('empty_svg_1_48x48.svg')).size,
           const Point<double>(48.0, 48.0),
       );

       expect(
           interpretSvg(testAsset('empty_svg_2_100x50.svg')).size,
           const Point<double>(100.0, 50.0),
       );
     });

     test('horizontal bar', () {
       final FrameData frameData = interpretSvg(testAsset('horizontal_bar.svg'));
       expect(frameData.paths, <SvgPath>[
         const SvgPath('path_1', <SvgPathCommand>[
           SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
           SvgPathCommand('Z', <Point<double>>[]),
         ]),
       ]);
     });

     test('leading space path command', () {
       interpretSvg(testAsset('leading_space_path_command.svg'));
     });

     test('SVG illegal path', () {
       expect(
         () { interpretSvg(testAsset('illegal_path.svg')); },
         throwsA(anything),
       );
     });


     test('SVG group', () {
       final FrameData frameData = interpretSvg(testAsset('bars_group.svg'));
       expect(frameData.paths, const <SvgPath>[
         SvgPath('path_1', <SvgPathCommand>[
           SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
           SvgPathCommand('Z', <Point<double>>[]),
         ]),
         SvgPath('path_2', <SvgPathCommand>[
           SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 34.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 34.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 44.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 44.0)]),
           SvgPathCommand('Z', <Point<double>>[]),
         ]),
       ]);
     });

     test('SVG group translate', () {
       final FrameData frameData = interpretSvg(testAsset('bar_group_translate.svg'));
       expect(frameData.paths, const <SvgPath>[
         SvgPath('path_1', <SvgPathCommand>[
           SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 34.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 34.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 44.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 44.0)]),
           SvgPathCommand('Z', <Point<double>>[]),
         ]),
       ]);
     });

     test('SVG group scale', () {
       final FrameData frameData = interpretSvg(testAsset('bar_group_scale.svg'));
       expect(frameData.paths, const <SvgPath>[
         SvgPath(
             'path_1', <SvgPathCommand>[
           SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 9.5)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(24.0, 9.5)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(24.0, 14.5)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 14.5)]),
           SvgPathCommand('Z', <Point<double>>[]),
         ]),
       ]);
     });

     test('SVG group rotate scale', () {
       final FrameData frameData = interpretSvg(testAsset('bar_group_rotate_scale.svg'));
       expect(frameData.paths, const <PathMatcher>[
         PathMatcher(
             SvgPath(
                 'path_1', <SvgPathCommand>[
               SvgPathCommand('L', <Point<double>>[Point<double>(29.0, 0.0)]),
               SvgPathCommand('L', <Point<double>>[Point<double>(29.0, 48.0)]),
               SvgPathCommand('L', <Point<double>>[Point<double>(19.0, 48.0)]),
               SvgPathCommand('M', <Point<double>>[Point<double>(19.0, 0.0)]),
               SvgPathCommand('Z', <Point<double>>[]),
             ]),
             margin: precisionErrorTolerance,
         ),
       ]);
     });

     test('SVG illegal transform', () {
       expect(
         () { interpretSvg(testAsset('illegal_transform.svg')); },
         throwsA(anything),
       );
     });

     test('SVG group opacity', () {
       final FrameData frameData = interpretSvg(testAsset('bar_group_opacity.svg'));
       expect(frameData.paths, const <SvgPath>[
         SvgPath(
           'path_1',
           <SvgPathCommand>[
             SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
             SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
             SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
             SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
             SvgPathCommand('Z', <Point<double>>[]),
           ],
           opacity: 0.5,
         ),
       ]);
     });

     test('horizontal bar relative', () {
       // This asset uses the relative 'l' command instead of 'L'.
       final FrameData frameData = interpretSvg(testAsset('horizontal_bar_relative.svg'));
       expect(frameData.paths, const <SvgPath>[
         SvgPath(
             'path_1', <SvgPathCommand>[
           SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
           SvgPathCommand('Z', <Point<double>>[]),
         ]),
       ]);
     });

     test('close in middle of path', () {
       // This asset uses the relative 'l' command instead of 'L'.
       final FrameData frameData = interpretSvg(testAsset('close_path_in_middle.svg'));
       expect(frameData.paths, const <SvgPath>[
         SvgPath(
             'path_1', <SvgPathCommand>[
           SvgPathCommand('M', <Point<double>>[Point<double>(50.0, 50.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(60.0, 50.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(60.0, 60.0)]),
           SvgPathCommand('Z', <Point<double>>[]),
           SvgPathCommand('L', <Point<double>>[Point<double>(50.0, 40.0)]),
           SvgPathCommand('L', <Point<double>>[Point<double>(40.0, 40.0)]),
           SvgPathCommand('Z', <Point<double>>[]),
         ]),
       ]);
     });
   });

   group('create PathAnimation', () {
     test('single path', () {
       const List<FrameData> frameData = <FrameData>[
         FrameData(
           Point<double>(10.0, 10.0),
           <SvgPath>[
             SvgPath(
               'path_1',
               <SvgPathCommand>[
                 SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
                 SvgPathCommand('L', <Point<double>>[Point<double>(10.0, 10.0)]),
               ],
             ),
           ],
         ),
       ];
       expect(PathAnimation.fromFrameData(frameData, 0),
           const PathAnimationMatcher(PathAnimation(
               <PathCommandAnimation>[
                 PathCommandAnimation('M', <List<Point<double>>>[
                   <Point<double>>[Point<double>(0.0, 0.0)],
                 ]),
                 PathCommandAnimation('L', <List<Point<double>>>[
                   <Point<double>>[Point<double>(10.0, 10.0)],
                 ]),
               ],
               opacities: <double>[1.0],
           )),
       );
     });

     test('multiple paths', () {
       const List<FrameData> frameData = <FrameData>[
         FrameData(
           Point<double>(10.0, 10.0),
           <SvgPath>[
             SvgPath(
               'path_1',
               <SvgPathCommand>[
                 SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
               ],
             ),
             SvgPath(
               'path_2',
               <SvgPathCommand>[
                 SvgPathCommand('M', <Point<double>>[Point<double>(5.0, 6.0)]),
               ],
             ),
           ],
         ),
       ];
       expect(PathAnimation.fromFrameData(frameData, 0),
           const PathAnimationMatcher(PathAnimation(
               <PathCommandAnimation>[
                 PathCommandAnimation('M', <List<Point<double>>>[
                   <Point<double>>[Point<double>(0.0, 0.0)],
                 ]),
               ],
               opacities: <double>[1.0],
           )),
       );

       expect(PathAnimation.fromFrameData(frameData, 1),
           const PathAnimationMatcher(PathAnimation(
               <PathCommandAnimation>[
                 PathCommandAnimation('M', <List<Point<double>>>[
                   <Point<double>>[Point<double>(5.0, 6.0)],
                 ]),
               ],
               opacities: <double>[1.0],
           )),
       );
     });

     test('multiple frames', () {
       const List<FrameData> frameData = <FrameData>[
         FrameData(
           Point<double>(10.0, 10.0),
           <SvgPath>[
             SvgPath(
               'path_1',
               <SvgPathCommand>[
                 SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
               ],
               opacity: 0.5,
             ),
           ],
         ),
         FrameData(
           Point<double>(10.0, 10.0),
           <SvgPath>[
             SvgPath(
               'path_1',
               <SvgPathCommand>[
                 SvgPathCommand('M', <Point<double>>[Point<double>(10.0, 10.0)]),
               ],
             ),
           ],
         ),
       ];
       expect(PathAnimation.fromFrameData(frameData, 0),
           const PathAnimationMatcher(PathAnimation(
               <PathCommandAnimation>[
                 PathCommandAnimation('M', <List<Point<double>>>[
                   <Point<double>>[
                     Point<double>(0.0, 0.0),
                     Point<double>(10.0, 10.0),
                   ],
                 ]),
               ],
               opacities: <double>[0.5, 1.0],
           )),
       );
     });
   });

   group('create Animation', () {
     test('multiple paths', () {
       const List<FrameData> frameData = <FrameData>[
         FrameData(
           Point<double>(10.0, 10.0),
           <SvgPath>[
             SvgPath(
               'path_1',
               <SvgPathCommand>[
                 SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
               ],
             ),
             SvgPath(
               'path_1',
               <SvgPathCommand>[
                 SvgPathCommand('M', <Point<double>>[Point<double>(5.0, 6.0)]),
               ],
             ),
           ],
         ),
       ];
       final Animation animation = Animation.fromFrameData(frameData);
       expect(animation.paths[0],
           const PathAnimationMatcher(PathAnimation(
               <PathCommandAnimation>[
                 PathCommandAnimation('M', <List<Point<double>>>[
                   <Point<double>>[Point<double>(0.0, 0.0)],
                 ]),
               ],
               opacities: <double>[1.0],
           )),
       );

       expect(animation.paths[1],
           const PathAnimationMatcher(PathAnimation(
               <PathCommandAnimation>[
                 PathCommandAnimation('M', <List<Point<double>>>[
                   <Point<double>>[Point<double>(5.0, 6.0)],
                 ]),
               ],
               opacities: <double>[1.0],
           )),
       );

       expect(animation.size, const Point<double>(10.0, 10.0));
     });
   });

   group('toDart', () {
     test('_PathMoveTo', () {
       const PathCommandAnimation command = PathCommandAnimation(
         'M',
         <List<Point<double>>>[
           <Point<double>>[
             Point<double>(1.0, 2.0),
             Point<double>(3.0, 4.0),
           ],
         ],
       );

       expect(command.toDart(),
           '        const _PathMoveTo(\n'
           '          const <Offset>[\n'
           '            const Offset(1.0, 2.0),\n'
           '            const Offset(3.0, 4.0),\n'
           '          ],\n'
           '        ),\n',

       );
     });

     test('_PathLineTo', () {
       const PathCommandAnimation command = PathCommandAnimation(
         'L',
         <List<Point<double>>>[
           <Point<double>>[
             Point<double>(1.0, 2.0),
             Point<double>(3.0, 4.0),
           ],
         ],
       );

       expect(command.toDart(),
           '        const _PathLineTo(\n'
           '          const <Offset>[\n'
           '            const Offset(1.0, 2.0),\n'
           '            const Offset(3.0, 4.0),\n'
           '          ],\n'
           '        ),\n',

       );
     });

     test('_PathCubicTo', () {
       const PathCommandAnimation command = PathCommandAnimation(
         'C',
         <List<Point<double>>>[
           <Point<double>>[
             Point<double>(16.0, 24.0),
             Point<double>(16.0, 10.0),
           ],
           <Point<double>>[
             Point<double>(16.0, 25.0),
             Point<double>(16.0, 11.0),
           ],
           <Point<double>>[
             Point<double>(40.0, 40.0),
             Point<double>(40.0, 40.0),
           ],
         ],
       );

       expect(command.toDart(),
           '        const _PathCubicTo(\n'
           '          const <Offset>[\n'
           '            const Offset(16.0, 24.0),\n'
           '            const Offset(16.0, 10.0),\n'
           '          ],\n'
           '          const <Offset>[\n'
           '            const Offset(16.0, 25.0),\n'
           '            const Offset(16.0, 11.0),\n'
           '          ],\n'
           '          const <Offset>[\n'
           '            const Offset(40.0, 40.0),\n'
           '            const Offset(40.0, 40.0),\n'
           '          ],\n'
           '        ),\n',

       );
     });

     test('_PathClose', () {
       const PathCommandAnimation command = PathCommandAnimation(
         'Z',
         <List<Point<double>>>[],
       );

       expect(command.toDart(),
           '        const _PathClose(\n'
           '        ),\n',

       );
     });

     test('Unsupported path command', () {
       const PathCommandAnimation command = PathCommandAnimation(
         'h',
         <List<Point<double>>>[],
       );

       expect(
         () { command.toDart(); },
         throwsA(anything),
       );
     });

     test('_PathFrames', () {
       const PathAnimation pathAnimation = PathAnimation(
           <PathCommandAnimation>[
             PathCommandAnimation('M', <List<Point<double>>>[
               <Point<double>>[
                 Point<double>(0.0, 0.0),
                 Point<double>(10.0, 10.0),
               ],
             ]),
             PathCommandAnimation('L', <List<Point<double>>>[
               <Point<double>>[
                 Point<double>(48.0, 10.0),
                 Point<double>(0.0, 0.0),
               ],
             ]),
           ],
           opacities: <double>[0.5, 1.0],
       );

       expect(pathAnimation.toDart(),
           '    const _PathFrames(\n'
           '      opacities: const <double>[\n'
           '        0.5,\n'
           '        1.0,\n'
           '      ],\n'
           '      commands: const <_PathCommand>[\n'
           '        const _PathMoveTo(\n'
           '          const <Offset>[\n'
           '            const Offset(0.0, 0.0),\n'
           '            const Offset(10.0, 10.0),\n'
           '          ],\n'
           '        ),\n'
           '        const _PathLineTo(\n'
           '          const <Offset>[\n'
           '            const Offset(48.0, 10.0),\n'
           '            const Offset(0.0, 0.0),\n'
           '          ],\n'
           '        ),\n'
           '      ],\n'
           '    ),\n',
       );
     });

     test('Animation', () {
       const Animation animation = Animation(
           Point<double>(48.0, 48.0),
           <PathAnimation>[
             PathAnimation(
                 <PathCommandAnimation>[
                   PathCommandAnimation('M', <List<Point<double>>>[
                     <Point<double>>[
                       Point<double>(0.0, 0.0),
                       Point<double>(10.0, 10.0),
                     ],
                   ]),
                   PathCommandAnimation('L', <List<Point<double>>>[
                     <Point<double>>[
                       Point<double>(48.0, 10.0),
                       Point<double>(0.0, 0.0),
                     ],
                   ]),
                 ],
                 opacities: <double>[0.5, 1.0],
             ),

             PathAnimation(
                 <PathCommandAnimation>[
                   PathCommandAnimation('M', <List<Point<double>>>[
                     <Point<double>>[
                       Point<double>(0.0, 0.0),
                       Point<double>(10.0, 10.0),
                     ],
                   ]),
                 ],
                 opacities: <double>[0.5, 1.0],
             ),
           ]);

       expect(animation.toDart('_AnimatedIconData', r'_$data1'),
           'const _AnimatedIconData _\$data1 = const _AnimatedIconData(\n'
           '  const Size(48.0, 48.0),\n'
           '  const <_PathFrames>[\n'
           '    const _PathFrames(\n'
           '      opacities: const <double>[\n'
           '        0.5,\n'
           '        1.0,\n'
           '      ],\n'
           '      commands: const <_PathCommand>[\n'
           '        const _PathMoveTo(\n'
           '          const <Offset>[\n'
           '            const Offset(0.0, 0.0),\n'
           '            const Offset(10.0, 10.0),\n'
           '          ],\n'
           '        ),\n'
           '        const _PathLineTo(\n'
           '          const <Offset>[\n'
           '            const Offset(48.0, 10.0),\n'
           '            const Offset(0.0, 0.0),\n'
           '          ],\n'
           '        ),\n'
           '      ],\n'
           '    ),\n'
           '    const _PathFrames(\n'
           '      opacities: const <double>[\n'
           '        0.5,\n'
           '        1.0,\n'
           '      ],\n'
           '      commands: const <_PathCommand>[\n'
           '        const _PathMoveTo(\n'
           '          const <Offset>[\n'
           '            const Offset(0.0, 0.0),\n'
           '            const Offset(10.0, 10.0),\n'
           '          ],\n'
           '        ),\n'
           '      ],\n'
           '    ),\n'
           '  ],\n'
           ');',
       );
     });
   });
 }

 // Matches all path commands' points within an error margin.
 class PathMatcher extends Matcher {
   const PathMatcher(this.actual, {this.margin = 0.0});

   final SvgPath actual;
   final double margin;

   @override
   Description describe(Description description) => description.add('$actual (±$margin)');

   @override
   bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
     if (item == null || actual == null) {
       return item == actual;
     }

     if (item.runtimeType != actual.runtimeType) {
       return false;
     }

     final SvgPath other = item as SvgPath;
     if (other.id != actual.id || other.opacity != actual.opacity) {
       return false;
     }

     if (other.commands.length != actual.commands.length) {
       return false;
     }

     for (int i = 0; i < other.commands.length; i += 1) {
       if (!commandsMatch(actual.commands[i], other.commands[i])) {
         return false;
       }
     }
     return true;
   }

   bool commandsMatch(SvgPathCommand actual, SvgPathCommand other) {
     if (other.points.length != actual.points.length) {
       return false;
     }

     for (int i = 0; i < other.points.length; i += 1) {
       if ((other.points[i].x - actual.points[i].x).abs() > margin) {
         return false;
       }
       if ((other.points[i].y - actual.points[i].y).abs() > margin) {
         return false;
       }
     }
     return true;
   }
 }

 class PathAnimationMatcher extends Matcher {
   const PathAnimationMatcher(this.expected);

   final PathAnimation expected;

   @override
   Description describe(Description description) => description.add('$expected');

   @override
   bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
     if (item == null || expected == null) {
       return item == expected;
     }

     if (item.runtimeType != expected.runtimeType) {
       return false;
     }

     final PathAnimation other = item as PathAnimation;

     if (!const ListEquality<double>().equals(other.opacities, expected.opacities)) {
       return false;
     }

     if (other.commands.length != expected.commands.length) {
       return false;
     }

     for (int i = 0; i < other.commands.length; i += 1) {
       if (!commandsMatch(expected.commands[i], other.commands[i])) {
         return false;
       }
     }
     return true;
   }

   bool commandsMatch(PathCommandAnimation expected, PathCommandAnimation other) {
     if (other.points.length != expected.points.length) {
       return false;
     }

     for (int i = 0; i < other.points.length; i += 1) {
       if (!const ListEquality<Point<double>>().equals(other.points[i], expected.points[i])) {
         return false;
     }
       }

     return true;
   }
 }

 String testAsset(String name) {
   return path.join('test_assets', name);
 }
	// 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.

	import 'dart:math';

	import 'package:collection/collection.dart';
	import 'package:flutter/foundation.dart';
	import 'package:flutter_test/flutter_test.dart';
	import 'package:path/path.dart' as path;
	import 'package:vitool/vitool.dart';

	void main() {

	test('parsePixels', () {
	expect(parsePixels('23px'), 23);
	expect(parsePixels('9px'), 9);
	expect(() { parsePixels('9pt'); }, throwsArgumentError);
	});

	test('parsePoints', () {
	expect(parsePoints('1.0, 2.0'),
	const <Point<double>>[Point<double>(1.0, 2.0)],
	);
	expect(parsePoints('12.0, 34.0 5.0, 6.6'),
	const <Point<double>>[
	Point<double>(12.0, 34.0),
	Point<double>(5.0, 6.6),
	],
	);
	expect(parsePoints('12.0 34.0 5.0 6.6'),
	const <Point<double>>[
	Point<double>(12.0, 34.0),
	Point<double>(5.0, 6.6),
	],
	);
	});

	group('parseSvg', () {
	test('empty SVGs', () {
	interpretSvg(testAsset('empty_svg_1_48x48.svg'));
	interpretSvg(testAsset('empty_svg_2_100x50.svg'));
	});

	test('illegal SVGs', () {
	expect(
	() { interpretSvg(testAsset('illegal_svg_multiple_roots.svg')); },
	throwsA(anything),
	);
	});

	test('SVG size', () {
	expect(
	interpretSvg(testAsset('empty_svg_1_48x48.svg')).size,
	const Point<double>(48.0, 48.0),
	);

	expect(
	interpretSvg(testAsset('empty_svg_2_100x50.svg')).size,
	const Point<double>(100.0, 50.0),
	);
	});

	test('horizontal bar', () {
	final FrameData frameData = interpretSvg(testAsset('horizontal_bar.svg'));
	expect(frameData.paths, <SvgPath>[
	const SvgPath('path_1', <SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	]);
	});

	test('leading space path command', () {
	interpretSvg(testAsset('leading_space_path_command.svg'));
	});

	test('SVG illegal path', () {
	expect(
	() { interpretSvg(testAsset('illegal_path.svg')); },
	throwsA(anything),
	);
	});


	test('SVG group', () {
	final FrameData frameData = interpretSvg(testAsset('bars_group.svg'));
	expect(frameData.paths, const <SvgPath>[
	SvgPath('path_1', <SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	SvgPath('path_2', <SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 34.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 34.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 44.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 44.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	]);
	});

	test('SVG group translate', () {
	final FrameData frameData = interpretSvg(testAsset('bar_group_translate.svg'));
	expect(frameData.paths, const <SvgPath>[
	SvgPath('path_1', <SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 34.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 34.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 44.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 44.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	]);
	});

	test('SVG group scale', () {
	final FrameData frameData = interpretSvg(testAsset('bar_group_scale.svg'));
	expect(frameData.paths, const <SvgPath>[
	SvgPath(
	'path_1', <SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 9.5)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(24.0, 9.5)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(24.0, 14.5)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 14.5)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	]);
	});

	test('SVG group rotate scale', () {
	final FrameData frameData = interpretSvg(testAsset('bar_group_rotate_scale.svg'));
	expect(frameData.paths, const <PathMatcher>[
	PathMatcher(
	SvgPath(
	'path_1', <SvgPathCommand>[
	SvgPathCommand('L', <Point<double>>[Point<double>(29.0, 0.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(29.0, 48.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(19.0, 48.0)]),
	SvgPathCommand('M', <Point<double>>[Point<double>(19.0, 0.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	margin: precisionErrorTolerance,
	),
	]);
	});

	test('SVG illegal transform', () {
	expect(
	() { interpretSvg(testAsset('illegal_transform.svg')); },
	throwsA(anything),
	);
	});

	test('SVG group opacity', () {
	final FrameData frameData = interpretSvg(testAsset('bar_group_opacity.svg'));
	expect(frameData.paths, const <SvgPath>[
	SvgPath(
	'path_1',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	],
	opacity: 0.5,
	),
	]);
	});

	test('horizontal bar relative', () {
	// This asset uses the relative 'l' command instead of 'L'.
	final FrameData frameData = interpretSvg(testAsset('horizontal_bar_relative.svg'));
	expect(frameData.paths, const <SvgPath>[
	SvgPath(
	'path_1', <SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 19.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(48.0, 29.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(0.0, 29.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	]);
	});

	test('close in middle of path', () {
	// This asset uses the relative 'l' command instead of 'L'.
	final FrameData frameData = interpretSvg(testAsset('close_path_in_middle.svg'));
	expect(frameData.paths, const <SvgPath>[
	SvgPath(
	'path_1', <SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(50.0, 50.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(60.0, 50.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(60.0, 60.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	SvgPathCommand('L', <Point<double>>[Point<double>(50.0, 40.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(40.0, 40.0)]),
	SvgPathCommand('Z', <Point<double>>[]),
	]),
	]);
	});
	});

	group('create PathAnimation', () {
	test('single path', () {
	const List<FrameData> frameData = <FrameData>[
	FrameData(
	Point<double>(10.0, 10.0),
	<SvgPath>[
	SvgPath(
	'path_1',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
	SvgPathCommand('L', <Point<double>>[Point<double>(10.0, 10.0)]),
	],
	),
	],
	),
	];
	expect(PathAnimation.fromFrameData(frameData, 0),
	const PathAnimationMatcher(PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[Point<double>(0.0, 0.0)],
	]),
	PathCommandAnimation('L', <List<Point<double>>>[
	<Point<double>>[Point<double>(10.0, 10.0)],
	]),
	],
	opacities: <double>[1.0],
	)),
	);
	});

	test('multiple paths', () {
	const List<FrameData> frameData = <FrameData>[
	FrameData(
	Point<double>(10.0, 10.0),
	<SvgPath>[
	SvgPath(
	'path_1',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
	],
	),
	SvgPath(
	'path_2',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(5.0, 6.0)]),
	],
	),
	],
	),
	];
	expect(PathAnimation.fromFrameData(frameData, 0),
	const PathAnimationMatcher(PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[Point<double>(0.0, 0.0)],
	]),
	],
	opacities: <double>[1.0],
	)),
	);

	expect(PathAnimation.fromFrameData(frameData, 1),
	const PathAnimationMatcher(PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[Point<double>(5.0, 6.0)],
	]),
	],
	opacities: <double>[1.0],
	)),
	);
	});

	test('multiple frames', () {
	const List<FrameData> frameData = <FrameData>[
	FrameData(
	Point<double>(10.0, 10.0),
	<SvgPath>[
	SvgPath(
	'path_1',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
	],
	opacity: 0.5,
	),
	],
	),
	FrameData(
	Point<double>(10.0, 10.0),
	<SvgPath>[
	SvgPath(
	'path_1',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(10.0, 10.0)]),
	],
	),
	],
	),
	];
	expect(PathAnimation.fromFrameData(frameData, 0),
	const PathAnimationMatcher(PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[
	Point<double>(0.0, 0.0),
	Point<double>(10.0, 10.0),
	],
	]),
	],
	opacities: <double>[0.5, 1.0],
	)),
	);
	});
	});

	group('create Animation', () {
	test('multiple paths', () {
	const List<FrameData> frameData = <FrameData>[
	FrameData(
	Point<double>(10.0, 10.0),
	<SvgPath>[
	SvgPath(
	'path_1',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(0.0, 0.0)]),
	],
	),
	SvgPath(
	'path_1',
	<SvgPathCommand>[
	SvgPathCommand('M', <Point<double>>[Point<double>(5.0, 6.0)]),
	],
	),
	],
	),
	];
	final Animation animation = Animation.fromFrameData(frameData);
	expect(animation.paths[0],
	const PathAnimationMatcher(PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[Point<double>(0.0, 0.0)],
	]),
	],
	opacities: <double>[1.0],
	)),
	);

	expect(animation.paths[1],
	const PathAnimationMatcher(PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[Point<double>(5.0, 6.0)],
	]),
	],
	opacities: <double>[1.0],
	)),
	);

	expect(animation.size, const Point<double>(10.0, 10.0));
	});
	});

	group('toDart', () {
	test('_PathMoveTo', () {
	const PathCommandAnimation command = PathCommandAnimation(
	'M',
	<List<Point<double>>>[
	<Point<double>>[
	Point<double>(1.0, 2.0),
	Point<double>(3.0, 4.0),
	],
	],
	);

	expect(command.toDart(),
	' const _PathMoveTo(\n'
	' const <Offset>[\n'
	' const Offset(1.0, 2.0),\n'
	' const Offset(3.0, 4.0),\n'
	' ],\n'
	' ),\n',

	);
	});

	test('_PathLineTo', () {
	const PathCommandAnimation command = PathCommandAnimation(
	'L',
	<List<Point<double>>>[
	<Point<double>>[
	Point<double>(1.0, 2.0),
	Point<double>(3.0, 4.0),
	],
	],
	);

	expect(command.toDart(),
	' const _PathLineTo(\n'
	' const <Offset>[\n'
	' const Offset(1.0, 2.0),\n'
	' const Offset(3.0, 4.0),\n'
	' ],\n'
	' ),\n',

	);
	});

	test('_PathCubicTo', () {
	const PathCommandAnimation command = PathCommandAnimation(
	'C',
	<List<Point<double>>>[
	<Point<double>>[
	Point<double>(16.0, 24.0),
	Point<double>(16.0, 10.0),
	],
	<Point<double>>[
	Point<double>(16.0, 25.0),
	Point<double>(16.0, 11.0),
	],
	<Point<double>>[
	Point<double>(40.0, 40.0),
	Point<double>(40.0, 40.0),
	],
	],
	);

	expect(command.toDart(),
	' const _PathCubicTo(\n'
	' const <Offset>[\n'
	' const Offset(16.0, 24.0),\n'
	' const Offset(16.0, 10.0),\n'
	' ],\n'
	' const <Offset>[\n'
	' const Offset(16.0, 25.0),\n'
	' const Offset(16.0, 11.0),\n'
	' ],\n'
	' const <Offset>[\n'
	' const Offset(40.0, 40.0),\n'
	' const Offset(40.0, 40.0),\n'
	' ],\n'
	' ),\n',

	);
	});

	test('_PathClose', () {
	const PathCommandAnimation command = PathCommandAnimation(
	'Z',
	<List<Point<double>>>[],
	);

	expect(command.toDart(),
	' const _PathClose(\n'
	' ),\n',

	);
	});

	test('Unsupported path command', () {
	const PathCommandAnimation command = PathCommandAnimation(
	'h',
	<List<Point<double>>>[],
	);

	expect(
	() { command.toDart(); },
	throwsA(anything),
	);
	});

	test('_PathFrames', () {
	const PathAnimation pathAnimation = PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[
	Point<double>(0.0, 0.0),
	Point<double>(10.0, 10.0),
	],
	]),
	PathCommandAnimation('L', <List<Point<double>>>[
	<Point<double>>[
	Point<double>(48.0, 10.0),
	Point<double>(0.0, 0.0),
	],
	]),
	],
	opacities: <double>[0.5, 1.0],
	);

	expect(pathAnimation.toDart(),
	' const _PathFrames(\n'
	' opacities: const <double>[\n'
	' 0.5,\n'
	' 1.0,\n'
	' ],\n'
	' commands: const <_PathCommand>[\n'
	' const _PathMoveTo(\n'
	' const <Offset>[\n'
	' const Offset(0.0, 0.0),\n'
	' const Offset(10.0, 10.0),\n'
	' ],\n'
	' ),\n'
	' const _PathLineTo(\n'
	' const <Offset>[\n'
	' const Offset(48.0, 10.0),\n'
	' const Offset(0.0, 0.0),\n'
	' ],\n'
	' ),\n'
	' ],\n'
	' ),\n',
	);
	});

	test('Animation', () {
	const Animation animation = Animation(
	Point<double>(48.0, 48.0),
	<PathAnimation>[
	PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[
	Point<double>(0.0, 0.0),
	Point<double>(10.0, 10.0),
	],
	]),
	PathCommandAnimation('L', <List<Point<double>>>[
	<Point<double>>[
	Point<double>(48.0, 10.0),
	Point<double>(0.0, 0.0),
	],
	]),
	],
	opacities: <double>[0.5, 1.0],
	),

	PathAnimation(
	<PathCommandAnimation>[
	PathCommandAnimation('M', <List<Point<double>>>[
	<Point<double>>[
	Point<double>(0.0, 0.0),
	Point<double>(10.0, 10.0),
	],
	]),
	],
	opacities: <double>[0.5, 1.0],
	),
	]);

	expect(animation.toDart('_AnimatedIconData', r'_$data1'),
	'const _AnimatedIconData _\$data1 = const _AnimatedIconData(\n'
	' const Size(48.0, 48.0),\n'
	' const <_PathFrames>[\n'
	' const _PathFrames(\n'
	' opacities: const <double>[\n'
	' 0.5,\n'
	' 1.0,\n'
	' ],\n'
	' commands: const <_PathCommand>[\n'
	' const _PathMoveTo(\n'
	' const <Offset>[\n'
	' const Offset(0.0, 0.0),\n'
	' const Offset(10.0, 10.0),\n'
	' ],\n'
	' ),\n'
	' const _PathLineTo(\n'
	' const <Offset>[\n'
	' const Offset(48.0, 10.0),\n'
	' const Offset(0.0, 0.0),\n'
	' ],\n'
	' ),\n'
	' ],\n'
	' ),\n'
	' const _PathFrames(\n'
	' opacities: const <double>[\n'
	' 0.5,\n'
	' 1.0,\n'
	' ],\n'
	' commands: const <_PathCommand>[\n'
	' const _PathMoveTo(\n'
	' const <Offset>[\n'
	' const Offset(0.0, 0.0),\n'
	' const Offset(10.0, 10.0),\n'
	' ],\n'
	' ),\n'
	' ],\n'
	' ),\n'
	' ],\n'
	');',
	);
	});
	});
	}

	// Matches all path commands' points within an error margin.
	class PathMatcher extends Matcher {
	const PathMatcher(this.actual, {this.margin = 0.0});

	final SvgPath actual;
	final double margin;

	@override
	Description describe(Description description) => description.add('$actual (±$margin)');

	@override
	bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
	if (item == null \|\| actual == null) {
	return item == actual;
	}

	if (item.runtimeType != actual.runtimeType) {
	return false;
	}

	final SvgPath other = item as SvgPath;
	if (other.id != actual.id \|\| other.opacity != actual.opacity) {
	return false;
	}

	if (other.commands.length != actual.commands.length) {
	return false;
	}

	for (int i = 0; i < other.commands.length; i += 1) {
	if (!commandsMatch(actual.commands[i], other.commands[i])) {
	return false;
	}
	}
	return true;
	}

	bool commandsMatch(SvgPathCommand actual, SvgPathCommand other) {
	if (other.points.length != actual.points.length) {
	return false;
	}

	for (int i = 0; i < other.points.length; i += 1) {
	if ((other.points[i].x - actual.points[i].x).abs() > margin) {
	return false;
	}
	if ((other.points[i].y - actual.points[i].y).abs() > margin) {
	return false;
	}
	}
	return true;
	}
	}

	class PathAnimationMatcher extends Matcher {
	const PathAnimationMatcher(this.expected);

	final PathAnimation expected;

	@override
	Description describe(Description description) => description.add('$expected');

	@override
	bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
	if (item == null \|\| expected == null) {
	return item == expected;
	}

	if (item.runtimeType != expected.runtimeType) {
	return false;
	}

	final PathAnimation other = item as PathAnimation;

	if (!const ListEquality<double>().equals(other.opacities, expected.opacities)) {
	return false;
	}

	if (other.commands.length != expected.commands.length) {
	return false;
	}

	for (int i = 0; i < other.commands.length; i += 1) {
	if (!commandsMatch(expected.commands[i], other.commands[i])) {
	return false;
	}
	}
	return true;
	}

	bool commandsMatch(PathCommandAnimation expected, PathCommandAnimation other) {
	if (other.points.length != expected.points.length) {
	return false;
	}

	for (int i = 0; i < other.points.length; i += 1) {
	if (!const ListEquality<Point<double>>().equals(other.points[i], expected.points[i])) {
	return false;
	}
	}

	return true;
	}
	}

	String testAsset(String name) {
	return path.join('test_assets', name);
	}