service_extensions_test.dart 28 KB
Newer Older
1 2 3 4
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
@TestOn('!chrome')

7 8 9 10 11 12 13 14 15 16 17
import 'dart:async';
import 'dart:convert';
import 'dart:typed_data';
import 'dart:ui' as ui;

import 'package:flutter/foundation.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/scheduler.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
18
import '../flutter_test_alternative.dart';
19 20

class TestServiceExtensionsBinding extends BindingBase
21
  with ServicesBinding,
22
       GestureBinding,
23 24
       SchedulerBinding,
       PaintingBinding,
25
       SemanticsBinding,
26 27 28 29 30
       RendererBinding,
       WidgetsBinding {

  final Map<String, ServiceExtensionCallback> extensions = <String, ServiceExtensionCallback>{};

31 32
  final Map<String, List<Map<String, dynamic>>> eventsDispatched = <String, List<Map<String, dynamic>>>{};

33 34 35
  @override
  void registerServiceExtension({
    @required String name,
36
    @required ServiceExtensionCallback callback,
37 38 39 40 41
  }) {
    expect(extensions.containsKey(name), isFalse);
    extensions[name] = callback;
  }

42 43 44 45 46 47 48 49 50 51 52 53 54 55
  @override
  void postEvent(String eventKind, Map<dynamic, dynamic> eventData) {
    getEventsDispatched(eventKind).add(eventData);
  }

  List<Map<String, dynamic>> getEventsDispatched(String eventKind) {
    return eventsDispatched.putIfAbsent(eventKind, () => <Map<String, dynamic>>[]);
  }

  Iterable<Map<String, dynamic>> getServiceExtensionStateChangedEvents(String extensionName) {
    return getEventsDispatched('Flutter.ServiceExtensionStateChanged')
      .where((Map<String, dynamic> event) => event['extension'] == extensionName);
  }

56
  Future<Map<String, dynamic>> testExtension(String name, Map<String, String> arguments) {
57 58 59 60 61
    expect(extensions.containsKey(name), isTrue);
    return extensions[name](arguments);
  }

  int reassembled = 0;
62
  bool pendingReassemble = false;
63
  @override
64
  Future<void> performReassemble() {
65
    reassembled += 1;
66
    pendingReassemble = true;
67
    return super.performReassemble();
68 69 70 71 72 73 74
  }

  bool frameScheduled = false;
  @override
  void scheduleFrame() {
    frameScheduled = true;
  }
75
  Future<void> doFrame() async {
76 77
    frameScheduled = false;
    if (ui.window.onBeginFrame != null)
78
      ui.window.onBeginFrame(Duration.zero);
79 80 81
    await flushMicrotasks();
    if (ui.window.onDrawFrame != null)
      ui.window.onDrawFrame();
82 83
  }

84 85 86 87 88 89 90 91 92 93 94
  @override
  void scheduleForcedFrame() {
    expect(true, isFalse);
  }

  @override
  void scheduleWarmUpFrame() {
    expect(pendingReassemble, isTrue);
    pendingReassemble = false;
  }

95 96
  Future<void> flushMicrotasks() {
    final Completer<void> completer = Completer<void>();
97
    Timer.run(completer.complete);
98 99 100 101
    return completer.future;
  }
}

102 103
TestServiceExtensionsBinding binding;

104
Future<Map<String, dynamic>> hasReassemble(Future<Map<String, dynamic>> pendingResult) async {
105 106 107 108 109 110
  bool completed = false;
  pendingResult.whenComplete(() { completed = true; });
  expect(binding.frameScheduled, isFalse);
  await binding.flushMicrotasks();
  expect(binding.frameScheduled, isTrue);
  expect(completed, isFalse);
111
  await binding.flushMicrotasks();
112
  await binding.doFrame();
113 114 115 116 117 118
  await binding.flushMicrotasks();
  expect(completed, isTrue);
  expect(binding.frameScheduled, isFalse);
  return pendingResult;
}

