hot_test.dart 25.9 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
// @dart = 2.8

7
import 'package:file/memory.dart';
8
import 'package:flutter_tools/src/application_package.dart';
9
import 'package:flutter_tools/src/artifacts.dart';
10
import 'package:flutter_tools/src/asset.dart';
11
import 'package:flutter_tools/src/base/file_system.dart';
12
import 'package:flutter_tools/src/base/io.dart';
13
import 'package:flutter_tools/src/base/platform.dart';
14
import 'package:flutter_tools/src/build_info.dart';
15
import 'package:flutter_tools/src/compile.dart';
16
import 'package:flutter_tools/src/devfs.dart';
17
import 'package:flutter_tools/src/device.dart';
18
import 'package:flutter_tools/src/reporting/reporting.dart';
19
import 'package:flutter_tools/src/resident_devtools_handler.dart';
20
import 'package:flutter_tools/src/resident_runner.dart';
21
import 'package:flutter_tools/src/run_hot.dart';
22
import 'package:flutter_tools/src/vmservice.dart';
23
import 'package:meta/meta.dart';
24
import 'package:package_config/package_config.dart';
25
import 'package:test/fake.dart';
26
import 'package:vm_service/vm_service.dart' as vm_service;
27

28 29
import '../src/common.dart';
import '../src/context.dart';
30
import '../src/fake_vm_services.dart';
31
import '../src/fakes.dart';
32

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
final vm_service.Isolate fakeUnpausedIsolate = vm_service.Isolate(
  id: '1',
  pauseEvent: vm_service.Event(
    kind: vm_service.EventKind.kResume,
    timestamp: 0
  ),
  breakpoints: <vm_service.Breakpoint>[],
  exceptionPauseMode: null,
  libraries: <vm_service.LibraryRef>[],
  livePorts: 0,
  name: 'test',
  number: '1',
  pauseOnExit: false,
  runnable: true,
  startTime: 0,
48
  isSystemIsolate: false,
49
  isolateFlags: <vm_service.IsolateFlag>[],
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
);

final FlutterView fakeFlutterView = FlutterView(
  id: 'a',
  uiIsolate: fakeUnpausedIsolate,
);

final FakeVmServiceRequest listViews = FakeVmServiceRequest(
  method: kListViewsMethod,
  jsonResponse: <String, Object>{
    'views': <Object>[
      fakeFlutterView.toJson(),
    ],
  },
);
65

66
void main() {
67 68
  group('validateReloadReport', () {
    testUsingContext('invalid', () async {
69
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
70 71 72
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{},
73 74
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
75 76 77 78 79 80
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{
          'notices': <Map<String, dynamic>>[
          ],
        },
81 82
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
83 84 85 86 87 88 89
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{
          'notices': <String, dynamic>{
            'message': 'error',
          },
        },
90 91
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
92 93 94 95 96
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{
          'notices': <Map<String, dynamic>>[],
        },
97 98
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
99 100 101 102
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{
          'notices': <Map<String, dynamic>>[
103
            <String, dynamic>{'message': false},
104 105
          ],
        },
106 107
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
108 109 110 111
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{
          'notices': <Map<String, dynamic>>[
112
            <String, dynamic>{'message': <String>['error']},
113 114
          ],
        },
115 116
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
117 118 119 120
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{
          'notices': <Map<String, dynamic>>[
121 122
            <String, dynamic>{'message': 'error'},
            <String, dynamic>{'message': <String>['error']},
123 124
          ],
        },
125 126
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
127 128 129 130
        'type': 'ReloadReport',
        'success': false,
        'details': <String, dynamic>{
          'notices': <Map<String, dynamic>>[
131
            <String, dynamic>{'message': 'error'},
132 133
          ],
        },
134 135
      })), false);
      expect(HotRunner.validateReloadReport(vm_service.ReloadReport.parse(<String, dynamic>{
136 137
        'type': 'ReloadReport',
        'success': true,
138 139 140 141 142 143 144 145 146
      })), true);
    });

    testWithoutContext('ReasonForCancelling toString has a hint for specific errors', () {
      final ReasonForCancelling reasonForCancelling = ReasonForCancelling(
        message: 'Const class cannot remove fields',
      );

      expect(reasonForCancelling.toString(), contains('Try performing a hot restart instead.'));
147 148
    });
  });
