overall_experience_test.dart 26.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// 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.

// The purpose of this test is to verify the end-to-end behavior of
// "flutter run" and other such commands, as closely as possible to
// the default behavior. To that end, it avoids the use of any test
// features that are not critical (-dflutter-test being the primary
// example of a test feature that it does use). For example, no use
// is made of "--machine" in these tests.

// There are a number of risks when it comes to writing a test such
// as this one. Typically these tests are hard to debug if they are
// in a failing condition, because they just hang as they await the
// next expected line that never comes. To avoid this, here we have
// the policy of looking for multiple lines, printing what expected
// lines were not seen when a short timeout expires (but timing out
// does not cause the test to fail, to reduce flakes), and wherever
// possible recording all output and comparing the actual output to
// the expected output only once the test is completed.

// To aid in debugging, consider passing the `debug: true` argument
// to the runFlutter function.

25
// This file intentionally assumes the tests run in order.
26
@Tags(<String>['no-shuffle'])
27
library;
28

29 30 31 32 33 34 35 36
import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:meta/meta.dart';
import 'package:process/process.dart';

import '../src/common.dart';
37
import 'test_utils.dart' show fileSystem;
38 39 40 41 42

const ProcessManager processManager = LocalProcessManager();
final String flutterRoot = getFlutterRoot();
final String flutterBin = fileSystem.path.join(flutterRoot, 'bin', 'flutter');

43 44 45 46 47 48 49
void debugPrint(String message) {
  // This is called to intentionally print debugging output when a test is
  // either taking too long or has failed.
  // ignore: avoid_print
  print(message);
}

50
typedef LineHandler = String? Function(String line);
51 52 53 54 55 56 57 58 59

abstract class Transition {
  const Transition({this.handler, this.logging});

  /// Callback that is invoked when the transition matches.
  ///
  /// This should not throw, even if the test is failing. (For example, don't use "expect"
  /// in these callbacks.) Throwing here would prevent the [runFlutter] function from running
  /// to completion, which would leave zombie `flutter` processes around.
60
  final LineHandler? handler;
61 62 63 64

  /// Whether to enable or disable logging when this transition is matched.
  ///
  /// The default value, null, leaves the logging state unaffected.
65
  final bool? logging;
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

  bool matches(String line);

  @protected
  bool lineMatchesPattern(String line, Pattern pattern) {
    if (pattern is String) {
      return line == pattern;
    }
    return line.contains(pattern);
  }

  @protected
  String describe(Pattern pattern) {
    if (pattern is String) {
      return '"$pattern"';
    }
    if (pattern is RegExp) {
      return '/${pattern.pattern}/';
    }
    return '$pattern';
  }
}

class Barrier extends Transition {
90
  const Barrier(this.pattern, {super.handler, super.logging});
91 92 93 94 95 96 97 98 99 100 101
  final Pattern pattern;

  @override
  bool matches(String line) => lineMatchesPattern(line, pattern);

  @override
  String toString() => describe(pattern);
}

class Multiple extends Transition {
  Multiple(List<Pattern> patterns, {
102 103
    super.handler,
    super.logging,
104
  }) : _originalPatterns = patterns,
105
       patterns = patterns.toList();
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

  final List<Pattern> _originalPatterns;
  final List<Pattern> patterns;

  @override
  bool matches(String line) {
    for (int index = 0; index < patterns.length; index += 1) {
      if (lineMatchesPattern(line, patterns[index])) {
        patterns.removeAt(index);
        break;
      }
    }
    return patterns.isEmpty;
  }

  @override
  String toString() {
123
    if (patterns.isEmpty) {
124 125
      return '${_originalPatterns.map(describe).join(', ')} (all matched)';
    }
126
    return '${_originalPatterns.map(describe).join(', ')} (matched ${_originalPatterns.length - patterns.length} so far)';
127 128 129
  }
}

130 131 132 133 134 135 136
class LogLine {
  const LogLine(this.channel, this.stamp, this.message);
  final String channel;
  final String stamp;
  final String message;

