Switch from AsyncThunk to AsyncMemoizer.

lib/src/runner.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.runner;
 
 import 'dart:async';
 import 'dart:io';
 
+import 'package:async/async.dart';
+
 import 'backend/metadata.dart';
 import 'backend/test_platform.dart';
 import 'runner/application_exception.dart';
 import 'runner/configuration.dart';
 import 'runner/engine.dart';
 import 'runner/load_exception.dart';
 import 'runner/load_suite.dart';
 import 'runner/loader.dart';
 import 'runner/reporter.dart';
 import 'runner/reporter/compact.dart';
 import 'runner/reporter/expanded.dart';
 import 'runner/runner_suite.dart';
-import 'util/async_thunk.dart';
 import 'util/io.dart';
 import 'utils.dart';
 
 /// The set of platforms for which debug flags are (currently) not supported.
 final _debugUnsupportedPlatforms = new Set.from(
     [TestPlatform.vm, TestPlatform.phantomJS, TestPlatform.contentShell]);
 
 /// A class that loads and runs tests based on a [Configuration].
 ///
 /// This maintains a [Loader] and an [Engine] and passes test suites from one to
 /// the other, as well as printing out tests with a [CompactReporter] or an
 /// [ExpandedReporter].
 class Runner {
   /// The configuration for the runner.
   final Configuration _configuration;
 
   /// The loader that loads the test suites from the filesystem.
   final Loader _loader;
 
   /// The engine that runs the test suites.
   final Engine _engine;
 
   /// The reporter that's emitting the test runner's results.
   final Reporter _reporter;
 
   /// The subscription to the stream returned by [_loadSuites].
   StreamSubscription _suiteSubscription;
 
-  /// The thunk for ensuring [close] only runs once.
-  final _closeThunk = new AsyncThunk();
-  bool get _closed => _closeThunk.hasRun;
+  /// The memoizer for ensuring [close] only runs once.
+  final _closeMemo = new AsyncMemoizer();
+  bool get _closed => _closeMemo.hasRun;
 
   /// Creates a new runner based on [configuration].
   factory Runner(Configuration configuration) {
     var metadata = new Metadata(
         verboseTrace: configuration.verboseTrace);
     var loader = new Loader(configuration.platforms,
         pubServeUrl: configuration.pubServeUrl,
         packageRoot: configuration.packageRoot,
         color: configuration.color,
         metadata: metadata,
@@ skipping 60 matching lines @@
     // Explicitly check "== true" here because [Engine.run] can return `null`
     // if the engine was closed prematurely.
     return success == true;
   }
 
   /// Closes the runner.
   ///
   /// This stops any future test suites from running. It will wait for any
   /// currently-running VM tests, in case they have stuff to clean up on the
   /// filesystem.
-  Future close() => _closeThunk.run(() async {
+  Future close() => _closeMemo.runOnce(() async {
     var timer;
     if (!_engine.isIdle) {
       // Wait a bit to print this message, since printing it eagerly looks weird
       // if the tests then finish immediately.
       timer = new Timer(new Duration(seconds: 1), () {
         // Pause the reporter while we print to ensure that we don't interfere
         // with its output.
         _reporter.pause();
         print("Waiting for current test(s) to finish.");
         print("Press Control-C again to terminate immediately.");
@@ skipping 93 matching lines @@
 
       // TODO(nweiz): Display something in the paused browsers indicating that
       // they're paused.
 
       await stdinLines.next;
     } finally {
       _reporter.resume();
     }
   }
 }