149 150

  group('hotRestart', () {
151
    final FakeResidentCompiler residentCompiler = FakeResidentCompiler();
152
    FileSystem fileSystem;
153
    TestUsage testUsage;
154 155

    setUp(() {
156
      fileSystem = MemoryFileSystem.test();
157
      testUsage = TestUsage();
158 159
    });

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
    group('fails to setup', () {
      TestHotRunnerConfig failingTestingConfig;
      setUp(() {
        failingTestingConfig = TestHotRunnerConfig(
          successfulHotRestartSetup: false,
          successfulHotReloadSetup: false,
        );
      });

      testUsingContext('setupHotRestart function fails', () async {
        fileSystem.file('.packages')
          ..createSync(recursive: true)
          ..writeAsStringSync('\n');
        final FakeDevice device = FakeDevice();
        final List<FlutterDevice> devices = <FlutterDevice>[
          FlutterDevice(device, generator: residentCompiler, buildInfo: BuildInfo.debug)..devFS = FakeDevFs(),
        ];
        final OperationResult result = await HotRunner(
          devices,
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
          devtoolsHandler: createNoOpHandler,
        ).restart(fullRestart: true);
        expect(result.isOk, false);
        expect(result.message, 'setupHotRestart failed');
        expect(failingTestingConfig.updateDevFSCompleteCalled, false);
      }, overrides: <Type, Generator>{
        HotRunnerConfig: () => failingTestingConfig,
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
      });

      testUsingContext('setupHotReload function fails', () async {
        fileSystem.file('.packages')
          ..createSync(recursive: true)
          ..writeAsStringSync('\n');
        final FakeDevice device = FakeDevice();
        final FakeFlutterDevice fakeFlutterDevice = FakeFlutterDevice(device);
        final List<FlutterDevice> devices = <FlutterDevice>[
          fakeFlutterDevice,
        ];
        final OperationResult result = await HotRunner(
          devices,
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
          devtoolsHandler: createNoOpHandler,
          reassembleHelper: (
            List<FlutterDevice> flutterDevices,
            Map<FlutterDevice, List<FlutterView>> viewCache,
            void Function(String message) onSlow,
            String reloadMessage,
            String fastReassembleClassName,
          ) async => ReassembleResult(
              <FlutterView, FlutterVmService>{null: null},
              false,
              true,
            ),
        ).restart(fullRestart: false);
        expect(result.isOk, false);
        expect(result.message, 'setupHotReload failed');
        expect(failingTestingConfig.updateDevFSCompleteCalled, false);
      }, overrides: <Type, Generator>{
        HotRunnerConfig: () => failingTestingConfig,
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
      });
230
    });
231

232 233 234 235
    group('shutdown hook tests', () {
      TestHotRunnerConfig shutdownTestingConfig;

      setUp(() {
236
        shutdownTestingConfig = TestHotRunnerConfig();
237 238 239
      });

      testUsingContext('shutdown hook called after signal', () async {
240
        fileSystem.file('.packages')
241 242
          ..createSync(recursive: true)
          ..writeAsStringSync('\n');
243
        final FakeDevice device = FakeDevice();
244
        final List<FlutterDevice> devices = <FlutterDevice>[
245
          FlutterDevice(device, generator: residentCompiler, buildInfo: BuildInfo.debug),
246
        ];
247 248
        await HotRunner(
          devices,
249 250
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
251
        ).cleanupAfterSignal();
252
        expect(shutdownTestingConfig.shutdownHookCalled, true);
253
      }, overrides: <Type, Generator>{
254
        HotRunnerConfig: () => shutdownTestingConfig,
255 256 257 258
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
259 260 261
      });

      testUsingContext('shutdown hook called after app stop', () async {
262
        fileSystem.file('.packages')
263 264
          ..createSync(recursive: true)
          ..writeAsStringSync('\n');
265
        final FakeDevice device = FakeDevice();
266
        final List<FlutterDevice> devices = <FlutterDevice>[
267
          FlutterDevice(device, generator: residentCompiler, buildInfo: BuildInfo.debug),
268
        ];
269 270
        await HotRunner(
          devices,
271 272
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
273
        ).preExit();
274
        expect(shutdownTestingConfig.shutdownHookCalled, true);
275
      }, overrides: <Type, Generator>{
276
        HotRunnerConfig: () => shutdownTestingConfig,
277 278 279 280
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
281 282
      });
    });
283

284 285 286 287 288 289 290 291 292 293 294 295 296
    group('successful hot restart', () {
      TestHotRunnerConfig testingConfig;
      setUp(() {
        testingConfig = TestHotRunnerConfig(
          successfulHotRestartSetup: true,
        );
      });
      testUsingContext('correctly tracks time spent for analytics for hot restart', () async {
        final FakeDevice device = FakeDevice();
        final FakeFlutterDevice fakeFlutterDevice = FakeFlutterDevice(device);
        final List<FlutterDevice> devices = <FlutterDevice>[
          fakeFlutterDevice,
        ];
297

298 299 300 301 302 303 304 305
        fakeFlutterDevice.updateDevFSReportCallback = () async => UpdateFSReport(
          success: true,
          invalidatedSourcesCount: 2,
          syncedBytes: 4,
          scannedSourcesCount: 8,
          compileDuration: const Duration(seconds: 16),
          transferDuration: const Duration(seconds: 32),
        );
306

307 308 309 310 311 312
        final FakeStopwatchFactory fakeStopwatchFactory = FakeStopwatchFactory(
          stopwatches: <String, Stopwatch>{
            'fullRestartHelper': FakeStopwatch()..elapsed = const Duration(seconds: 64),
            'updateDevFS': FakeStopwatch()..elapsed = const Duration(seconds: 128),
          },
        );
313

314
        (fakeFlutterDevice.devFS as FakeDevFs).baseUri = Uri.parse('file:///base_uri');
315

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
        final OperationResult result = await HotRunner(
          devices,
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
          devtoolsHandler: createNoOpHandler,
          stopwatchFactory: fakeStopwatchFactory,
        ).restart(fullRestart: true);

        expect(result.isOk, true);
        expect(testUsage.events, <TestUsageEvent>[
          const TestUsageEvent('hot', 'restart', parameters: CustomDimensions(
            hotEventTargetPlatform: 'flutter-tester',
            hotEventSdkName: 'Tester',
            hotEventEmulator: false,
            hotEventFullRestart: true,
            hotEventOverallTimeInMs: 64000,
            hotEventSyncedBytes: 4,
            hotEventInvalidatedSourcesCount: 2,
            hotEventTransferTimeInMs: 32000,
            hotEventCompileTimeInMs: 16000,
            hotEventFindInvalidatedTimeInMs: 128000,
            hotEventScannedSourcesCount: 8,
          )),
        ]);
        expect(testingConfig.updateDevFSCompleteCalled, true);
      }, overrides: <Type, Generator>{
        HotRunnerConfig: () => testingConfig,
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
        Usage: () => testUsage,
      });
349 350
    });

351 352 353 354 355 356 357 358 359 360 361 362 363
    group('successful hot reload', () {
      TestHotRunnerConfig testingConfig;
      setUp(() {
        testingConfig = TestHotRunnerConfig(
          successfulHotReloadSetup: true,
        );
      });
      testUsingContext('correctly tracks time spent for analytics for hot reload', () async {
        final FakeDevice device = FakeDevice();
        final FakeFlutterDevice fakeFlutterDevice = FakeFlutterDevice(device);
        final List<FlutterDevice> devices = <FlutterDevice>[
          fakeFlutterDevice,
        ];
364

365 366 367 368 369 370 371 372
        fakeFlutterDevice.updateDevFSReportCallback = () async => UpdateFSReport(
          success: true,
          invalidatedSourcesCount: 6,
          syncedBytes: 8,
          scannedSourcesCount: 16,
          compileDuration: const Duration(seconds: 16),
          transferDuration: const Duration(seconds: 32),
        );
373

374 375 376 377 378 379 380 381
        final FakeStopwatchFactory fakeStopwatchFactory = FakeStopwatchFactory(
          stopwatches: <String, Stopwatch>{
            'updateDevFS': FakeStopwatch()..elapsed = const Duration(seconds: 64),
            'reloadSources:reload': FakeStopwatch()..elapsed = const Duration(seconds: 128),
            'reloadSources:reassemble': FakeStopwatch()..elapsed = const Duration(seconds: 256),
            'reloadSources:vm': FakeStopwatch()..elapsed = const Duration(seconds: 512),
          },
        );
382

383
        (fakeFlutterDevice.devFS as FakeDevFs).baseUri = Uri.parse('file:///base_uri');
384

385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
        final OperationResult result = await HotRunner(
          devices,
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
          devtoolsHandler: createNoOpHandler,
          stopwatchFactory: fakeStopwatchFactory,
          reloadSourcesHelper: (
            HotRunner hotRunner,
            List<FlutterDevice> flutterDevices,
            bool pause,
            Map<String, dynamic> firstReloadDetails,
            String targetPlatform,
            String sdkName,
            bool emulator,
            String reason,
          ) async {
            firstReloadDetails['finalLibraryCount'] = 2;
            firstReloadDetails['receivedLibraryCount'] = 3;
            firstReloadDetails['receivedClassesCount'] = 4;
            firstReloadDetails['receivedProceduresCount'] = 5;
            return OperationResult.ok;
          },
          reassembleHelper: (
            List<FlutterDevice> flutterDevices,
            Map<FlutterDevice, List<FlutterView>> viewCache,
            void Function(String message) onSlow,
            String reloadMessage,
            String fastReassembleClassName,
          ) async => ReassembleResult(
              <FlutterView, FlutterVmService>{null: null},
              false,
              true,
            ),
        ).restart(fullRestart: false);

        expect(result.isOk, true);
        expect(testUsage.events, <TestUsageEvent>[
          const TestUsageEvent('hot', 'reload', parameters: CustomDimensions(
            hotEventFinalLibraryCount: 2,
            hotEventSyncedLibraryCount: 3,
            hotEventSyncedClassesCount: 4,
            hotEventSyncedProceduresCount: 5,
            hotEventSyncedBytes: 8,
            hotEventInvalidatedSourcesCount: 6,
            hotEventTransferTimeInMs: 32000,
            hotEventOverallTimeInMs: 128000,
            hotEventTargetPlatform: 'flutter-tester',
            hotEventSdkName: 'Tester',
            hotEventEmulator: false,
            hotEventFullRestart: false,
            fastReassemble: false,
            hotEventCompileTimeInMs: 16000,
            hotEventFindInvalidatedTimeInMs: 64000,
            hotEventScannedSourcesCount: 16,
            hotEventReassembleTimeInMs: 256000,
            hotEventReloadVMTimeInMs: 512000,
          )),
        ]);
        expect(testingConfig.updateDevFSCompleteCalled, true);
      }, overrides: <Type, Generator>{
        HotRunnerConfig: () => testingConfig,
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
        Usage: () => testUsage,
      });
    });

    group('hot restart that failed to sync dev fs', () {
      TestHotRunnerConfig testingConfig;
      setUp(() {
        testingConfig = TestHotRunnerConfig(
          successfulHotRestartSetup: true,
        );
      });
      testUsingContext('still calls the devfs complete callback', () async {
        final FakeDevice device = FakeDevice();
        final FakeFlutterDevice fakeFlutterDevice = FakeFlutterDevice(device);
        final List<FlutterDevice> devices = <FlutterDevice>[
          fakeFlutterDevice,
        ];
        fakeFlutterDevice.updateDevFSReportCallback = () async => throw 'updateDevFS failed';

        final HotRunner runner = HotRunner(
          devices,
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
          devtoolsHandler: createNoOpHandler,
        );

        await expectLater(runner.restart(fullRestart: true), throwsA('updateDevFS failed'));
        expect(testingConfig.updateDevFSCompleteCalled, true);
      }, overrides: <Type, Generator>{
        HotRunnerConfig: () => testingConfig,
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
        Usage: () => testUsage,
      });
    });

    group('hot reload that failed to sync dev fs', () {
      TestHotRunnerConfig testingConfig;
      setUp(() {
        testingConfig = TestHotRunnerConfig(
          successfulHotReloadSetup: true,
        );
      });
      testUsingContext('still calls the devfs complete callback', () async {
        final FakeDevice device = FakeDevice();
        final FakeFlutterDevice fakeFlutterDevice = FakeFlutterDevice(device);
        final List<FlutterDevice> devices = <FlutterDevice>[
          fakeFlutterDevice,
        ];
        fakeFlutterDevice.updateDevFSReportCallback = () async => throw 'updateDevFS failed';

        final HotRunner runner = HotRunner(
          devices,
          debuggingOptions: DebuggingOptions.disabled(BuildInfo.debug),
          target: 'main.dart',
          devtoolsHandler: createNoOpHandler,
        );

        await expectLater(runner.restart(fullRestart: false), throwsA('updateDevFS failed'));
        expect(testingConfig.updateDevFSCompleteCalled, true);
      }, overrides: <Type, Generator>{
        HotRunnerConfig: () => testingConfig,
        Artifacts: () => Artifacts.test(),
        FileSystem: () => fileSystem,
        Platform: () => FakePlatform(operatingSystem: 'linux'),
        ProcessManager: () => FakeProcessManager.any(),
        Usage: () => testUsage,
      });
520
    });
521
  });