  bool get couldBeCrash => message.contains('Oops; flutter has exited unexpectedly:');
137 138

  @override
139
  String toString() => '$stamp $channel: $message';
140

141
  void printClearly() {
142
    debugPrint('$stamp $channel: ${clarify(message)}');
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
  }

  static String clarify(String line) {
    return line.runes.map<String>((int rune) {
      if (rune >= 0x20 && rune <= 0x7F) {
        return String.fromCharCode(rune);
      }
      switch (rune) {
        case 0x00: return '<NUL>';
        case 0x07: return '<BEL>';
        case 0x08: return '<TAB>';
        case 0x09: return '<BS>';
        case 0x0A: return '<LF>';
        case 0x0D: return '<CR>';
      }
      return '<${rune.toRadixString(16).padLeft(rune <= 0xFF ? 2 : rune <= 0xFFFF ? 4 : 5, '0')}>';
159
    }).join();
160
  }
161 162
}

163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
class ProcessTestResult {
  const ProcessTestResult(this.exitCode, this.logs);
  final int exitCode;
  final List<LogLine> logs;

  List<String> get stdout {
    return logs
      .where((LogLine log) => log.channel == 'stdout')
      .map<String>((LogLine log) => log.message)
      .toList();
  }

  List<String> get stderr {
    return logs
      .where((LogLine log) => log.channel == 'stderr')
      .map<String>((LogLine log) => log.message)
      .toList();
  }

  @override
  String toString() => 'exit code $exitCode\nlogs:\n  ${logs.join('\n  ')}\n';
184 185 186 187 188 189 190 191
}

