Add RunnerSuite.{on,is}Debugging properties.

lib/src/runner/load_suite.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.load_suite;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
 import '../../test.dart';
 import '../backend/group.dart';
 import '../backend/invoker.dart';
 import '../backend/metadata.dart';
+import '../backend/suite.dart';
 import '../backend/test.dart';
 import '../backend/test_platform.dart';
 import '../utils.dart';
 import 'load_exception.dart';
 import 'runner_suite.dart';
 import 'vm/environment.dart';
 
 /// A [Suite] emitted by a [Loader] that provides a test-like interface for
 /// loading a test file.
 ///
 /// This is used to expose the current status of test loading to the user. It's
 /// important to provide users visibility into what's taking a long time and
 /// where failures occur. And since some tests may be loaded at the same time as
 /// others are run, it's useful to provide that visibility in the form of a test
 /// suite so that it can integrate well into the existing reporting interface
 /// without too much extra logic.
 ///
 /// A suite is constructed with logic necessary to produce a test suite. As with
 /// a normal test body, this logic isn't run until [LiveTest.run] is called. The
 /// suite itself is returned by [suite] once it's avaialble, but any errors or
 /// prints will be emitted through the running [LiveTest].
-class LoadSuite extends RunnerSuite {
+class LoadSuite extends Suite implements RunnerSuite {
+  final environment = const VMEnvironment();

[kevmoo, 2015/11/06 18:13:56]

nit - might as well be getters – don't add to instance size

[nweiz, 2015/11/16 20:27:00]

The implementation can easily determine that final fields with constant values
aren't going to change. It can represent them internally however it thinks will
be most efficient, if the VM developers believe that representation will make a
difference.

I'm writing this code to be read, and it's more readable with fewer extra
characters and duplicated type annotations. I'm not going to make it less
readable for a theoretical small efficiency improvement that could be done at a
lower level anyway.

+  final isDebugging = false;
+  final onDebugging = new StreamController<bool>().stream;
+
   /// A future that completes to the loaded suite once the suite's test has been
   /// run and completed successfully.
   ///
   /// This will return `null` if the suite is unavailable for some reason (for
   /// example if an error occurred while loading it).
   final Future<RunnerSuite> suite;
 
   /// Returns the test that loads the suite.
   ///
   /// Load suites are guaranteed to only contain one test. This is a utility
@@ skipping 54 matching lines @@
     }, platform: platform);
   }
 
   /// A utility constructor for a load suite that just emits [suite].
   factory LoadSuite.forSuite(RunnerSuite suite) {
     return new LoadSuite("loading ${suite.path}", () => suite,
         platform: suite.platform);
   }
 
   LoadSuite._(String name, void body(), this.suite, {TestPlatform platform})
-      : super(const VMEnvironment(), new Group.root([
+      : super(new Group.root([
         new LocalTest(name,
             new Metadata(timeout: new Timeout(new Duration(minutes: 5))),
             body)
       ]), platform: platform);
 
   /// A constructor used by [changeSuite].
   LoadSuite._changeSuite(LoadSuite old, Future<RunnerSuite> this.suite)
-      : super(const VMEnvironment(), old.group, platform: old.platform);
+      : super(old.group, platform: old.platform);
 
   /// Creates a new [LoadSuite] that's identical to this one, but that
   /// transforms [suite] once it's loaded.
   ///
   /// If [suite] completes to `null`, [change] won't be run.
   LoadSuite changeSuite(RunnerSuite change(RunnerSuite suite)) {
     return new LoadSuite._changeSuite(this, suite.then((loadedSuite) {
       if (loadedSuite == null) return null;
       return change(loadedSuite);
     }));
   }
 
   /// Runs the test and returns the suite.
   ///
   /// Rather than emitting errors through a [LiveTest], this just pipes them
   /// through the return value.
   Future<RunnerSuite> getSuite() async {
     var liveTest = await test.load(this);
     liveTest.onPrint.listen(print);
     await liveTest.run();
 
     if (liveTest.errors.isEmpty) return await suite;
 
     var error = liveTest.errors.first;
     await new Future.error(error.error, error.stackTrace);
     throw 'unreachable';
   }
+
+  Future close() async {}
 }