522 523

  group('hot attach', () {
524
    FileSystem fileSystem;
525 526

    setUp(() {
527
      fileSystem = MemoryFileSystem.test();
528 529
    });

nt4f04uNd's avatar
nt4f04uNd committed
530
    testUsingContext('Exits with code 2 when HttpException is thrown '
531
      'during VM service connection', () async {
532
      fileSystem.file('.packages')
533 534 535
        ..createSync(recursive: true)
        ..writeAsStringSync('\n');

536
      final FakeResidentCompiler residentCompiler = FakeResidentCompiler();
537
      final FakeDevice device = FakeDevice();
538 539
      final List<FlutterDevice> devices = <FlutterDevice>[
        TestFlutterDevice(
540
          device: device,
541 542
          generator: residentCompiler,
          exception: const HttpException('Connection closed before full header was received, '
543
              'uri = http://127.0.0.1:63394/5ZmLv8A59xY=/ws'),
544 545 546 547 548
        ),
      ];

      final int exitCode = await HotRunner(devices,
        debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
549
        target: 'main.dart',
550 551 552
      ).attach(
        enableDevTools: false,
      );
553 554
      expect(exitCode, 2);
    }, overrides: <Type, Generator>{
555
      HotRunnerConfig: () => TestHotRunnerConfig(),
556 557 558 559
      Artifacts: () => Artifacts.test(),
      FileSystem: () => fileSystem,
      Platform: () => FakePlatform(operatingSystem: 'linux'),
      ProcessManager: () => FakeProcessManager.any(),
560 561
    });
  });