Future<ProcessTestResult> runFlutter(
  List<String> arguments,
  String workingDirectory,
  List<Transition> transitions, {
  bool debug = false,
  bool logging = true,
192
  Duration expectedMaxDuration = const Duration(minutes: 10), // must be less than test timeout of 15 minutes! See ../../dart_test.yaml.
193
}) async {
194
  final Stopwatch clock = Stopwatch()..start();
195 196 197 198
  final Process process = await processManager.start(
    <String>[flutterBin, ...arguments],
    workingDirectory: workingDirectory,
  );
199
  final List<LogLine> logs = <LogLine>[];
200 201 202
  int nextTransition = 0;
  void describeStatus() {
    if (transitions.isNotEmpty) {
203
      debugPrint('Expected state transitions:');
204
      for (int index = 0; index < transitions.length; index += 1) {
205
        debugPrint(
206 207 208 209 210 211
          '${index.toString().padLeft(5)} '
          '${index <  nextTransition ? 'ALREADY MATCHED ' :
             index == nextTransition ? 'NOW WAITING FOR>' :
                                       '                '} ${transitions[index]}');
      }
    }
212
    if (logs.isEmpty) {
213
      debugPrint('So far nothing has been logged${ debug ? "" : "; use debug:true to print all output" }.');
214
    } else {
215
      debugPrint('Log${ debug ? "" : " (only contains logged lines; use debug:true to print all output)" }:');
216 217 218
      for (final LogLine log in logs) {
        log.printClearly();
      }
219 220 221
    }
  }
  bool streamingLogs = false;
222
  Timer? timeout;
223 224 225 226
  void processTimeout() {
    if (!streamingLogs) {
      streamingLogs = true;
      if (!debug) {
227
        debugPrint('Test is taking a long time (${clock.elapsed.inSeconds} seconds so far).');
228 229
      }
      describeStatus();
230
      debugPrint('(streaming all logs from this point on...)');
231
    } else {
232
      debugPrint('(taking a long time...)');
233 234
    }
  }
235
  String stamp() => '[${(clock.elapsed.inMilliseconds / 1000.0).toStringAsFixed(1).padLeft(5)}s]';
236
  void processStdout(String line) {
237
    final LogLine log = LogLine('stdout', stamp(), line);
238
    if (logging) {
239
      logs.add(log);
240 241
    }
    if (streamingLogs) {
242
      log.printClearly();
243 244 245
    }
    if (nextTransition < transitions.length && transitions[nextTransition].matches(line)) {
      if (streamingLogs) {
246
        debugPrint('(matched ${transitions[nextTransition]})');
247 248
      }
      if (transitions[nextTransition].logging != null) {
249
        if (!logging && transitions[nextTransition].logging!) {
250
          logs.add(log);
251
        }
252
        logging = transitions[nextTransition].logging!;
253 254
        if (streamingLogs) {
          if (logging) {
255
            debugPrint('(enabled logging)');
256
          } else {
257
            debugPrint('(disabled logging)');
258 259 260 261
          }
        }
      }
      if (transitions[nextTransition].handler != null) {
262
        final String? command = transitions[nextTransition].handler!(line);
263
        if (command != null) {
264 265
          final LogLine inLog = LogLine('stdin', stamp(), command);
          logs.add(inLog);
266
          if (streamingLogs) {
267
            inLog.printClearly();
268 269 270 271 272 273
          }
          process.stdin.write(command);
        }
      }
      nextTransition += 1;
      timeout?.cancel();
274
      timeout = Timer(expectedMaxDuration ~/ 5, processTimeout); // This is not a failure timeout, just when to start logging verbosely to help debugging.
275 276 277
    }
  }
  void processStderr(String line) {
278 279
    final LogLine log = LogLine('stdout', stamp(), line);
    logs.add(log);
280
    if (streamingLogs) {
281
      log.printClearly();
282 283 284 285 286
    }
  }
  if (debug) {
    processTimeout();
  } else {
287
    timeout = Timer(expectedMaxDuration ~/ 2, processTimeout); // This is not a failure timeout, just when to start logging verbosely to help debugging.
288 289 290
  }
  process.stdout.transform<String>(utf8.decoder).transform<String>(const LineSplitter()).listen(processStdout);
  process.stderr.transform<String>(utf8.decoder).transform<String>(const LineSplitter()).listen(processStderr);
291
  unawaited(process.exitCode.timeout(expectedMaxDuration, onTimeout: () { // This is a failure timeout, must not be short.
292 293
    debugPrint('${stamp()} (process is not quitting, trying to send a "q" just in case that helps)');
    debugPrint('(a functional test should never reach this point)');
294 295 296 297 298
    final LogLine inLog = LogLine('stdin', stamp(), 'q');
    logs.add(inLog);
    if (streamingLogs) {
      inLog.printClearly();
    }
299
    process.stdin.write('q');
300
    return -1; // discarded
301 302 303 304 305 306 307
  }).then(
    (int i) => i,
    onError: (Object error) {
      // ignore errors here, they will be reported on the next line
      return -1; // discarded
    },
  ));
308 309
  final int exitCode = await process.exitCode;
  if (streamingLogs) {
310
    debugPrint('${stamp()} (process terminated with exit code $exitCode)');
311 312 313
  }
  timeout?.cancel();
  if (nextTransition < transitions.length) {
314
    debugPrint('The subprocess terminated before all the expected transitions had been matched.');
315
    if (logs.any((LogLine line) => line.couldBeCrash)) {
316
      debugPrint('The subprocess may in fact have crashed. Check the stderr logs below.');
317
    }
318 319
    debugPrint('The transition that we were hoping to see next but that we never saw was:');
    debugPrint('${nextTransition.toString().padLeft(5)} NOW WAITING FOR> ${transitions[nextTransition]}');
320 321
    if (!streamingLogs) {
      describeStatus();
322
      debugPrint('(process terminated with exit code $exitCode)');
323 324 325 326
    }
    throw TestFailure('Missed some expected transitions.');
  }
  if (streamingLogs) {
327
    debugPrint('${stamp()} (completed execution successfully!)');
328
  }
329
  return ProcessTestResult(exitCode, logs);
330 331
}