119
void main() {
120
  final List<String> console = <String>[];
121

122
  setUpAll(() async {
123
    binding = TestServiceExtensionsBinding();
124
    expect(binding.frameScheduled, isTrue);
125 126 127 128 129 130

    // We need to test this service extension here because the result is true
    // after the first binding.doFrame() call.
    Map<String, dynamic> firstFrameResult;
    expect(binding.debugDidSendFirstFrameEvent, isFalse);
    firstFrameResult = await binding.testExtension('didSendFirstFrameEvent', <String, String>{});
131
    expect(firstFrameResult, <String, String>{'enabled': 'false'});
132

133
    await binding.doFrame(); // initial frame scheduled by creating the binding
134 135 136

    expect(binding.debugDidSendFirstFrameEvent, isTrue);
    firstFrameResult = await binding.testExtension('didSendFirstFrameEvent', <String, String>{});
137
    expect(firstFrameResult, <String, String>{'enabled': 'true'});
138

139 140 141 142 143 144 145 146
    expect(binding.frameScheduled, isFalse);

    expect(debugPrint, equals(debugPrintThrottled));
    debugPrint = (String message, { int wrapWidth }) {
      console.add(message);
    };
  });

147 148 149
  tearDownAll(() async {
    // See widget_inspector_test.dart for tests of the ext.flutter.inspector
    // service extensions included in this count.
150
    int widgetInspectorExtensionCount = 16;
151 152 153 154 155 156 157 158 159 160 161 162 163 164
    if (WidgetInspectorService.instance.isWidgetCreationTracked()) {
      // Some inspector extensions are only exposed if widget creation locations
      // are tracked.
      widgetInspectorExtensionCount += 2;
    }

    // If you add a service extension... TEST IT! :-)
    // ...then increment this number.
    expect(binding.extensions.length, 26 + widgetInspectorExtensionCount);

    expect(console, isEmpty);
    debugPrint = debugPrintThrottled;
  });

165 166 167
  // The following list is alphabetical, one test per extension.

  test('Service extensions - debugAllowBanner', () async {
168
    Map<String, dynamic> result;
169 170 171 172

    expect(binding.frameScheduled, isFalse);
    expect(WidgetsApp.debugAllowBannerOverride, true);
    result = await binding.testExtension('debugAllowBanner', <String, String>{});
173
    expect(result, <String, String>{'enabled': 'true'});
174
    expect(WidgetsApp.debugAllowBannerOverride, true);
175 176
    result = await binding.testExtension('debugAllowBanner', <String, String>{'enabled': 'false'});
    expect(result, <String, String>{'enabled': 'false'});
177 178
    expect(WidgetsApp.debugAllowBannerOverride, false);
    result = await binding.testExtension('debugAllowBanner', <String, String>{});
179
    expect(result, <String, String>{'enabled': 'false'});
180
    expect(WidgetsApp.debugAllowBannerOverride, false);
181 182
    result = await binding.testExtension('debugAllowBanner', <String, String>{'enabled': 'true'});
    expect(result, <String, String>{'enabled': 'true'});
183 184
    expect(WidgetsApp.debugAllowBannerOverride, true);
    result = await binding.testExtension('debugAllowBanner', <String, String>{});
185
    expect(result, <String, String>{'enabled': 'true'});
186 187 188 189
    expect(WidgetsApp.debugAllowBannerOverride, true);
    expect(binding.frameScheduled, isFalse);
  });

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
  test('Service extensions - debugCheckElevationsEnabled', () async {
    expect(binding.frameScheduled, isFalse);
    expect(debugCheckElevationsEnabled, false);

    bool lastValue = false;
    Future<void> _updateAndCheck(bool newValue) async {
      Map<String, dynamic> result;
      binding.testExtension(
        'debugCheckElevationsEnabled',
        <String, String>{'enabled': '$newValue'}
      ).then((Map<String, dynamic> answer) => result = answer);
      await binding.flushMicrotasks();
      expect(binding.frameScheduled, lastValue != newValue);
      await binding.doFrame();
      await binding.flushMicrotasks();
      expect(result, <String, String>{'enabled': '$newValue'});
      expect(debugCheckElevationsEnabled, newValue);
      lastValue = newValue;
    }

    await _updateAndCheck(false);
    await _updateAndCheck(true);
    await _updateAndCheck(true);
    await _updateAndCheck(false);
    await _updateAndCheck(false);
    expect(binding.frameScheduled, isFalse);
  });

218
  test('Service extensions - debugDumpApp', () async {
219
    Map<String, dynamic> result;
220 221 222 223 224 225 226 227

    result = await binding.testExtension('debugDumpApp', <String, String>{});
    expect(result, <String, String>{});
    expect(console, <String>['TestServiceExtensionsBinding - CHECKED MODE', '<no tree currently mounted>']);
    console.clear();
  });

  test('Service extensions - debugDumpRenderTree', () async {
228
    Map<String, dynamic> result;
229

230
    await binding.doFrame();
231 232
    result = await binding.testExtension('debugDumpRenderTree', <String, String>{});
    expect(result, <String, String>{});
233 234
    expect(console, <Matcher>[
      matches(
235
        r'^'
236
        r'RenderView#[0-9a-f]{5}\n'
237
        r'   debug mode enabled - [a-zA-Z]+\n'
238 239 240
        r'   window size: Size\(2400\.0, 1800\.0\) \(in physical pixels\)\n'
        r'   device pixel ratio: 3\.0 \(physical pixels per logical pixel\)\n'
        r'   configuration: Size\(800\.0, 600\.0\) at 3\.0x \(in logical pixels\)\n'
241
        r'$'
242
      ),
243 244 245 246
    ]);
    console.clear();
  });

247
  test('Service extensions - debugDumpLayerTree', () async {
248
    Map<String, dynamic> result;
249 250 251 252 253 254 255

    await binding.doFrame();
    result = await binding.testExtension('debugDumpLayerTree', <String, String>{});
    expect(result, <String, String>{});
    expect(console, <Matcher>[
      matches(
        r'^'
256 257
        r'TransformLayer#[0-9a-f]{5}\n'
        r'   owner: RenderView#[0-9a-f]{5}\n'
258 259 260
        r'   creator: RenderView\n'
        r'   offset: Offset\(0\.0, 0\.0\)\n'
        r'   transform:\n'
261 262
        r'     \[0] 3\.0,0\.0,0\.0,0\.0\n'
        r'     \[1] 0\.0,3\.0,0\.0,0\.0\n'
263 264 265 266 267 268 269 270
        r'     \[2] 0\.0,0\.0,1\.0,0\.0\n'
        r'     \[3] 0\.0,0\.0,0\.0,1\.0\n'
        r'$'
      ),
    ]);
    console.clear();
  });

271
  test('Service extensions - debugDumpSemanticsTreeInTraversalOrder', () async {
272
    Map<String, dynamic> result;
273 274

    await binding.doFrame();
275
    result = await binding.testExtension('debugDumpSemanticsTreeInTraversalOrder', <String, String>{});
276 277 278 279 280 281
    expect(result, <String, String>{});
    expect(console, <String>['Semantics not collected.']);
    console.clear();
  });

  test('Service extensions - debugDumpSemanticsTreeInInverseHitTestOrder', () async {
282
    Map<String, dynamic> result;
283 284 285

    await binding.doFrame();
    result = await binding.testExtension('debugDumpSemanticsTreeInInverseHitTestOrder', <String, String>{});
286 287 288 289 290
    expect(result, <String, String>{});
    expect(console, <String>['Semantics not collected.']);
    console.clear();
  });

291
  test('Service extensions - debugPaint', () async {
292 293
    final Iterable<Map<String, dynamic>> extensionChangedEvents = binding.getServiceExtensionStateChangedEvents('ext.flutter.debugPaint');
    Map<String, dynamic> extensionChangedEvent;
294 295
    Map<String, dynamic> result;
    Future<Map<String, dynamic>> pendingResult;
296 297 298 299 300
    bool completed;

    expect(binding.frameScheduled, isFalse);
    expect(debugPaintSizeEnabled, false);
    result = await binding.testExtension('debugPaint', <String, String>{});
301
    expect(result, <String, String>{'enabled': 'false'});
302
    expect(debugPaintSizeEnabled, false);
303
    expect(extensionChangedEvents, isEmpty);
304
    expect(binding.frameScheduled, isFalse);
305
    pendingResult = binding.testExtension('debugPaint', <String, String>{'enabled': 'true'});
306 307 308 309 310
    completed = false;
    pendingResult.whenComplete(() { completed = true; });
    await binding.flushMicrotasks();
    expect(binding.frameScheduled, isTrue);
    expect(completed, isFalse);
311
    await binding.doFrame();
312 313 314 315
    await binding.flushMicrotasks();
    expect(completed, isTrue);
    expect(binding.frameScheduled, isFalse);
    result = await pendingResult;
316
    expect(result, <String, String>{'enabled': 'true'});
317
    expect(debugPaintSizeEnabled, true);
318 319 320 321
    expect(extensionChangedEvents.length, 1);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.debugPaint');
    expect(extensionChangedEvent['value'], 'true');
322
    result = await binding.testExtension('debugPaint', <String, String>{});
323
    expect(result, <String, String>{'enabled': 'true'});
324
    expect(debugPaintSizeEnabled, true);
325
    expect(extensionChangedEvents.length, 1);
326
    expect(binding.frameScheduled, isFalse);
327
    pendingResult = binding.testExtension('debugPaint', <String, String>{'enabled': 'false'});
328 329
    await binding.flushMicrotasks();
    expect(binding.frameScheduled, isTrue);
330
    await binding.doFrame();
331 332
    expect(binding.frameScheduled, isFalse);
    result = await pendingResult;
333
    expect(result, <String, String>{'enabled': 'false'});
334
    expect(debugPaintSizeEnabled, false);
335 336 337 338
    expect(extensionChangedEvents.length, 2);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.debugPaint');
    expect(extensionChangedEvent['value'], 'false');
339
    result = await binding.testExtension('debugPaint', <String, String>{});
340
    expect(result, <String, String>{'enabled': 'false'});
341
    expect(debugPaintSizeEnabled, false);
342
    expect(extensionChangedEvents.length, 2);
343 344 345
    expect(binding.frameScheduled, isFalse);
  });

346
  test('Service extensions - debugPaintBaselinesEnabled', () async {
347 348
    Map<String, dynamic> result;
    Future<Map<String, dynamic>> pendingResult;
349 350 351 352 353
    bool completed;

    expect(binding.frameScheduled, isFalse);
    expect(debugPaintBaselinesEnabled, false);
    result = await binding.testExtension('debugPaintBaselinesEnabled', <String, String>{});
354
    expect(result, <String, String>{'enabled': 'false'});
355 356
    expect(debugPaintBaselinesEnabled, false);
    expect(binding.frameScheduled, isFalse);
357
    pendingResult = binding.testExtension('debugPaintBaselinesEnabled', <String, String>{'enabled': 'true'});
358 359 360 361 362 363 364 365 366 367
    completed = false;
    pendingResult.whenComplete(() { completed = true; });
    await binding.flushMicrotasks();
    expect(binding.frameScheduled, isTrue);
    expect(completed, isFalse);
    await binding.doFrame();
    await binding.flushMicrotasks();
    expect(completed, isTrue);
    expect(binding.frameScheduled, isFalse);
    result = await pendingResult;
368
    expect(result, <String, String>{'enabled': 'true'});
369 370
    expect(debugPaintBaselinesEnabled, true);
    result = await binding.testExtension('debugPaintBaselinesEnabled', <String, String>{});
371
    expect(result, <String, String>{'enabled': 'true'});
372 373
    expect(debugPaintBaselinesEnabled, true);
    expect(binding.frameScheduled, isFalse);
374
    pendingResult = binding.testExtension('debugPaintBaselinesEnabled', <String, String>{'enabled': 'false'});
375 376 377 378 379
    await binding.flushMicrotasks();
    expect(binding.frameScheduled, isTrue);
    await binding.doFrame();
    expect(binding.frameScheduled, isFalse);
    result = await pendingResult;
380
    expect(result, <String, String>{'enabled': 'false'});
381 382
    expect(debugPaintBaselinesEnabled, false);
    result = await binding.testExtension('debugPaintBaselinesEnabled', <String, String>{});
383
    expect(result, <String, String>{'enabled': 'false'});
384 385 386 387
    expect(debugPaintBaselinesEnabled, false);
    expect(binding.frameScheduled, isFalse);
  });

388 389 390 391 392 393 394
  test('Service extensions - profileWidgetBuilds', () async {
    Map<String, dynamic> result;

    expect(binding.frameScheduled, isFalse);
    expect(debugProfileBuildsEnabled, false);

    result = await binding.testExtension('profileWidgetBuilds', <String, String>{});
395
    expect(result, <String, String>{'enabled': 'false'});
396 397
    expect(debugProfileBuildsEnabled, false);

398 399
    result = await binding.testExtension('profileWidgetBuilds', <String, String>{'enabled': 'true'});
    expect(result, <String, String>{'enabled': 'true'});
400 401 402
    expect(debugProfileBuildsEnabled, true);

    result = await binding.testExtension('profileWidgetBuilds', <String, String>{});
403
    expect(result, <String, String>{'enabled': 'true'});
404 405
    expect(debugProfileBuildsEnabled, true);

406 407
    result = await binding.testExtension('profileWidgetBuilds', <String, String>{'enabled': 'false'});
    expect(result, <String, String>{'enabled': 'false'});
408 409 410
    expect(debugProfileBuildsEnabled, false);

    result = await binding.testExtension('profileWidgetBuilds', <String, String>{});
411
    expect(result, <String, String>{'enabled': 'false'});
412 413 414 415 416
    expect(debugProfileBuildsEnabled, false);

    expect(binding.frameScheduled, isFalse);
  });

417
  test('Service extensions - evict', () async {
418
    Map<String, dynamic> result;
419 420 421
    bool completed;

    completed = false;
422
    defaultBinaryMessenger.setMockMessageHandler('flutter/assets', (ByteData message) async {
423
      expect(utf8.decode(message.buffer.asUint8List()), 'test');
424
      completed = true;
425
      return ByteData(5); // 0x0000000000
426 427 428 429 430 431 432 433 434
    });
    bool data;
    data = await rootBundle.loadStructuredData<bool>('test', (String value) async { expect(value, '\x00\x00\x00\x00\x00'); return true; });
    expect(data, isTrue);
    expect(completed, isTrue);
    completed = false;
    data = await rootBundle.loadStructuredData('test', (String value) async { expect(true, isFalse); return null; });
    expect(data, isTrue);
    expect(completed, isFalse);
435 436
    result = await binding.testExtension('evict', <String, String>{'value': 'test'});
    expect(result, <String, String>{'value': ''});
437 438 439 440
    expect(completed, isFalse);
    data = await rootBundle.loadStructuredData<bool>('test', (String value) async { expect(value, '\x00\x00\x00\x00\x00'); return false; });
    expect(data, isFalse);
    expect(completed, isTrue);
441
    defaultBinaryMessenger.setMockMessageHandler('flutter/assets', null);
442 443 444 445 446 447 448
  });

  test('Service extensions - exit', () async {
    // no test for _calling_ 'exit', because that should terminate the process!
    expect(binding.extensions.containsKey('exit'), isTrue);
  });

449
  test('Service extensions - platformOverride', () async {
450 451
    final Iterable<Map<String, dynamic>> extensionChangedEvents = binding.getServiceExtensionStateChangedEvents('ext.flutter.platformOverride');
    Map<String, dynamic> extensionChangedEvent;
452
    Map<String, dynamic> result;
453 454 455 456 457 458

    expect(binding.reassembled, 0);
    expect(defaultTargetPlatform, TargetPlatform.android);
    result = await binding.testExtension('platformOverride', <String, String>{});
    expect(result, <String, String>{'value': 'android'});
    expect(defaultTargetPlatform, TargetPlatform.android);
459
    expect(extensionChangedEvents, isEmpty);
460 461 462 463
    result = await hasReassemble(binding.testExtension('platformOverride', <String, String>{'value': 'iOS'}));
    expect(result, <String, String>{'value': 'iOS'});
    expect(binding.reassembled, 1);
    expect(defaultTargetPlatform, TargetPlatform.iOS);
464 465 466 467
    expect(extensionChangedEvents.length, 1);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.platformOverride');
    expect(extensionChangedEvent['value'], 'iOS');
468 469 470 471
    result = await hasReassemble(binding.testExtension('platformOverride', <String, String>{'value': 'android'}));
    expect(result, <String, String>{'value': 'android'});
    expect(binding.reassembled, 2);
    expect(defaultTargetPlatform, TargetPlatform.android);
472 473 474 475
    expect(extensionChangedEvents.length, 2);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.platformOverride');
    expect(extensionChangedEvent['value'], 'android');
476 477 478 479
    result = await hasReassemble(binding.testExtension('platformOverride', <String, String>{'value': 'fuchsia'}));
    expect(result, <String, String>{'value': 'fuchsia'});
    expect(binding.reassembled, 3);
    expect(defaultTargetPlatform, TargetPlatform.fuchsia);
480 481 482 483
    expect(extensionChangedEvents.length, 3);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.platformOverride');
    expect(extensionChangedEvent['value'], 'fuchsia');
484 485 486 487
    result = await hasReassemble(binding.testExtension('platformOverride', <String, String>{'value': 'default'}));
    expect(result, <String, String>{'value': 'android'});
    expect(binding.reassembled, 4);
    expect(defaultTargetPlatform, TargetPlatform.android);
488 489 490 491
    expect(extensionChangedEvents.length, 4);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.platformOverride');
    expect(extensionChangedEvent['value'], 'android');
492 493 494 495
    result = await hasReassemble(binding.testExtension('platformOverride', <String, String>{'value': 'iOS'}));
    expect(result, <String, String>{'value': 'iOS'});
    expect(binding.reassembled, 5);
    expect(defaultTargetPlatform, TargetPlatform.iOS);
496 497 498 499
    expect(extensionChangedEvents.length, 5);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.platformOverride');
    expect(extensionChangedEvent['value'], 'iOS');
500 501 502 503
    result = await hasReassemble(binding.testExtension('platformOverride', <String, String>{'value': 'bogus'}));
    expect(result, <String, String>{'value': 'android'});
    expect(binding.reassembled, 6);
    expect(defaultTargetPlatform, TargetPlatform.android);
504 505 506 507
    expect(extensionChangedEvents.length, 6);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.platformOverride');
    expect(extensionChangedEvent['value'], 'android');
508 509 510
    binding.reassembled = 0;
  });

511
  test('Service extensions - repaintRainbow', () async {
512 513
    Map<String, dynamic> result;
    Future<Map<String, dynamic>> pendingResult;
514 515 516 517 518
    bool completed;

    expect(binding.frameScheduled, isFalse);
    expect(debugRepaintRainbowEnabled, false);
    result = await binding.testExtension('repaintRainbow', <String, String>{});
519
    expect(result, <String, String>{'enabled': 'false'});
520 521
    expect(debugRepaintRainbowEnabled, false);
    expect(binding.frameScheduled, isFalse);
522
    pendingResult = binding.testExtension('repaintRainbow', <String, String>{'enabled': 'true'});
523 524 525 526 527 528
    completed = false;
    pendingResult.whenComplete(() { completed = true; });
    await binding.flushMicrotasks();
    expect(completed, true);
    expect(binding.frameScheduled, isFalse);
    result = await pendingResult;
529
    expect(result, <String, String>{'enabled': 'true'});
530 531
    expect(debugRepaintRainbowEnabled, true);
    result = await binding.testExtension('repaintRainbow', <String, String>{});
532
    expect(result, <String, String>{'enabled': 'true'});
533 534
    expect(debugRepaintRainbowEnabled, true);
    expect(binding.frameScheduled, isFalse);
535
    pendingResult = binding.testExtension('repaintRainbow', <String, String>{'enabled': 'false'});
536 537 538 539 540
    completed = false;
    pendingResult.whenComplete(() { completed = true; });
    await binding.flushMicrotasks();
    expect(completed, false);
    expect(binding.frameScheduled, isTrue);
541
    await binding.doFrame();
542 543 544 545
    await binding.flushMicrotasks();
    expect(completed, true);
    expect(binding.frameScheduled, isFalse);
    result = await pendingResult;
546
    expect(result, <String, String>{'enabled': 'false'});
547 548
    expect(debugRepaintRainbowEnabled, false);
    result = await binding.testExtension('repaintRainbow', <String, String>{});
549
    expect(result, <String, String>{'enabled': 'false'});
550 551 552 553 554
    expect(debugRepaintRainbowEnabled, false);
    expect(binding.frameScheduled, isFalse);
  });

  test('Service extensions - reassemble', () async {
555 556
    Map<String, dynamic> result;
    Future<Map<String, dynamic>> pendingResult;
557 558 559 560 561 562 563 564 565
    bool completed;

    completed = false;
    expect(binding.reassembled, 0);
    pendingResult = binding.testExtension('reassemble', <String, String>{});
    pendingResult.whenComplete(() { completed = true; });
    await binding.flushMicrotasks();
    expect(binding.frameScheduled, isTrue);
    expect(completed, false);
566
    await binding.flushMicrotasks();
567
    await binding.doFrame();
568 569 570 571 572 573 574 575 576
    await binding.flushMicrotasks();
    expect(completed, true);
    expect(binding.frameScheduled, isFalse);
    result = await pendingResult;
    expect(result, <String, String>{});
    expect(binding.reassembled, 1);
  });

  test('Service extensions - showPerformanceOverlay', () async {
577
    Map<String, dynamic> result;
578 579 580 581

    expect(binding.frameScheduled, isFalse);
    expect(WidgetsApp.showPerformanceOverlayOverride, false);
    result = await binding.testExtension('showPerformanceOverlay', <String, String>{});
582
    expect(result, <String, String>{'enabled': 'false'});
583
    expect(WidgetsApp.showPerformanceOverlayOverride, false);
584 585
    result = await binding.testExtension('showPerformanceOverlay', <String, String>{'enabled': 'true'});
    expect(result, <String, String>{'enabled': 'true'});
586 587
    expect(WidgetsApp.showPerformanceOverlayOverride, true);
    result = await binding.testExtension('showPerformanceOverlay', <String, String>{});
588
    expect(result, <String, String>{'enabled': 'true'});
589
    expect(WidgetsApp.showPerformanceOverlayOverride, true);
590 591
    result = await binding.testExtension('showPerformanceOverlay', <String, String>{'enabled': 'false'});
    expect(result, <String, String>{'enabled': 'false'});
592 593
    expect(WidgetsApp.showPerformanceOverlayOverride, false);
    result = await binding.testExtension('showPerformanceOverlay', <String, String>{});
594
    expect(result, <String, String>{'enabled': 'false'});
595 596 597 598
    expect(WidgetsApp.showPerformanceOverlayOverride, false);
    expect(binding.frameScheduled, isFalse);
  });

599 600 601 602 603
  test('Service extensions - debugWidgetInspector', () async {
    Map<String, dynamic> result;
    expect(binding.frameScheduled, isFalse);
    expect(WidgetsApp.debugShowWidgetInspectorOverride, false);
    result = await binding.testExtension('debugWidgetInspector', <String, String>{});
604
    expect(result, <String, String>{'enabled': 'false'});
605
    expect(WidgetsApp.debugShowWidgetInspectorOverride, false);
606 607
    result = await binding.testExtension('debugWidgetInspector', <String, String>{'enabled': 'true'});
    expect(result, <String, String>{'enabled': 'true'});
608 609
    expect(WidgetsApp.debugShowWidgetInspectorOverride, true);
    result = await binding.testExtension('debugWidgetInspector', <String, String>{});
610
    expect(result, <String, String>{'enabled': 'true'});
611
    expect(WidgetsApp.debugShowWidgetInspectorOverride, true);
612 613
    result = await binding.testExtension('debugWidgetInspector', <String, String>{'enabled': 'false'});
    expect(result, <String, String>{'enabled': 'false'});
614 615
    expect(WidgetsApp.debugShowWidgetInspectorOverride, false);
    result = await binding.testExtension('debugWidgetInspector', <String, String>{});
616
    expect(result, <String, String>{'enabled': 'false'});
617 618 619 620
    expect(WidgetsApp.debugShowWidgetInspectorOverride, false);
    expect(binding.frameScheduled, isFalse);
  });

621
  test('Service extensions - timeDilation', () async {
622 623
    final Iterable<Map<String, dynamic>> extensionChangedEvents = binding.getServiceExtensionStateChangedEvents('ext.flutter.timeDilation');
    Map<String, dynamic> extensionChangedEvent;
624
    Map<String, dynamic> result;
625 626 627 628

    expect(binding.frameScheduled, isFalse);
    expect(timeDilation, 1.0);
    result = await binding.testExtension('timeDilation', <String, String>{});
629
    expect(result, <String, String>{'timeDilation': '1.0'});
630
    expect(timeDilation, 1.0);
631
    expect(extensionChangedEvents, isEmpty);
632 633
    result = await binding.testExtension('timeDilation', <String, String>{'timeDilation': '100.0'});
    expect(result, <String, String>{'timeDilation': '100.0'});
634
    expect(timeDilation, 100.0);
635 636 637 638
    expect(extensionChangedEvents.length, 1);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.timeDilation');
    expect(extensionChangedEvent['value'], '100.0');
639
    result = await binding.testExtension('timeDilation', <String, String>{});
640
    expect(result, <String, String>{'timeDilation': '100.0'});
641
    expect(timeDilation, 100.0);
642
    expect(extensionChangedEvents.length, 1);
643 644
    result = await binding.testExtension('timeDilation', <String, String>{'timeDilation': '1.0'});
    expect(result, <String, String>{'timeDilation': '1.0'});
645
    expect(timeDilation, 1.0);
646 647 648 649
    expect(extensionChangedEvents.length, 2);
    extensionChangedEvent = extensionChangedEvents.last;
    expect(extensionChangedEvent['extension'], 'ext.flutter.timeDilation');
    expect(extensionChangedEvent['value'], '1.0');
650
    result = await binding.testExtension('timeDilation', <String, String>{});
651
    expect(result, <String, String>{'timeDilation': '1.0'});
652
    expect(timeDilation, 1.0);
653
    expect(extensionChangedEvents.length, 2);
654 655 656
    expect(binding.frameScheduled, isFalse);
  });

657
  test('Service extensions - saveCompilationTrace', () async {
658
    Map<String, dynamic> result;
659
    result = await binding.testExtension('saveCompilationTrace', <String, String>{});
660 661 662 663 664
    final String trace = String.fromCharCodes(result['value']);
    expect(trace, contains('dart:core,Object,Object.\n'));
    expect(trace, contains('package:test_api/test_api.dart,::,test\n'));
    expect(trace, contains('service_extensions_test.dart,::,main\n'));
  });
665
}