562 563 564

  group('hot cleanupAtFinish()', () {
    testUsingContext('disposes each device', () async {
565 566 567 568
      final FakeDevice device1 = FakeDevice();
      final FakeDevice device2 = FakeDevice();
      final FakeFlutterDevice flutterDevice1 = FakeFlutterDevice(device1);
      final FakeFlutterDevice flutterDevice2 = FakeFlutterDevice(device2);
569 570

      final List<FlutterDevice> devices = <FlutterDevice>[
571 572
        flutterDevice1,
        flutterDevice2,
573 574 575 576
      ];

      await HotRunner(devices,
        debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
577
        target: 'main.dart',
578 579
      ).cleanupAtFinish();

580 581 582 583 584
      expect(device1.disposed, true);
      expect(device2.disposed, true);

      expect(flutterDevice1.stoppedEchoingDeviceLog, true);
      expect(flutterDevice2.stoppedEchoingDeviceLog, true);
585 586
    });
  });
587 588
}

589 590 591
class FakeDevFs extends Fake implements DevFS {
  @override
  Future<void> destroy() async { }
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606

  @override
  List<Uri> sources = <Uri>[];

  @override
  DateTime lastCompiled;

  @override
  PackageConfig lastPackageConfig;

  @override
  Set<String> assetPathsToEvict = <String>{};

