flutter_frontend_server/test/to_string_test.dart - mirrors/engine - Git at Google

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

 import 'dart:io';

 import 'package:frontend_server/frontend_server.dart' as frontend
     show ProgramTransformer, ToStringTransformer, ToStringVisitor;
 import 'package:kernel/kernel.dart';
 import 'package:path/path.dart' as path;

 import 'utils.dart';

 Future<void> main(List<String> args) async {
   if (args.length != 2) {
     stderr.writeln('The first argument must be the path to the forntend server dill.');
     stderr.writeln('The second argument must be the path to the flutter_patched_sdk');
     exit(-1);
   }

   const Set<String> uiAndFlutter = <String>{
     'dart:ui',
     'package:flutter',
   };

   test('No packages', () {
     final frontend.ToStringTransformer transformer = frontend.ToStringTransformer(null, <String>{});
     final FakeComponent component = FakeComponent();
     transformer.transform(component);

     expect(
       !component.visitChildrenCalled,
       'Expected component.visitChildrenCalled to be false',
     );
   });

   test('dart:ui package', () {
     final frontend.ToStringTransformer transformer = frontend.ToStringTransformer(null, uiAndFlutter);
     final FakeComponent component = FakeComponent();
     transformer.transform(component);

     expect(
       component.visitChildrenCalled,
       'Expected component.visitChildrenCalled to be true',
     );
   });

   test('Child transformer', () {
     final FakeTransformer childTransformer = FakeTransformer();
     final frontend.ToStringTransformer transformer = frontend.ToStringTransformer(childTransformer, <String>{});
     final FakeComponent component = FakeComponent();
     transformer.transform(component);

     expect(
       !component.visitChildrenCalled,
       'Expected component.visitChildrenCalled to be false',
     );
     expect(
       childTransformer.transformCalled,
       'Expected childTransformer.transformCalled to be true',
     );
   });

   test('ToStringVisitor ignores non-toString procedures', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final FakeProcedure procedure = FakeProcedure(
       name: Name('name'),
       annotations: const <Expression>[],
     );
     visitor.visitProcedure(procedure);

     expect(
       !procedure.enclosingLibraryCalled,
       'Expected procedure.enclosingLibraryCalled to be false',
     );
   });

   test('ToStringVisitor ignores top level toString', () {
     // i.e. a `toString` method specified at the top of a library, like:
     //
     // void main() {}
     // String toString() => 'why?';
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final Uri uri = Uri.parse('package:some_package/src/blah.dart');
     final Library library = Library(uri, fileUri: uri);
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final FakeProcedure procedure = FakeProcedure(
       name: Name('tostring'),
       function: function,
       annotations: const <Expression>[],
       enclosingLibrary: library,
       isAbstract: false,
       isStatic: false,
     );
     visitor.visitProcedure(procedure);

     expect(
       !statement.replaceWithCalled,
       'Expected statement.replaceWithCalled to be false',
     );
   });

   test('ToStringVisitor ignores abstract toString', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final Uri uri = Uri.parse('package:some_package/src/blah.dart');
     final Library library = Library(uri, fileUri: uri);
     final FakeProcedure procedure = FakeProcedure(
       name: Name('toString'),
       function: function,
       annotations: const <Expression>[],
       enclosingLibrary: library,
       enclosingClass: Class(name: 'foo', fileUri: uri),
       isAbstract: true,
       isStatic: false,
     );
     visitor.visitProcedure(procedure);

     expect(
       !statement.replaceWithCalled,
       'Expected statement.replaceWithCalled to be false',
     );
   });

   test('ToStringVisitor ignores static toString', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final Uri uri = Uri.parse('package:some_package/src/blah.dart');
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final Library library = Library(uri, fileUri: uri);
     final FakeProcedure procedure = FakeProcedure(
       name: Name('toString'),
       function: function,
       annotations: const <Expression>[],
       enclosingLibrary: library,
       enclosingClass: Class(name: 'foo', fileUri: uri),
       isAbstract: false,
       isStatic: true,
     );
     visitor.visitProcedure(procedure);

     expect(
       !statement.replaceWithCalled,
       'Expected statement.replaceWithCalled jto be false',
     );
   });

   test('ToStringVisitor ignores enum toString', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final Uri uri = Uri.parse('package:some_package/src/blah.dart');
     final Library library = Library(uri, fileUri: uri);
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final FakeProcedure procedure = FakeProcedure(
       name: Name('toString'),
       function: function,
       annotations: const <Expression>[],
       enclosingLibrary: library,
       enclosingClass: Class(name: 'foo', fileUri: uri)..isEnum = true,
       isAbstract: false,
       isStatic: false,
     );
     visitor.visitProcedure(procedure);

     expect(
       !statement.replaceWithCalled,
       'Expected statement.replaceWithCalled to be false',
     );
   });

   test('ToStringVisitor ignores non-specified libraries', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final Uri uri = Uri.parse('package:some_package/src/blah.dart');
     final Library library = Library(uri, fileUri: uri);
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final FakeProcedure procedure = FakeProcedure(
       name: Name('toString'),
       function: function,
       annotations: const <Expression>[],
       enclosingLibrary: library,
       enclosingClass: Class(name: 'foo', fileUri: uri),
       isAbstract: false,
       isStatic: false,
     );
     visitor.visitProcedure(procedure);

     expect(
       !statement.replaceWithCalled,
       'Expected statement.replaceWithCalled to be false',
     );
   });

   test('ToStringVisitor ignores @keepToString', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final Uri uri = Uri.parse('dart:ui');
     final Library library = Library(uri, fileUri: uri);
     final Name name = Name('toString');
     final Class annotation = Class(name: '_KeepToString', fileUri: uri)..parent = library;
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final FakeProcedure procedure = FakeProcedure(
       name: name,
       function: function,
       annotations: <Expression>[ConstantExpression(
         InstanceConstant(
           Reference()..node = annotation,
           <DartType>[],
           <Reference, Constant>{},
         ),
       )],
       enclosingLibrary: library,
       enclosingClass: Class(name: 'foo', fileUri: uri),
       isAbstract: false,
       isStatic: false,
     );
     visitor.visitProcedure(procedure);

     expect(
       !statement.replaceWithCalled,
       'Expected statement.replaceWithCalled to be false',
     );
   });

   void _validateReplacement(FakeStatement body) {
     final ReturnStatement replacement = body.replacement as ReturnStatement;
     expect(
       replacement.expression is SuperMethodInvocation,
       'Expected replacement.expression to be a SuperMethodInvocation',
     );
     final SuperMethodInvocation superMethodInvocation = replacement.expression as SuperMethodInvocation;
     expect(
       superMethodInvocation.name.text == 'toString',
       'Expected superMethodInvocation.name.text to be "toString"',
     );
   }

   test('ToStringVisitor replaces toString in specified libraries (dart:ui)', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final Uri uri = Uri.parse('dart:ui');
     final Library library = Library(uri, fileUri: uri);
     final Name name = Name('toString');
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final FakeProcedure procedure = FakeProcedure(
       name: name,
       function: function,
       annotations: const <Expression>[],
       enclosingLibrary: library,
       enclosingClass: Class(name: 'foo', fileUri: uri),
       isAbstract: false,
       isStatic: false,
     );
     visitor.visitProcedure(procedure);

     _validateReplacement(statement);
   });

   test('ToStringVisitor replaces toString in specified libraries (package:flutter)', () {
     final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
     final Uri uri = Uri.parse('package:flutter/src/foundation.dart');
     final Library library = Library(uri, fileUri: uri);
     final Name name = Name('toString');
     final FakeStatement statement = FakeStatement();
     final FakeFunctionNode function = FakeFunctionNode(
       body: statement,
     );
     final FakeProcedure procedure = FakeProcedure(
       name: name,
       function: function,
       annotations: const <Expression>[],
       enclosingLibrary: library,
       enclosingClass: Class(name: 'foo', fileUri: uri),
       isAbstract: false,
       isStatic: false,
     );
     visitor.visitProcedure(procedure);

     _validateReplacement(statement);
   });

   group('Integration tests',  () {
     final String dart = Platform.resolvedExecutable;
     final String frontendServer = args[0];
     final String sdkRoot = args[1];
     final String basePath = path.canonicalize(path.join(path.dirname(Platform.script.path), '..'));
     final String fixtures = path.join(basePath, 'test', 'fixtures');
     final String mainDart = path.join(fixtures, 'lib', 'main.dart');
     final String packageConfig = path.join(fixtures, '.dart_tool', 'package_config.json');
     final String regularDill = path.join(fixtures, 'toString.dill');
     final String transformedDill = path.join(fixtures, 'toStringTransformed.dill');


     void _checkProcessResult(ProcessResult result) {
       if (result.exitCode != 0) {
         stdout.writeln(result.stdout);
         stderr.writeln(result.stderr);
       }
       expect(result.exitCode == 0, 'Expected result.exitCode to be 0');
     }

     test('Without flag', () {
       _checkProcessResult(Process.runSync(dart, <String>[
         frontendServer,
         '--sdk-root=$sdkRoot',
         '--target=flutter',
         '--packages=$packageConfig',
         '--output-dill=$regularDill',
         mainDart,
       ]));
       final ProcessResult runResult = Process.runSync(dart, <String>[regularDill]);
       _checkProcessResult(runResult);
       String paintString = '"Paint.toString":"Paint(Color(0xffffffff))"';
       if (const bool.fromEnvironment('dart.vm.product', defaultValue: false)) {
         paintString = '"Paint.toString":"Instance of \'Paint\'"';
       }

       final String expectedStdout = '{$paintString,'
         '"Brightness.toString":"Brightness.dark",'
         '"Foo.toString":"I am a Foo",'
         '"Keep.toString":"I am a Keep"}';
       final String actualStdout = runResult.stdout.trim() as String;
       expect(
         actualStdout == expectedStdout,
         'Expected "$expectedStdout" but got "$actualStdout"',
       );
     });

     test('With flag', () {
       _checkProcessResult(Process.runSync(dart, <String>[
         frontendServer,
         '--sdk-root=$sdkRoot',
         '--target=flutter',
         '--packages=$packageConfig',
         '--output-dill=$transformedDill',
         '--delete-tostring-package-uri', 'dart:ui',
         '--delete-tostring-package-uri', 'package:flutter_frontend_fixtures',
         mainDart,
       ]));
       final ProcessResult runResult = Process.runSync(dart, <String>[transformedDill]);
       _checkProcessResult(runResult);

       const String expectedStdout = '{"Paint.toString":"Instance of \'Paint\'",'
         '"Brightness.toString":"Brightness.dark",'
         '"Foo.toString":"Instance of \'Foo\'",'
         '"Keep.toString":"I am a Keep"}';
       final String actualStdout = runResult.stdout.trim() as String;
       expect(
         actualStdout == expectedStdout,
         'Expected "$expectedStdout" but got "$actualStdout"',
       );
     });
   });

   if (TestFailure.testFailures == 0) {
     print('All tests passed!');
     exit(0);
   } else {
     print('${TestFailure.testFailures} test expectations failed');
     exit(1);
   }
 }

 abstract class Fake {
   @override
   dynamic noSuchMethod(Invocation invocation) {
     throw UnimplementedError(invocation.memberName.toString().split('"')[1]);
   }
 }

 class FakeComponent extends Fake implements Component {
   bool visitChildrenCalled = false;

   @override
   void visitChildren(Visitor<void> v) {
     visitChildrenCalled = true;
   }
 }

 class FakeTransformer extends Fake implements frontend.ProgramTransformer {
   bool transformCalled = false;

   @override
   void transform(Component component) {
     transformCalled = true;
   }
 }

 class FakeProcedure extends Fake implements Procedure {
   FakeProcedure({
     this.name,
     this.function,
     this.annotations,
     Library enclosingLibrary,
     this.enclosingClass,
     this.isAbstract,
     this.isStatic,
   }) : _enclosingLibrary = enclosingLibrary;

   @override
   final Name name;

   @override
   final FunctionNode function;

   @override
   final List<Expression> annotations;

   @override
   final bool isAbstract;

   @override
   final bool isStatic;

   @override
   final Class enclosingClass;

   final Library _enclosingLibrary;

   bool enclosingLibraryCalled = false;

   @override
   Library get enclosingLibrary {
     enclosingLibraryCalled = true;
     return _enclosingLibrary;
   }
 }

 class FakeFunctionNode extends Fake implements FunctionNode {
   FakeFunctionNode({
     this.body,
   });

   @override
   final Statement body;
 }

 class FakeStatement extends Fake implements Statement {
   bool replaceWithCalled = false;

   TreeNode replacement;

   @override
   void replaceWith(TreeNode r) {
     replaceWithCalled = true;
     replacement = r;
   }
 }
	// 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.

	import 'dart:io';

	import 'package:frontend_server/frontend_server.dart' as frontend
	show ProgramTransformer, ToStringTransformer, ToStringVisitor;
	import 'package:kernel/kernel.dart';
	import 'package:path/path.dart' as path;

	import 'utils.dart';

	Future<void> main(List<String> args) async {
	if (args.length != 2) {
	stderr.writeln('The first argument must be the path to the forntend server dill.');
	stderr.writeln('The second argument must be the path to the flutter_patched_sdk');
	exit(-1);
	}

	const Set<String> uiAndFlutter = <String>{
	'dart:ui',
	'package:flutter',
	};

	test('No packages', () {
	final frontend.ToStringTransformer transformer = frontend.ToStringTransformer(null, <String>{});
	final FakeComponent component = FakeComponent();
	transformer.transform(component);

	expect(
	!component.visitChildrenCalled,
	'Expected component.visitChildrenCalled to be false',
	);
	});

	test('dart:ui package', () {
	final frontend.ToStringTransformer transformer = frontend.ToStringTransformer(null, uiAndFlutter);
	final FakeComponent component = FakeComponent();
	transformer.transform(component);

	expect(
	component.visitChildrenCalled,
	'Expected component.visitChildrenCalled to be true',
	);
	});

	test('Child transformer', () {
	final FakeTransformer childTransformer = FakeTransformer();
	final frontend.ToStringTransformer transformer = frontend.ToStringTransformer(childTransformer, <String>{});
	final FakeComponent component = FakeComponent();
	transformer.transform(component);

	expect(
	!component.visitChildrenCalled,
	'Expected component.visitChildrenCalled to be false',
	);
	expect(
	childTransformer.transformCalled,
	'Expected childTransformer.transformCalled to be true',
	);
	});

	test('ToStringVisitor ignores non-toString procedures', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final FakeProcedure procedure = FakeProcedure(
	name: Name('name'),
	annotations: const <Expression>[],
	);
	visitor.visitProcedure(procedure);

	expect(
	!procedure.enclosingLibraryCalled,
	'Expected procedure.enclosingLibraryCalled to be false',
	);
	});

	test('ToStringVisitor ignores top level toString', () {
	// i.e. a `toString` method specified at the top of a library, like:
	//
	// void main() {}
	// String toString() => 'why?';
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final Uri uri = Uri.parse('package:some_package/src/blah.dart');
	final Library library = Library(uri, fileUri: uri);
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final FakeProcedure procedure = FakeProcedure(
	name: Name('tostring'),
	function: function,
	annotations: const <Expression>[],
	enclosingLibrary: library,
	isAbstract: false,
	isStatic: false,
	);
	visitor.visitProcedure(procedure);

	expect(
	!statement.replaceWithCalled,
	'Expected statement.replaceWithCalled to be false',
	);
	});

	test('ToStringVisitor ignores abstract toString', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final Uri uri = Uri.parse('package:some_package/src/blah.dart');
	final Library library = Library(uri, fileUri: uri);
	final FakeProcedure procedure = FakeProcedure(
	name: Name('toString'),
	function: function,
	annotations: const <Expression>[],
	enclosingLibrary: library,
	enclosingClass: Class(name: 'foo', fileUri: uri),
	isAbstract: true,
	isStatic: false,
	);
	visitor.visitProcedure(procedure);

	expect(
	!statement.replaceWithCalled,
	'Expected statement.replaceWithCalled to be false',
	);
	});

	test('ToStringVisitor ignores static toString', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final Uri uri = Uri.parse('package:some_package/src/blah.dart');
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final Library library = Library(uri, fileUri: uri);
	final FakeProcedure procedure = FakeProcedure(
	name: Name('toString'),
	function: function,
	annotations: const <Expression>[],
	enclosingLibrary: library,
	enclosingClass: Class(name: 'foo', fileUri: uri),
	isAbstract: false,
	isStatic: true,
	);
	visitor.visitProcedure(procedure);

	expect(
	!statement.replaceWithCalled,
	'Expected statement.replaceWithCalled jto be false',
	);
	});

	test('ToStringVisitor ignores enum toString', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final Uri uri = Uri.parse('package:some_package/src/blah.dart');
	final Library library = Library(uri, fileUri: uri);
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final FakeProcedure procedure = FakeProcedure(
	name: Name('toString'),
	function: function,
	annotations: const <Expression>[],
	enclosingLibrary: library,
	enclosingClass: Class(name: 'foo', fileUri: uri)..isEnum = true,
	isAbstract: false,
	isStatic: false,
	);
	visitor.visitProcedure(procedure);

	expect(
	!statement.replaceWithCalled,
	'Expected statement.replaceWithCalled to be false',
	);
	});

	test('ToStringVisitor ignores non-specified libraries', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final Uri uri = Uri.parse('package:some_package/src/blah.dart');
	final Library library = Library(uri, fileUri: uri);
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final FakeProcedure procedure = FakeProcedure(
	name: Name('toString'),
	function: function,
	annotations: const <Expression>[],
	enclosingLibrary: library,
	enclosingClass: Class(name: 'foo', fileUri: uri),
	isAbstract: false,
	isStatic: false,
	);
	visitor.visitProcedure(procedure);

	expect(
	!statement.replaceWithCalled,
	'Expected statement.replaceWithCalled to be false',
	);
	});

	test('ToStringVisitor ignores @keepToString', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final Uri uri = Uri.parse('dart:ui');
	final Library library = Library(uri, fileUri: uri);
	final Name name = Name('toString');
	final Class annotation = Class(name: '_KeepToString', fileUri: uri)..parent = library;
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final FakeProcedure procedure = FakeProcedure(
	name: name,
	function: function,
	annotations: <Expression>[ConstantExpression(
	InstanceConstant(
	Reference()..node = annotation,
	<DartType>[],
	<Reference, Constant>{},
	),
	)],
	enclosingLibrary: library,
	enclosingClass: Class(name: 'foo', fileUri: uri),
	isAbstract: false,
	isStatic: false,
	);
	visitor.visitProcedure(procedure);

	expect(
	!statement.replaceWithCalled,
	'Expected statement.replaceWithCalled to be false',
	);
	});

	void _validateReplacement(FakeStatement body) {
	final ReturnStatement replacement = body.replacement as ReturnStatement;
	expect(
	replacement.expression is SuperMethodInvocation,
	'Expected replacement.expression to be a SuperMethodInvocation',
	);
	final SuperMethodInvocation superMethodInvocation = replacement.expression as SuperMethodInvocation;
	expect(
	superMethodInvocation.name.text == 'toString',
	'Expected superMethodInvocation.name.text to be "toString"',
	);
	}

	test('ToStringVisitor replaces toString in specified libraries (dart:ui)', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final Uri uri = Uri.parse('dart:ui');
	final Library library = Library(uri, fileUri: uri);
	final Name name = Name('toString');
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final FakeProcedure procedure = FakeProcedure(
	name: name,
	function: function,
	annotations: const <Expression>[],
	enclosingLibrary: library,
	enclosingClass: Class(name: 'foo', fileUri: uri),
	isAbstract: false,
	isStatic: false,
	);
	visitor.visitProcedure(procedure);

	_validateReplacement(statement);
	});

	test('ToStringVisitor replaces toString in specified libraries (package:flutter)', () {
	final frontend.ToStringVisitor visitor = frontend.ToStringVisitor(uiAndFlutter);
	final Uri uri = Uri.parse('package:flutter/src/foundation.dart');
	final Library library = Library(uri, fileUri: uri);
	final Name name = Name('toString');
	final FakeStatement statement = FakeStatement();
	final FakeFunctionNode function = FakeFunctionNode(
	body: statement,
	);
	final FakeProcedure procedure = FakeProcedure(
	name: name,
	function: function,
	annotations: const <Expression>[],
	enclosingLibrary: library,
	enclosingClass: Class(name: 'foo', fileUri: uri),
	isAbstract: false,
	isStatic: false,
	);
	visitor.visitProcedure(procedure);

	_validateReplacement(statement);
	});

	group('Integration tests', () {
	final String dart = Platform.resolvedExecutable;
	final String frontendServer = args[0];
	final String sdkRoot = args[1];
	final String basePath = path.canonicalize(path.join(path.dirname(Platform.script.path), '..'));
	final String fixtures = path.join(basePath, 'test', 'fixtures');
	final String mainDart = path.join(fixtures, 'lib', 'main.dart');
	final String packageConfig = path.join(fixtures, '.dart_tool', 'package_config.json');
	final String regularDill = path.join(fixtures, 'toString.dill');
	final String transformedDill = path.join(fixtures, 'toStringTransformed.dill');


	void _checkProcessResult(ProcessResult result) {
	if (result.exitCode != 0) {
	stdout.writeln(result.stdout);
	stderr.writeln(result.stderr);
	}
	expect(result.exitCode == 0, 'Expected result.exitCode to be 0');
	}

	test('Without flag', () {
	_checkProcessResult(Process.runSync(dart, <String>[
	frontendServer,
	'--sdk-root=$sdkRoot',
	'--target=flutter',
	'--packages=$packageConfig',
	'--output-dill=$regularDill',
	mainDart,
	]));
	final ProcessResult runResult = Process.runSync(dart, <String>[regularDill]);
	_checkProcessResult(runResult);
	String paintString = '"Paint.toString":"Paint(Color(0xffffffff))"';
	if (const bool.fromEnvironment('dart.vm.product', defaultValue: false)) {
	paintString = '"Paint.toString":"Instance of \'Paint\'"';
	}

	final String expectedStdout = '{$paintString,'
	'"Brightness.toString":"Brightness.dark",'
	'"Foo.toString":"I am a Foo",'
	'"Keep.toString":"I am a Keep"}';
	final String actualStdout = runResult.stdout.trim() as String;
	expect(
	actualStdout == expectedStdout,
	'Expected "$expectedStdout" but got "$actualStdout"',
	);
	});

	test('With flag', () {
	_checkProcessResult(Process.runSync(dart, <String>[
	frontendServer,
	'--sdk-root=$sdkRoot',
	'--target=flutter',
	'--packages=$packageConfig',
	'--output-dill=$transformedDill',
	'--delete-tostring-package-uri', 'dart:ui',
	'--delete-tostring-package-uri', 'package:flutter_frontend_fixtures',
	mainDart,
	]));
	final ProcessResult runResult = Process.runSync(dart, <String>[transformedDill]);
	_checkProcessResult(runResult);

	const String expectedStdout = '{"Paint.toString":"Instance of \'Paint\'",'
	'"Brightness.toString":"Brightness.dark",'
	'"Foo.toString":"Instance of \'Foo\'",'
	'"Keep.toString":"I am a Keep"}';
	final String actualStdout = runResult.stdout.trim() as String;
	expect(
	actualStdout == expectedStdout,
	'Expected "$expectedStdout" but got "$actualStdout"',
	);
	});
	});

	if (TestFailure.testFailures == 0) {
	print('All tests passed!');
	exit(0);
	} else {
	print('${TestFailure.testFailures} test expectations failed');
	exit(1);
	}
	}

	abstract class Fake {
	@override
	dynamic noSuchMethod(Invocation invocation) {
	throw UnimplementedError(invocation.memberName.toString().split('"')[1]);
	}
	}

	class FakeComponent extends Fake implements Component {
	bool visitChildrenCalled = false;

	@override
	void visitChildren(Visitor<void> v) {
	visitChildrenCalled = true;
	}
	}

	class FakeTransformer extends Fake implements frontend.ProgramTransformer {
	bool transformCalled = false;

	@override
	void transform(Component component) {
	transformCalled = true;
	}
	}

	class FakeProcedure extends Fake implements Procedure {
	FakeProcedure({
	this.name,
	this.function,
	this.annotations,
	Library enclosingLibrary,
	this.enclosingClass,
	this.isAbstract,
	this.isStatic,
	}) : _enclosingLibrary = enclosingLibrary;

	@override
	final Name name;

	@override
	final FunctionNode function;

	@override
	final List<Expression> annotations;

	@override
	final bool isAbstract;

	@override
	final bool isStatic;

	@override
	final Class enclosingClass;

	final Library _enclosingLibrary;

	bool enclosingLibraryCalled = false;

	@override
	Library get enclosingLibrary {
	enclosingLibraryCalled = true;
	return _enclosingLibrary;
	}
	}

	class FakeFunctionNode extends Fake implements FunctionNode {
	FakeFunctionNode({
	this.body,
	});

	@override
	final Statement body;
	}

	class FakeStatement extends Fake implements Statement {
	bool replaceWithCalled = false;

	TreeNode replacement;

	@override
	void replaceWith(TreeNode r) {
	replaceWithCalled = true;
	replacement = r;
	}
	}