packages/flutter_tools/test/general.shard/crash_reporting_test.dart - external/github.com/flutter/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:async';
 import 'dart:convert';

 import 'package:file/file.dart';
 import 'package:file/local.dart';
 import 'package:file/memory.dart';
 import 'package:flutter_tools/runner.dart' as tools;
 import 'package:flutter_tools/src/base/common.dart';
 import 'package:flutter_tools/src/base/context.dart';
 import 'package:flutter_tools/src/base/io.dart';
 import 'package:flutter_tools/src/cache.dart';
 import 'package:flutter_tools/src/doctor.dart';
 import 'package:flutter_tools/src/reporting/reporting.dart';
 import 'package:flutter_tools/src/runner/flutter_command.dart';
 import 'package:flutter_tools/src/globals.dart' as globals;
 import 'package:http/http.dart';
 import 'package:http/testing.dart';
 import 'package:quiver/testing/async.dart';
 import 'package:platform/platform.dart';

 import '../src/common.dart';
 import '../src/context.dart';

 void main() {
   group('crash reporting', () {
     setUpAll(() {
       Cache.disableLocking();
     });

     setUp(() async {
       tools.crashFileSystem = MemoryFileSystem();
       setExitFunctionForTests((_) { });
       MockCrashReportSender.sendCalls = 0;
     });

     tearDown(() {
       tools.crashFileSystem = const LocalFileSystem();
       restoreExitFunction();
     });

     testUsingContext('should send crash reports', () async {
       final RequestInfo requestInfo = RequestInfo();

       CrashReportSender.initializeWith(MockCrashReportSender(requestInfo));
       final int exitCode = await tools.run(
         <String>['crash'],
         <FlutterCommand>[_CrashCommand()],
         reportCrashes: true,
         flutterVersion: 'test-version',
       );
       expect(exitCode, 1);

       await verifyCrashReportSent(requestInfo);
     }, overrides: <Type, Generator>{
       Stdio: () => _NoStderr(),
     });

     testUsingContext('should print an explanatory message when there is a SocketException', () async {
       final Completer<int> exitCodeCompleter = Completer<int>();
       setExitFunctionForTests((int exitCode) {
         exitCodeCompleter.complete(exitCode);
       });

       CrashReportSender.initializeWith(
           CrashingCrashReportSender(const SocketException('no internets')));

       unawaited(tools.run(
         <String>['crash'],
         <FlutterCommand>[_CrashAsyncCommand()],
         reportCrashes: true,
         flutterVersion: 'test-version',
       ));
       expect(await exitCodeCompleter.future, 1);
       expect(testLogger.errorText, contains('Failed to send crash report due to a network error'));
     }, overrides: <Type, Generator>{
       Stdio: () => _NoStderr(),
     });

     testUsingContext('should print an explanatory message when there is an HttpException', () async {
       final Completer<int> exitCodeCompleter = Completer<int>();
       setExitFunctionForTests((int exitCode) {
         exitCodeCompleter.complete(exitCode);
       });

       CrashReportSender.initializeWith(
           CrashingCrashReportSender(const HttpException('no internets')));

       unawaited(tools.run(
         <String>['crash'],
         <FlutterCommand>[_CrashAsyncCommand()],
         reportCrashes: true,
         flutterVersion: 'test-version',
       ));
       expect(await exitCodeCompleter.future, 1);
       expect(testLogger.errorText, contains('Failed to send crash report due to a network error'));
     }, overrides: <Type, Generator>{
       Stdio: () => _NoStderr(),
     });

     testUsingContext('should send crash reports when async throws', () async {
       final Completer<int> exitCodeCompleter = Completer<int>();
       setExitFunctionForTests((int exitCode) {
         exitCodeCompleter.complete(exitCode);
       });

       final RequestInfo requestInfo = RequestInfo();

       CrashReportSender.initializeWith(MockCrashReportSender(requestInfo));

       unawaited(tools.run(
         <String>['crash'],
         <FlutterCommand>[_CrashAsyncCommand()],
         reportCrashes: true,
         flutterVersion: 'test-version',
       ));
       expect(await exitCodeCompleter.future, 1);
       await verifyCrashReportSent(requestInfo);
     }, overrides: <Type, Generator>{
       Stdio: () => _NoStderr(),
     });

     testUsingContext('should send only one crash report when async throws many', () async {
       final Completer<int> exitCodeCompleter = Completer<int>();
       setExitFunctionForTests((int exitCode) {
         if (!exitCodeCompleter.isCompleted) {
           exitCodeCompleter.complete(exitCode);
         }
       });

       final RequestInfo requestInfo = RequestInfo();
       final MockCrashReportSender sender = MockCrashReportSender(requestInfo);
       CrashReportSender.initializeWith(sender);

       FakeAsync().run((FakeAsync time) {
         time.elapse(const Duration(seconds: 1));
         unawaited(tools.run(
           <String>['crash'],
           <FlutterCommand>[_MultiCrashAsyncCommand(crashes: 4)],
           reportCrashes: true,
           flutterVersion: 'test-version',
         ));
         time.elapse(const Duration(seconds: 1));
         time.flushMicrotasks();
       });
       expect(await exitCodeCompleter.future, 1);
       expect(MockCrashReportSender.sendCalls, 1);
       await verifyCrashReportSent(requestInfo, crashes: 4);
     }, overrides: <Type, Generator>{
       DoctorValidatorsProvider: () => FakeDoctorValidatorsProvider(),
       Stdio: () => _NoStderr(),
     });

     testUsingContext('should not send a crash report if on a user-branch', () async {
       String method;
       Uri uri;

       CrashReportSender.initializeWith(MockClient((Request request) async {
         method = request.method;
         uri = request.url;

         return Response(
           'test-report-id',
           200,
         );
       }));

       final int exitCode = await tools.run(
         <String>['crash'],
         <FlutterCommand>[_CrashCommand()],
         reportCrashes: true,
         flutterVersion: '[user-branch]/v1.2.3',
       );

       expect(exitCode, 1);

       // Verify that the report wasn't sent
       expect(method, null);
       expect(uri, null);

       expect(testLogger.traceText, isNot(contains('Crash report sent')));
     }, overrides: <Type, Generator>{
       Stdio: () => _NoStderr(),
     });

     testUsingContext('can override base URL', () async {
       Uri uri;
       CrashReportSender.initializeWith(MockClient((Request request) async {
         uri = request.url;
         return Response('test-report-id', 200);
       }));

       final int exitCode = await tools.run(
         <String>['crash'],
         <FlutterCommand>[_CrashCommand()],
         reportCrashes: true,
         flutterVersion: 'test-version',
       );

       expect(exitCode, 1);

       // Verify that we sent the crash report.
       expect(uri, isNotNull);
       expect(uri, Uri(
         scheme: 'https',
         host: 'localhost',
         port: 12345,
         path: '/fake_server',
         queryParameters: <String, String>{
           'product': 'Flutter_Tools',
           'version': 'test-version',
         },
       ));
     }, overrides: <Type, Generator>{
       Platform: () => FakePlatform(
         operatingSystem: 'linux',
         environment: <String, String>{
           'HOME': '/',
           'FLUTTER_CRASH_SERVER_BASE_URL': 'https://localhost:12345/fake_server',
         },
         script: Uri(scheme: 'data'),
       ),
       Stdio: () => _NoStderr(),
     });
   });
 }

 class RequestInfo {
   String method;
   Uri uri;
   Map<String, String> fields;
 }

 Future<void> verifyCrashReportSent(RequestInfo crashInfo, {
   int crashes = 1,
 }) async {
   // Verify that we sent the crash report.
   expect(crashInfo.method, 'POST');
   expect(crashInfo.uri, Uri(
     scheme: 'https',
     host: 'clients2.google.com',
     port: 443,
     path: '/cr/report',
     queryParameters: <String, String>{
       'product': 'Flutter_Tools',
       'version': 'test-version',
     },
   ));
   expect(crashInfo.fields['uuid'], '00000000-0000-4000-0000-000000000000');
   expect(crashInfo.fields['product'], 'Flutter_Tools');
   expect(crashInfo.fields['version'], 'test-version');
   expect(crashInfo.fields['osName'], globals.platform.operatingSystem);
   expect(crashInfo.fields['osVersion'], 'fake OS name and version');
   expect(crashInfo.fields['type'], 'DartError');
   expect(crashInfo.fields['error_runtime_type'], 'StateError');
   expect(crashInfo.fields['error_message'], 'Bad state: Test bad state error');
   expect(crashInfo.fields['comments'], 'crash');

   expect(testLogger.traceText, contains('Sending crash report to Google.'));
   expect(testLogger.traceText, contains('Crash report sent (report ID: test-report-id)'));

   // Verify that we've written the crash report to disk.
   final List<String> writtenFiles =
   (await tools.crashFileSystem.directory('/').list(recursive: true).toList())
       .map((FileSystemEntity e) => e.path).toList();
   expect(writtenFiles, hasLength(crashes));
   expect(writtenFiles, contains('flutter_01.log'));
 }

 class MockCrashReportSender extends MockClient {
   MockCrashReportSender(RequestInfo crashInfo) : super((Request request) async {
     MockCrashReportSender.sendCalls++;
     crashInfo.method = request.method;
     crashInfo.uri = request.url;

     // A very ad-hoc multipart request parser. Good enough for this test.
     String boundary = request.headers['Content-Type'];
     boundary = boundary.substring(boundary.indexOf('boundary=') + 9);
     crashInfo.fields = Map<String, String>.fromIterable(
       utf8.decode(request.bodyBytes)
         .split('--$boundary')
         .map<List<String>>((String part) {
           final Match nameMatch = RegExp(r'name="(.*)"').firstMatch(part);
           if (nameMatch == null) {
             return null;
           }
           final String name = nameMatch[1];
           final String value = part.split('\n').skip(2).join('\n').trim();
           return <String>[name, value];
         })
         .where((List<String> pair) => pair != null),
       key: (dynamic key) {
         final List<String> pair = key as List<String>;
         return pair[0];
       },
       value: (dynamic value) {
         final List<String> pair = value as List<String>;
         return pair[1];
       },
     );

     return Response(
       'test-report-id',
       200,
     );
   });

   static int sendCalls = 0;
 }

 class CrashingCrashReportSender extends MockClient {
   CrashingCrashReportSender(Object exception) : super((Request request) async {
     throw exception;
   });
 }

 /// Throws a random error to simulate a CLI crash.
 class _CrashCommand extends FlutterCommand {

   @override
   String get description => 'Simulates a crash';

   @override
   String get name => 'crash';

   @override
   Future<FlutterCommandResult> runCommand() async {
     void fn1() {
       throw StateError('Test bad state error');
     }

     void fn2() {
       fn1();
     }

     void fn3() {
       fn2();
     }

     fn3();

     return FlutterCommandResult.success();
   }
 }

 /// Throws StateError from async callback.
 class _CrashAsyncCommand extends FlutterCommand {

   @override
   String get description => 'Simulates a crash';

   @override
   String get name => 'crash';

   @override
   Future<FlutterCommandResult> runCommand() async {
     Timer.run(() {
       throw StateError('Test bad state error');
     });
     return Completer<FlutterCommandResult>().future; // expect StateError
   }
 }

 /// Generates multiple asynchronous unhandled exceptions.
 class _MultiCrashAsyncCommand extends FlutterCommand {
   _MultiCrashAsyncCommand({
     int crashes = 1,
   }) : _crashes = crashes;

   final int _crashes;

   @override
   String get description => 'Simulates a crash';

   @override
   String get name => 'crash';

   @override
   Future<FlutterCommandResult> runCommand() async {
     for (int i = 0; i < _crashes; i++) {
       Timer.run(() {
         throw StateError('Test bad state error');
       });
     }
     return Completer<FlutterCommandResult>().future; // expect StateError
   }
 }

 /// A DoctorValidatorsProvider that overrides the default validators without
 /// overriding the doctor.
 class FakeDoctorValidatorsProvider implements DoctorValidatorsProvider {
   @override
   List<DoctorValidator> get validators => <DoctorValidator>[];

   @override
   List<Workflow> get workflows => <Workflow>[];
 }

 class _NoStderr extends Stdio {
   _NoStderr();

   @override
   IOSink get stderr => const _NoopIOSink();
 }

 class _NoopIOSink implements IOSink {
   const _NoopIOSink();

   @override
   Encoding get encoding => utf8;

   @override
   set encoding(_) => throw UnsupportedError('');

   @override
   void add(_) { }

   @override
   void write(_) { }

   @override
   void writeAll(_, [ __ = '' ]) { }

   @override
   void writeln([ _ = '' ]) { }

   @override
   void writeCharCode(_) { }

   @override
   void addError(_, [ __ ]) { }

   @override
   Future<dynamic> addStream(_) async { }

   @override
   Future<dynamic> flush() async { }

   @override
   Future<dynamic> close() async { }

   @override
   Future<dynamic> get done async { }
 }
	// 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:async';
	import 'dart:convert';

	import 'package:file/file.dart';
	import 'package:file/local.dart';
	import 'package:file/memory.dart';
	import 'package:flutter_tools/runner.dart' as tools;
	import 'package:flutter_tools/src/base/common.dart';
	import 'package:flutter_tools/src/base/context.dart';
	import 'package:flutter_tools/src/base/io.dart';
	import 'package:flutter_tools/src/cache.dart';
	import 'package:flutter_tools/src/doctor.dart';
	import 'package:flutter_tools/src/reporting/reporting.dart';
	import 'package:flutter_tools/src/runner/flutter_command.dart';
	import 'package:flutter_tools/src/globals.dart' as globals;
	import 'package:http/http.dart';
	import 'package:http/testing.dart';
	import 'package:quiver/testing/async.dart';
	import 'package:platform/platform.dart';

	import '../src/common.dart';
	import '../src/context.dart';

	void main() {
	group('crash reporting', () {
	setUpAll(() {
	Cache.disableLocking();
	});

	setUp(() async {
	tools.crashFileSystem = MemoryFileSystem();
	setExitFunctionForTests((_) { });
	MockCrashReportSender.sendCalls = 0;
	});

	tearDown(() {
	tools.crashFileSystem = const LocalFileSystem();
	restoreExitFunction();
	});

	testUsingContext('should send crash reports', () async {
	final RequestInfo requestInfo = RequestInfo();

	CrashReportSender.initializeWith(MockCrashReportSender(requestInfo));
	final int exitCode = await tools.run(
	<String>['crash'],
	<FlutterCommand>[_CrashCommand()],
	reportCrashes: true,
	flutterVersion: 'test-version',
	);
	expect(exitCode, 1);

	await verifyCrashReportSent(requestInfo);
	}, overrides: <Type, Generator>{
	Stdio: () => _NoStderr(),
	});

	testUsingContext('should print an explanatory message when there is a SocketException', () async {
	final Completer<int> exitCodeCompleter = Completer<int>();
	setExitFunctionForTests((int exitCode) {
	exitCodeCompleter.complete(exitCode);
	});

	CrashReportSender.initializeWith(
	CrashingCrashReportSender(const SocketException('no internets')));

	unawaited(tools.run(
	<String>['crash'],
	<FlutterCommand>[_CrashAsyncCommand()],
	reportCrashes: true,
	flutterVersion: 'test-version',
	));
	expect(await exitCodeCompleter.future, 1);
	expect(testLogger.errorText, contains('Failed to send crash report due to a network error'));
	}, overrides: <Type, Generator>{
	Stdio: () => _NoStderr(),
	});

	testUsingContext('should print an explanatory message when there is an HttpException', () async {
	final Completer<int> exitCodeCompleter = Completer<int>();
	setExitFunctionForTests((int exitCode) {
	exitCodeCompleter.complete(exitCode);
	});

	CrashReportSender.initializeWith(
	CrashingCrashReportSender(const HttpException('no internets')));

	unawaited(tools.run(
	<String>['crash'],
	<FlutterCommand>[_CrashAsyncCommand()],
	reportCrashes: true,
	flutterVersion: 'test-version',
	));
	expect(await exitCodeCompleter.future, 1);
	expect(testLogger.errorText, contains('Failed to send crash report due to a network error'));
	}, overrides: <Type, Generator>{
	Stdio: () => _NoStderr(),
	});

	testUsingContext('should send crash reports when async throws', () async {
	final Completer<int> exitCodeCompleter = Completer<int>();
	setExitFunctionForTests((int exitCode) {
	exitCodeCompleter.complete(exitCode);
	});

	final RequestInfo requestInfo = RequestInfo();

	CrashReportSender.initializeWith(MockCrashReportSender(requestInfo));

	unawaited(tools.run(
	<String>['crash'],
	<FlutterCommand>[_CrashAsyncCommand()],
	reportCrashes: true,
	flutterVersion: 'test-version',
	));
	expect(await exitCodeCompleter.future, 1);
	await verifyCrashReportSent(requestInfo);
	}, overrides: <Type, Generator>{
	Stdio: () => _NoStderr(),
	});

	testUsingContext('should send only one crash report when async throws many', () async {
	final Completer<int> exitCodeCompleter = Completer<int>();
	setExitFunctionForTests((int exitCode) {
	if (!exitCodeCompleter.isCompleted) {
	exitCodeCompleter.complete(exitCode);
	}
	});

	final RequestInfo requestInfo = RequestInfo();
	final MockCrashReportSender sender = MockCrashReportSender(requestInfo);
	CrashReportSender.initializeWith(sender);

	FakeAsync().run((FakeAsync time) {
	time.elapse(const Duration(seconds: 1));
	unawaited(tools.run(
	<String>['crash'],
	<FlutterCommand>[_MultiCrashAsyncCommand(crashes: 4)],
	reportCrashes: true,
	flutterVersion: 'test-version',
	));
	time.elapse(const Duration(seconds: 1));
	time.flushMicrotasks();
	});
	expect(await exitCodeCompleter.future, 1);
	expect(MockCrashReportSender.sendCalls, 1);
	await verifyCrashReportSent(requestInfo, crashes: 4);
	}, overrides: <Type, Generator>{
	DoctorValidatorsProvider: () => FakeDoctorValidatorsProvider(),
	Stdio: () => _NoStderr(),
	});

	testUsingContext('should not send a crash report if on a user-branch', () async {
	String method;
	Uri uri;

	CrashReportSender.initializeWith(MockClient((Request request) async {
	method = request.method;
	uri = request.url;

	return Response(
	'test-report-id',
	200,
	);
	}));

	final int exitCode = await tools.run(
	<String>['crash'],
	<FlutterCommand>[_CrashCommand()],
	reportCrashes: true,
	flutterVersion: '[user-branch]/v1.2.3',
	);

	expect(exitCode, 1);

	// Verify that the report wasn't sent
	expect(method, null);
	expect(uri, null);

	expect(testLogger.traceText, isNot(contains('Crash report sent')));
	}, overrides: <Type, Generator>{
	Stdio: () => _NoStderr(),
	});

	testUsingContext('can override base URL', () async {
	Uri uri;
	CrashReportSender.initializeWith(MockClient((Request request) async {
	uri = request.url;
	return Response('test-report-id', 200);
	}));

	final int exitCode = await tools.run(
	<String>['crash'],
	<FlutterCommand>[_CrashCommand()],
	reportCrashes: true,
	flutterVersion: 'test-version',
	);

	expect(exitCode, 1);

	// Verify that we sent the crash report.
	expect(uri, isNotNull);
	expect(uri, Uri(
	scheme: 'https',
	host: 'localhost',
	port: 12345,
	path: '/fake_server',
	queryParameters: <String, String>{
	'product': 'Flutter_Tools',
	'version': 'test-version',
	},
	));
	}, overrides: <Type, Generator>{
	Platform: () => FakePlatform(
	operatingSystem: 'linux',
	environment: <String, String>{
	'HOME': '/',
	'FLUTTER_CRASH_SERVER_BASE_URL': 'https://localhost:12345/fake_server',
	},
	script: Uri(scheme: 'data'),
	),
	Stdio: () => _NoStderr(),
	});
	});
	}

	class RequestInfo {
	String method;
	Uri uri;
	Map<String, String> fields;
	}

	Future<void> verifyCrashReportSent(RequestInfo crashInfo, {
	int crashes = 1,
	}) async {
	// Verify that we sent the crash report.
	expect(crashInfo.method, 'POST');
	expect(crashInfo.uri, Uri(
	scheme: 'https',
	host: 'clients2.google.com',
	port: 443,
	path: '/cr/report',
	queryParameters: <String, String>{
	'product': 'Flutter_Tools',
	'version': 'test-version',
	},
	));
	expect(crashInfo.fields['uuid'], '00000000-0000-4000-0000-000000000000');
	expect(crashInfo.fields['product'], 'Flutter_Tools');
	expect(crashInfo.fields['version'], 'test-version');
	expect(crashInfo.fields['osName'], globals.platform.operatingSystem);
	expect(crashInfo.fields['osVersion'], 'fake OS name and version');
	expect(crashInfo.fields['type'], 'DartError');
	expect(crashInfo.fields['error_runtime_type'], 'StateError');
	expect(crashInfo.fields['error_message'], 'Bad state: Test bad state error');
	expect(crashInfo.fields['comments'], 'crash');

	expect(testLogger.traceText, contains('Sending crash report to Google.'));
	expect(testLogger.traceText, contains('Crash report sent (report ID: test-report-id)'));

	// Verify that we've written the crash report to disk.
	final List<String> writtenFiles =
	(await tools.crashFileSystem.directory('/').list(recursive: true).toList())
	.map((FileSystemEntity e) => e.path).toList();
	expect(writtenFiles, hasLength(crashes));
	expect(writtenFiles, contains('flutter_01.log'));
	}

	class MockCrashReportSender extends MockClient {
	MockCrashReportSender(RequestInfo crashInfo) : super((Request request) async {
	MockCrashReportSender.sendCalls++;
	crashInfo.method = request.method;
	crashInfo.uri = request.url;

	// A very ad-hoc multipart request parser. Good enough for this test.
	String boundary = request.headers['Content-Type'];
	boundary = boundary.substring(boundary.indexOf('boundary=') + 9);
	crashInfo.fields = Map<String, String>.fromIterable(
	utf8.decode(request.bodyBytes)
	.split('--$boundary')
	.map<List<String>>((String part) {
	final Match nameMatch = RegExp(r'name="(.*)"').firstMatch(part);
	if (nameMatch == null) {
	return null;
	}
	final String name = nameMatch[1];
	final String value = part.split('\n').skip(2).join('\n').trim();
	return <String>[name, value];
	})
	.where((List<String> pair) => pair != null),
	key: (dynamic key) {
	final List<String> pair = key as List<String>;
	return pair[0];
	},
	value: (dynamic value) {
	final List<String> pair = value as List<String>;
	return pair[1];
	},
	);

	return Response(
	'test-report-id',
	200,
	);
	});

	static int sendCalls = 0;
	}

	class CrashingCrashReportSender extends MockClient {
	CrashingCrashReportSender(Object exception) : super((Request request) async {
	throw exception;
	});
	}

	/// Throws a random error to simulate a CLI crash.
	class _CrashCommand extends FlutterCommand {

	@override
	String get description => 'Simulates a crash';

	@override
	String get name => 'crash';

	@override
	Future<FlutterCommandResult> runCommand() async {
	void fn1() {
	throw StateError('Test bad state error');
	}

	void fn2() {
	fn1();
	}

	void fn3() {
	fn2();
	}

	fn3();

	return FlutterCommandResult.success();
	}
	}

	/// Throws StateError from async callback.
	class _CrashAsyncCommand extends FlutterCommand {

	@override
	String get description => 'Simulates a crash';

	@override
	String get name => 'crash';

	@override
	Future<FlutterCommandResult> runCommand() async {
	Timer.run(() {
	throw StateError('Test bad state error');
	});
	return Completer<FlutterCommandResult>().future; // expect StateError
	}
	}

	/// Generates multiple asynchronous unhandled exceptions.
	class _MultiCrashAsyncCommand extends FlutterCommand {
	_MultiCrashAsyncCommand({
	int crashes = 1,
	}) : _crashes = crashes;

	final int _crashes;

	@override
	String get description => 'Simulates a crash';

	@override
	String get name => 'crash';

	@override
	Future<FlutterCommandResult> runCommand() async {
	for (int i = 0; i < _crashes; i++) {
	Timer.run(() {
	throw StateError('Test bad state error');
	});
	}
	return Completer<FlutterCommandResult>().future; // expect StateError
	}
	}

	/// A DoctorValidatorsProvider that overrides the default validators without
	/// overriding the doctor.
	class FakeDoctorValidatorsProvider implements DoctorValidatorsProvider {
	@override
	List<DoctorValidator> get validators => <DoctorValidator>[];

	@override
	List<Workflow> get workflows => <Workflow>[];
	}

	class _NoStderr extends Stdio {
	_NoStderr();

	@override
	IOSink get stderr => const _NoopIOSink();
	}

	class _NoopIOSink implements IOSink {
	const _NoopIOSink();

	@override
	Encoding get encoding => utf8;

	@override
	set encoding(_) => throw UnsupportedError('');

	@override
	void add(_) { }

	@override
	void write(_) { }

	@override
	void writeAll(_, [ __ = '' ]) { }

	@override
	void writeln([ _ = '' ]) { }

	@override
	void writeCharCode(_) { }

	@override
	void addError(_, [ __ ]) { }

	@override
	Future<dynamic> addStream(_) async { }

	@override
	Future<dynamic> flush() async { }

	@override
	Future<dynamic> close() async { }

	@override
	Future<dynamic> get done async { }
	}