  @override
  Uri baseUri;
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
}

class FakeDevice extends Fake implements Device {
  bool disposed = false;

  @override
  bool isSupported() => true;

  @override
  bool supportsHotReload = true;

  @override
  bool supportsHotRestart = true;

  @override
  bool supportsFlutterExit = true;

  @override
  Future<TargetPlatform> get targetPlatform async => TargetPlatform.tester;
626

627 628 629 630 631 632
  @override
  Future<String> get sdkNameAndVersion async => 'Tester';

  @override
  Future<bool> get isLocalEmulator async => false;

633 634 635
  @override
  String get name => 'Fake Device';

636 637 638 639 640 641 642 643 644 645 646
  @override
  Future<bool> stopApp(
    covariant ApplicationPackage app, {
    String userIdentifier,
  }) async {
    return true;
  }

  @override
  Future<void> dispose() async {
    disposed = true;
647 648 649
  }
}

650 651 652 653
class FakeFlutterDevice extends Fake implements FlutterDevice {
  FakeFlutterDevice(this.device);

  bool stoppedEchoingDeviceLog = false;
654
  Future<UpdateFSReport> Function() updateDevFSReportCallback;
655 656 657 658 659 660 661 662 663 664 665

  @override
  final FakeDevice device;

  @override
  Future<void> stopEchoingDeviceLog() async {
    stoppedEchoingDeviceLog = true;
  }