332 333
const int progressMessageWidth = 64;

334 335 336 337 338
void main() {
  testWithoutContext('flutter run writes and clears pidfile appropriately', () async {
    final String tempDirectory = fileSystem.systemTempDirectory.createTempSync('flutter_overall_experience_test.').resolveSymbolicLinksSync();
    final String pidFile = fileSystem.path.join(tempDirectory, 'flutter.pid');
    final String testDirectory = fileSystem.path.join(flutterRoot, 'examples', 'hello_world');
339
    bool? existsDuringTest;
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
    try {
      expect(fileSystem.file(pidFile).existsSync(), isFalse);
      final ProcessTestResult result = await runFlutter(
        <String>['run', '-dflutter-tester', '--pid-file', pidFile],
        testDirectory,
        <Transition>[
          Barrier('q Quit (terminate the application on the device).', handler: (String line) {
            existsDuringTest = fileSystem.file(pidFile).existsSync();
            return 'q';
          }),
          const Barrier('Application finished.'),
        ],
      );
      expect(existsDuringTest, isNot(isNull));
      expect(existsDuringTest, isTrue);
      expect(result.exitCode, 0, reason: 'subprocess failed; $result');
      expect(fileSystem.file(pidFile).existsSync(), isFalse);
      // This first test ignores the stdout and stderr, so that if the
      // first run outputs "building flutter", or the "there's a new
      // flutter" banner, or other such first-run messages, they won't
      // fail the tests. This does mean that running this test first is
      // actually important in the case where you're running the tests
      // manually. (On CI, all those messages are expected to be seen
      // long before we get here, e.g. because we run "flutter doctor".)
    } finally {
      tryToDelete(fileSystem.directory(tempDirectory));
    }
367
  }, skip: Platform.isWindows); // [intended] Windows doesn't support sending signals so we don't care if it can store the PID.
368 369 370 371 372
  testWithoutContext('flutter run handle SIGUSR1/2', () async {
    final String tempDirectory = fileSystem.systemTempDirectory.createTempSync('flutter_overall_experience_test.').resolveSymbolicLinksSync();
    final String pidFile = fileSystem.path.join(tempDirectory, 'flutter.pid');
    final String testDirectory = fileSystem.path.join(flutterRoot, 'dev', 'integration_tests', 'ui');
    final String testScript = fileSystem.path.join('lib', 'commands.dart');
373
    late int pid;
374 375 376 377 378
    try {
      final ProcessTestResult result = await runFlutter(
        <String>['run', '-dflutter-tester', '--report-ready', '--pid-file', pidFile, '--no-devtools', testScript],
        testDirectory,
        <Transition>[
379
          Multiple(<Pattern>['Flutter run key commands.', 'called paint'], handler: (String line) {
380 381 382 383
            pid = int.parse(fileSystem.file(pidFile).readAsStringSync());
            processManager.killPid(pid, ProcessSignal.sigusr1);
            return null;
          }),
384
          Barrier('Performing hot reload...'.padRight(progressMessageWidth), logging: true),
385
          Multiple(<Pattern>[RegExp(r'^Reloaded 0 libraries in [0-9]+ms \(compile: \d+ ms, reload: \d+ ms, reassemble: \d+ ms\)\.$'), 'called reassemble', 'called paint'], handler: (String line) {
386 387 388
            processManager.killPid(pid, ProcessSignal.sigusr2);
            return null;
          }),
389
          Barrier('Performing hot restart...'.padRight(progressMessageWidth)),
390 391
          // This could look like 'Restarted application in 1,237ms.'
          Multiple(<Pattern>[RegExp(r'^Restarted application in .+m?s.$'), 'called main', 'called paint'], handler: (String line) {
392 393 394 395 396 397 398 399 400
            return 'q';
          }),
          const Barrier('Application finished.'),
        ],
        logging: false, // we ignore leading log lines to avoid making this test sensitive to e.g. the help message text
      );
      // We check the output from the app (all starts with "called ...") and the output from the tool
      // (everything else) separately, because their relative timing isn't guaranteed. Their rough timing
      // is verified by the expected transitions above.
401
      expect(result.stdout.where((String line) => line.startsWith('called ')), <Object>[
402 403
        // logs start after we receive the response to sending SIGUSR1
        // SIGUSR1:
404
        'called reassemble',
405 406
        'called paint',
        // SIGUSR2:
407
        'called main',
408 409 410 411
        'called paint',
      ]);
      expect(result.stdout.where((String line) => !line.startsWith('called ')), <Object>[
        // logs start after we receive the response to sending SIGUSR1
412
        'Performing hot reload...'.padRight(progressMessageWidth),
413
        startsWith('Reloaded 0 libraries in '),
414
        'Performing hot restart...'.padRight(progressMessageWidth),
415 416 417 418 419 420 421 422 423
        startsWith('Restarted application in '),
        '', // this newline is the one for after we hit "q"
        'Application finished.',
        'ready',
      ]);
      expect(result.exitCode, 0);
    } finally {
      tryToDelete(fileSystem.directory(tempDirectory));
    }
424
  }, skip: Platform.isWindows); // [intended] Windows doesn't support sending signals.
425 426 427 428 429 430 431 432 433 434

  testWithoutContext('flutter run can hot reload and hot restart, handle "p" key', () async {
    final String tempDirectory = fileSystem.systemTempDirectory.createTempSync('flutter_overall_experience_test.').resolveSymbolicLinksSync();
    final String testDirectory = fileSystem.path.join(flutterRoot, 'dev', 'integration_tests', 'ui');
    final String testScript = fileSystem.path.join('lib', 'commands.dart');
    try {
      final ProcessTestResult result = await runFlutter(
        <String>['run', '-dflutter-tester', '--report-ready', '--no-devtools', testScript],
        testDirectory,
        <Transition>[
435
          Multiple(<Pattern>['Flutter run key commands.', 'called main', 'called paint'], handler: (String line) {
436 437
            return 'r';
          }),
438 439
          Barrier('Performing hot reload...'.padRight(progressMessageWidth), logging: true),
          Multiple(<Pattern>['ready', 'called reassemble', 'called paint'], handler: (String line) {
440 441
            return 'R';
          }),
442
          Barrier('Performing hot restart...'.padRight(progressMessageWidth)),
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
          Multiple(<Pattern>['ready', 'called main', 'called paint'], handler: (String line) {
            return 'p';
          }),
          Multiple(<Pattern>['ready', 'called paint', 'called debugPaintSize'], handler: (String line) {
            return 'p';
          }),
          Multiple(<Pattern>['ready', 'called paint'], handler: (String line) {
            return 'q';
          }),
          const Barrier('Application finished.'),
        ],
        logging: false, // we ignore leading log lines to avoid making this test sensitive to e.g. the help message text
      );
      // We check the output from the app (all starts with "called ...") and the output from the tool
      // (everything else) separately, because their relative timing isn't guaranteed. Their rough timing
      // is verified by the expected transitions above.
459 460
      expect(result.stdout.where((String line) => line.startsWith('called ')), <Object>[
        // logs start after we initiate the hot reload
461
        // hot reload:
462
        'called reassemble',
463 464 465 466 467 468 469 470 471 472 473 474
        'called paint',
        // hot restart:
        'called main',
        'called paint',
        // debugPaintSizeEnabled = true:
        'called paint',
        'called debugPaintSize',
        // debugPaintSizeEnabled = false:
        'called paint',
      ]);
      expect(result.stdout.where((String line) => !line.startsWith('called ')), <Object>[
        // logs start after we receive the response to hitting "r"
475
        'Performing hot reload...'.padRight(progressMessageWidth),
476 477 478
        startsWith('Reloaded 0 libraries in '),
        'ready',
        '', // this newline is the one for after we hit "R"
479
        'Performing hot restart...'.padRight(progressMessageWidth),
480 481 482 483 484 485 486 487 488 489 490 491 492 493
        startsWith('Restarted application in '),
        'ready',
        '', // newline for after we hit "p" the first time
        'ready',
        '', // newline for after we hit "p" the second time
        'ready',
        '', // this newline is the one for after we hit "q"
        'Application finished.',
        'ready',
      ]);
      expect(result.exitCode, 0);
    } finally {
      tryToDelete(fileSystem.directory(tempDirectory));
    }
494
  });
495 496 497

  testWithoutContext('flutter error messages include a DevTools link', () async {
    final String testDirectory = fileSystem.path.join(flutterRoot, 'dev', 'integration_tests', 'ui');
498
    final String tempDirectory = fileSystem.systemTempDirectory.createTempSync('flutter_overall_experience_test.').resolveSymbolicLinksSync();
499 500 501 502 503 504
    final String testScript = fileSystem.path.join('lib', 'overflow.dart');
    try {
      final ProcessTestResult result = await runFlutter(
        <String>['run', '-dflutter-tester', testScript],
        testDirectory,
        <Transition>[
505
          Barrier(RegExp(r'^A Dart VM Service on Flutter test device is available at: ')),
506 507 508
          Barrier(RegExp(r'^The Flutter DevTools debugger and profiler on Flutter test device is available at: '), handler: (String line) {
            return 'r';
          }),
509
          Barrier('Performing hot reload...'.padRight(progressMessageWidth), logging: true),
510 511 512 513 514 515 516
          Barrier(RegExp(r'^Reloaded 0 libraries in [0-9]+ms.'), handler: (String line) {
            return 'q';
          }),
        ],
        logging: false,
      );
      expect(result.exitCode, 0);
517
      expect(result.stdout, <Object>[
518
        startsWith('Performing hot reload...'),
519
        '',
520 521 522 523 524
        '══╡ EXCEPTION CAUGHT BY RENDERING LIBRARY ╞═════════════════════════════════════════════════════════',
        'The following assertion was thrown during layout:',
        'A RenderFlex overflowed by 69200 pixels on the right.',
        '',
        'The relevant error-causing widget was:',
525
        matches(RegExp(r'^  Row .+flutter/dev/integration_tests/ui/lib/overflow\.dart:32:18$')),
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
        '',
        'To inspect this widget in Flutter DevTools, visit:',
        startsWith('http'),
        '',
        'The overflowing RenderFlex has an orientation of Axis.horizontal.',
        'The edge of the RenderFlex that is overflowing has been marked in the rendering with a yellow and',
        'black striped pattern. This is usually caused by the contents being too big for the RenderFlex.',
        'Consider applying a flex factor (e.g. using an Expanded widget) to force the children of the',
        'RenderFlex to fit within the available space instead of being sized to their natural size.',
        'This is considered an error condition because it indicates that there is content that cannot be',
        'seen. If the content is legitimately bigger than the available space, consider clipping it with a',
        'ClipRect widget before putting it in the flex, or using a scrollable container rather than a Flex,',
        'like a ListView.',
        matches(RegExp(r'^The specific RenderFlex in question is: RenderFlex#..... OVERFLOWING:$')),
        startsWith('  creator: Row ← Test ← '),
        contains(' ← '),
542
        endsWith(' ⋯'),
543 544 545 546 547 548 549 550 551 552 553
        '  parentData: <none> (can use size)',
        '  constraints: BoxConstraints(w=800.0, h=600.0)',
        '  size: Size(800.0, 600.0)',
        '  direction: horizontal',
        '  mainAxisAlignment: start',
        '  mainAxisSize: max',
        '  crossAxisAlignment: center',
        '  textDirection: ltr',
        '  verticalDirection: down',
        '◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤',
        '════════════════════════════════════════════════════════════════════════════════════════════════════',
554
        '',
555 556 557 558 559 560 561
        startsWith('Reloaded 0 libraries in '),
        '',
        'Application finished.',
      ]);
    } finally {
      tryToDelete(fileSystem.directory(tempDirectory));
    }
562
  });
563 564 565 566 567 568

  testWithoutContext('flutter run help output', () async {
    // This test enables all logging so that it checks the exact text of starting up an application.
    // The idea is to verify that we're not outputting spurious messages.
    // WHEN EDITING THIS TEST PLEASE CAREFULLY CONSIDER WHETHER THE NEW OUTPUT IS AN IMPROVEMENT.
    final String testDirectory = fileSystem.path.join(flutterRoot, 'examples', 'hello_world');
569
    final RegExp finalLine = RegExp(r'^The Flutter DevTools');
570
    final ProcessTestResult result = await runFlutter(
571
      <String>['run', '-dflutter-tester'],
572 573 574 575 576 577 578 579 580 581 582 583 584
      testDirectory,
      <Transition>[
        Barrier(finalLine, handler: (String line) {
          return 'h';
        }),
        Barrier(finalLine, handler: (String line) {
          return 'q';
        }),
        const Barrier('Application finished.'),
      ],
    );
    expect(result.exitCode, 0);
    expect(result.stderr, isEmpty);
585
    expect(result.stdout, containsAllInOrder(<Object>[
586 587 588 589 590 591
      startsWith('Launching '),
      startsWith('Syncing files to device Flutter test device...'),
      '',
      'Flutter run key commands.',
      startsWith('r Hot reload.'),
      'R Hot restart.',
592
      'h List all available interactive commands.',
593 594 595 596
      'd Detach (terminate "flutter run" but leave application running).',
      'c Clear the screen',
      'q Quit (terminate the application on the device).',
      '',
597
      startsWith('A Dart VM Service on Flutter test device is available at: http://'),
598
      startsWith('The Flutter DevTools debugger and profiler on Flutter test device is available at: http://'),
599 600 601 602
      '',
      'Flutter run key commands.',
      startsWith('r Hot reload.'),
      'R Hot restart.',
603
      'v Open Flutter DevTools.',
604 605 606
      'w Dump widget hierarchy to the console.                                               (debugDumpApp)',
      't Dump rendering tree to the console.                                          (debugDumpRenderTree)',
      'L Dump layer tree to the console.                                               (debugDumpLayerTree)',
607
      'f Dump focus tree to the console.                                               (debugDumpFocusTree)',
608 609 610 611
      'S Dump accessibility tree in traversal order.                                   (debugDumpSemantics)',
      'U Dump accessibility tree in inverse hit test order.                            (debugDumpSemantics)',
      'i Toggle widget inspector.                                  (WidgetsApp.showWidgetInspectorOverride)',
      'p Toggle the display of construction lines.                                  (debugPaintSizeEnabled)',
612
      'I Toggle oversized image inversion.                                     (debugInvertOversizedImages)',
613
      'o Simulate different operating systems.                                      (defaultTargetPlatform)',
614
      'b Toggle platform brightness (dark and light mode).                        (debugBrightnessOverride)',
615 616
      'P Toggle performance overlay.                                    (WidgetsApp.showPerformanceOverlay)',
      'a Toggle timeline events for all widget build methods.                    (debugProfileWidgetBuilds)',
617 618
      'M Write SkSL shaders to a unique file in the project directory.',
      'g Run source code generators.',
619
      'j Dump frame raster stats for the current frame. (Unsupported for web)',
620 621 622 623
      'h Repeat this help message.',
      'd Detach (terminate "flutter run" but leave application running).',
      'c Clear the screen',
      'q Quit (terminate the application on the device).',
624
      '',
625
      startsWith('A Dart VM Service on Flutter test device is available at: http://'),
626
      startsWith('The Flutter DevTools debugger and profiler on Flutter test device is available at: http://'),
627 628
      '',
      'Application finished.',
629
    ]));
630
  });
631
}