mirror of
https://github.com/flutter/flutter
synced 2024-08-25 02:46:31 +00:00
![Ian Hickson](/assets/img/avatar_default.png)
Each error section is numbered, so you can all be sure you're talking about the same one. A message is printed at the very end telling you how to find the error blocks in the verbose logs.
225 lines
8 KiB
Dart
225 lines
8 KiB
Dart
// 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 'dart:core' hide print;
|
|
import 'dart:io' as io;
|
|
|
|
import 'package:path/path.dart' as path;
|
|
|
|
import 'utils.dart';
|
|
|
|
/// Runs the `executable` and returns standard output as a stream of lines.
|
|
///
|
|
/// The returned stream reaches its end immediately after the command exits.
|
|
///
|
|
/// If `expectNonZeroExit` is false and the process exits with a non-zero exit
|
|
/// code fails the test immediately by exiting the test process with exit code
|
|
/// 1.
|
|
Stream<String> runAndGetStdout(String executable, List<String> arguments, {
|
|
String? workingDirectory,
|
|
Map<String, String>? environment,
|
|
bool expectNonZeroExit = false,
|
|
}) async* {
|
|
final StreamController<String> output = StreamController<String>();
|
|
final Future<CommandResult?> command = runCommand(
|
|
executable,
|
|
arguments,
|
|
workingDirectory: workingDirectory,
|
|
environment: environment,
|
|
expectNonZeroExit: expectNonZeroExit,
|
|
// Capture the output so it's not printed to the console by default.
|
|
outputMode: OutputMode.capture,
|
|
outputListener: (String line, io.Process process) {
|
|
output.add(line);
|
|
},
|
|
);
|
|
|
|
// Close the stream controller after the command is complete. Otherwise,
|
|
// the yield* will never finish.
|
|
command.whenComplete(output.close);
|
|
|
|
yield* output.stream;
|
|
}
|
|
|
|
/// Represents a running process launched using [startCommand].
|
|
class Command {
|
|
Command._(this.process, this._time, this._savedStdout, this._savedStderr);
|
|
|
|
/// The raw process that was launched for this command.
|
|
final io.Process process;
|
|
final Stopwatch _time;
|
|
final Future<String> _savedStdout;
|
|
final Future<String> _savedStderr;
|
|
}
|
|
|
|
/// The result of running a command using [startCommand] and [runCommand];
|
|
class CommandResult {
|
|
CommandResult._(this.exitCode, this.elapsedTime, this.flattenedStdout, this.flattenedStderr);
|
|
|
|
/// The exit code of the process.
|
|
final int exitCode;
|
|
|
|
/// The amount of time it took the process to complete.
|
|
final Duration elapsedTime;
|
|
|
|
/// Standard output decoded as a string using UTF8 decoder.
|
|
final String? flattenedStdout;
|
|
|
|
/// Standard error output decoded as a string using UTF8 decoder.
|
|
final String? flattenedStderr;
|
|
}
|
|
|
|
/// Starts the `executable` and returns a command object representing the
|
|
/// running process.
|
|
///
|
|
/// `outputListener` is called for every line of standard output from the
|
|
/// process, and is given the [Process] object. This can be used to interrupt
|
|
/// an indefinitely running process, for example, by waiting until the process
|
|
/// emits certain output.
|
|
///
|
|
/// `outputMode` controls where the standard output from the command process
|
|
/// goes. See [OutputMode].
|
|
Future<Command> startCommand(String executable, List<String> arguments, {
|
|
String? workingDirectory,
|
|
Map<String, String>? environment,
|
|
OutputMode outputMode = OutputMode.print,
|
|
bool Function(String)? removeLine,
|
|
void Function(String, io.Process)? outputListener,
|
|
}) async {
|
|
final String relativeWorkingDir = path.relative(workingDirectory ?? io.Directory.current.path);
|
|
final String commandDescription = '${path.relative(executable, from: workingDirectory)} ${arguments.join(' ')}';
|
|
print('RUNNING: cd $cyan$relativeWorkingDir$reset; $green$commandDescription$reset');
|
|
|
|
final Stopwatch time = Stopwatch()..start();
|
|
print('workingDirectory: $workingDirectory, executable: $executable, arguments: $arguments');
|
|
final io.Process process = await io.Process.start(executable, arguments,
|
|
workingDirectory: workingDirectory,
|
|
environment: environment,
|
|
);
|
|
return Command._(
|
|
process,
|
|
time,
|
|
process.stdout
|
|
.transform<String>(const Utf8Decoder())
|
|
.transform(const LineSplitter())
|
|
.where((String line) => removeLine == null || !removeLine(line))
|
|
.map<String>((String line) {
|
|
final String formattedLine = '$line\n';
|
|
if (outputListener != null) {
|
|
outputListener(formattedLine, process);
|
|
}
|
|
switch (outputMode) {
|
|
case OutputMode.print:
|
|
print(line);
|
|
case OutputMode.capture:
|
|
break;
|
|
}
|
|
return line;
|
|
})
|
|
.join('\n'),
|
|
process.stderr
|
|
.transform<String>(const Utf8Decoder())
|
|
.transform(const LineSplitter())
|
|
.map<String>((String line) {
|
|
switch (outputMode) {
|
|
case OutputMode.print:
|
|
print(line);
|
|
case OutputMode.capture:
|
|
break;
|
|
}
|
|
return line;
|
|
})
|
|
.join('\n'),
|
|
);
|
|
}
|
|
|
|
/// Runs the `executable` and waits until the process exits.
|
|
///
|
|
/// If the process exits with a non-zero exit code and `expectNonZeroExit` is
|
|
/// false, calls foundError (which does not terminate execution!).
|
|
///
|
|
/// `outputListener` is called for every line of standard output from the
|
|
/// process, and is given the [Process] object. This can be used to interrupt
|
|
/// an indefinitely running process, for example, by waiting until the process
|
|
/// emits certain output.
|
|
///
|
|
/// Returns the result of the finished process.
|
|
///
|
|
/// `outputMode` controls where the standard output from the command process
|
|
/// goes. See [OutputMode].
|
|
Future<CommandResult> runCommand(String executable, List<String> arguments, {
|
|
String? workingDirectory,
|
|
Map<String, String>? environment,
|
|
bool expectNonZeroExit = false,
|
|
int? expectedExitCode,
|
|
String? failureMessage,
|
|
OutputMode outputMode = OutputMode.print,
|
|
bool Function(String)? removeLine,
|
|
void Function(String, io.Process)? outputListener,
|
|
}) async {
|
|
final String commandDescription = '${path.relative(executable, from: workingDirectory)} ${arguments.join(' ')}';
|
|
final String relativeWorkingDir = workingDirectory ?? path.relative(io.Directory.current.path);
|
|
|
|
final Command command = await startCommand(executable, arguments,
|
|
workingDirectory: workingDirectory,
|
|
environment: environment,
|
|
outputMode: outputMode,
|
|
removeLine: removeLine,
|
|
outputListener: outputListener,
|
|
);
|
|
|
|
final CommandResult result = CommandResult._(
|
|
await command.process.exitCode,
|
|
command._time.elapsed,
|
|
await command._savedStdout,
|
|
await command._savedStderr,
|
|
);
|
|
|
|
if ((result.exitCode == 0) == expectNonZeroExit || (expectedExitCode != null && result.exitCode != expectedExitCode)) {
|
|
// Print the output when we get unexpected results (unless output was
|
|
// printed already).
|
|
switch (outputMode) {
|
|
case OutputMode.print:
|
|
break;
|
|
case OutputMode.capture:
|
|
print(result.flattenedStdout);
|
|
print(result.flattenedStderr);
|
|
}
|
|
final String allOutput = '${result.flattenedStdout}\n${result.flattenedStderr}';
|
|
foundError(<String>[
|
|
if (failureMessage != null)
|
|
failureMessage,
|
|
'${bold}Command: $green$commandDescription$reset',
|
|
if (failureMessage == null)
|
|
'$bold${red}Command exited with exit code ${result.exitCode} but expected ${expectNonZeroExit ? (expectedExitCode ?? 'non-zero') : 'zero'} exit code.$reset',
|
|
'${bold}Working directory: $cyan${path.absolute(relativeWorkingDir)}$reset',
|
|
if (allOutput.isNotEmpty && allOutput.length < 512)
|
|
'${bold}stdout and stderr output:\n$allOutput',
|
|
]);
|
|
} else {
|
|
print('ELAPSED TIME: ${prettyPrintDuration(result.elapsedTime)} for $green$commandDescription$reset in $cyan$relativeWorkingDir$reset');
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// Specifies what to do with the command output from [runCommand] and [startCommand].
|
|
enum OutputMode {
|
|
/// Forwards standard output and standard error streams to the test process'
|
|
/// standard output stream (i.e. stderr is redirected to stdout).
|
|
///
|
|
/// Use this mode if all you want is print the output of the command to the
|
|
/// console. The output is no longer available after the process exits.
|
|
print,
|
|
|
|
/// Saves standard output and standard error streams in memory.
|
|
///
|
|
/// Captured output can be retrieved from the [CommandResult] object.
|
|
///
|
|
/// Use this mode in tests that need to inspect the output of a command, or
|
|
/// when the output should not be printed to console.
|
|
capture,
|
|
}
|