  @override
  DevFS devFS = FakeDevFs();
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686

  @override
  FlutterVmService get vmService => FakeFlutterVmService();

  @override
  ResidentCompiler generator;

  @override
  Future<UpdateFSReport> updateDevFS({
    Uri mainUri,
    String target,
    AssetBundle bundle,
    DateTime firstBuildTime,
    bool bundleFirstUpload = false,
    bool bundleDirty = false,
    bool fullRestart = false,
    String projectRootPath,
    String pathToReload,
    @required String dillOutputPath,
    @required List<Uri> invalidatedFiles,
    @required PackageConfig packageConfig,
687
  }) => updateDevFSReportCallback();
688
}
689

690 691 692 693
class TestFlutterDevice extends FlutterDevice {
  TestFlutterDevice({
    @required Device device,
    @required this.exception,
694
    @required ResidentCompiler generator,
695
  })  : assert(exception != null),
696
        super(device, buildInfo: BuildInfo.debug, generator: generator);
697 698 699 700 701 702 703 704 705

  /// The exception to throw when the connect method is called.
  final Exception exception;

  @override
  Future<void> connect({
    ReloadSources reloadSources,
    Restart restart,
    CompileExpression compileExpression,
706
    GetSkSLMethod getSkSLMethod,
707
    PrintStructuredErrorLogMethod printStructuredErrorLogMethod,
708
    bool disableServiceAuthCodes = false,
709
    bool enableDds = true,
710
    bool ipv6 = false,
711 712
    int hostVmServicePort,
    int ddsPort,
713
    bool allowExistingDdsInstance = false,
714 715 716 717 718
  }) async {
    throw exception;
  }
}

719
class TestHotRunnerConfig extends HotRunnerConfig {
720 721 722
  TestHotRunnerConfig({this.successfulHotRestartSetup, this.successfulHotReloadSetup});
  bool successfulHotRestartSetup;
  bool successfulHotReloadSetup;
723
  bool shutdownHookCalled = false;
724
  bool updateDevFSCompleteCalled = false;
725

726 727
  @override
  Future<bool> setupHotRestart() async {
728 729 730 731 732 733 734 735 736 737 738 739 740
    assert(successfulHotRestartSetup != null, 'setupHotRestart is not expected to be called in this test.');
    return successfulHotRestartSetup;
  }

  @override
  Future<bool> setupHotReload() async {
    assert(successfulHotReloadSetup != null, 'setupHotReload is not expected to be called in this test.');
    return successfulHotReloadSetup;
  }

  @override
  void updateDevFSComplete() {
    updateDevFSCompleteCalled = true;
741
  }
742 743 744 745 746

  @override
  Future<void> runPreShutdownOperations() async {
    shutdownHookCalled = true;
  }
747
}
748 749 750 751 752

class FakeResidentCompiler extends Fake implements ResidentCompiler {
  @override
  void accept() {}
}
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772

class FakeFlutterVmService extends Fake implements FlutterVmService {
  @override
  vm_service.VmService get service => FakeVmService();

  @override
  Future<List<FlutterView>> getFlutterViews({bool returnEarly = false, Duration delay = const Duration(milliseconds: 50)}) async {
    return <FlutterView>[];
  }
}

class FakeVmService extends Fake implements vm_service.VmService {
  @override
  Future<vm_service.VM> getVM() async => FakeVm();
}

class FakeVm extends Fake implements vm_service.VM {
  @override
  List<vm_service.IsolateRef> get isolates => <vm_service.IsolateRef>[];
}