Warn when an unsupported platform is passed.

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.
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:async/async.dart';
 
 import 'backend/group.dart';
 import 'backend/group_entry.dart';
+import 'backend/operating_system.dart';
+import 'backend/platform_selector.dart';
 import 'backend/suite.dart';
 import 'backend/test.dart';
 import 'backend/test_platform.dart';
 import 'runner/application_exception.dart';
 import 'runner/configuration.dart';
 import 'runner/debugger.dart';
 import 'runner/engine.dart';
 import 'runner/load_exception.dart';
 import 'runner/load_suite.dart';
 import 'runner/loader.dart';
@@ skipping 76 matching lines @@
 
   /// Starts the runner.
   ///
   /// This starts running tests and printing their progress. It returns whether
   /// or not they ran successfully.
   Future<bool> run() async {
     if (_closed) {
       throw new StateError("run() may not be called on a closed Runner.");
     }
 
+    _warnForUnsupportedPlatforms();
+
     var suites = _loadSuites();
 
     var success;
     if (_config.pauseAfterLoad) {
       success = await _loadThenPause(suites);
     } else {
       _suiteSubscription = suites.listen(_engine.suiteSink.add);
       var results = await Future.wait([
         _suiteSubscription.asFuture().then((_) => _engine.suiteSink.close()),
         _engine.run()
@@ skipping 14 matching lines @@
         message += '"${_config.pattern}".';
       }
       throw new ApplicationException(message);
     }
 
     // Explicitly check "== true" here because [Engine.run] can return `null`
     // if the engine was closed prematurely.
     return success == true;
   }
 
+  /// Emits a warning if the user is trying to run on a platform that's
+  /// unsupported for the entire package.
+  void _warnForUnsupportedPlatforms() {
+    if (_config.testOn == PlatformSelector.all) return;
+
+    var unsupportedPlatforms = _config.platforms.where((platform) {
+      return !_config.testOn.evaluate(platform, os: currentOS);
+    }).toList();
+    if (unsupportedPlatforms.isEmpty) return;
+
+    // Human-readable names for all unsupported platforms.
+    var unsupportedNames = [];
+
+    // If the user tried to run on one or moe unsupported browsers, figure out
+    // whether we should warn about the individual browsers or whether all
+    // browsers are unsupported.
+    var unsupportedBrowsers = unsupportedPlatforms
+        .where((platform) => platform.isBrowser);
+    if (unsupportedBrowsers.isNotEmpty) {
+      var supportsAnyBrowser = TestPlatform.all
+          .where((platform) => platform.isBrowser)
+          .any((platform) => _config.testOn.evaluate(platform));
+
+      if (supportsAnyBrowser) {
+        unsupportedNames.addAll(
+            unsupportedBrowsers.map((platform) => platform.name));
+      } else {
+        unsupportedNames.add("browsers");
+      }
+    }
+
+    // If the user tried to run on the VM and it's not supported, figure out if
+    // that's because of the current OS or whether the VM is unsupported.
+    if (unsupportedPlatforms.contains(TestPlatform.vm)) {
+      var supportsAnyOS = OperatingSystem.all.any((os) =>
+          _config.testOn.evaluate(TestPlatform.vm, os: os));
+
+      if (supportsAnyOS) {
+        unsupportedNames.add(currentOS.name);
+      } else {
+        unsupportedNames.add("the Dart VM");
+      }
+    }
+
+    warn("this package doesn't support running tests on " +
+        toSentence(unsupportedNames, conjunction: "or") + ".");
+  }
+
   /// 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() => _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.
@@ skipping 149 matching lines @@
       await _debugOperation.valueOrCancellation();
     }).listen(null);
 
     var results = await Future.wait([
       _suiteSubscription.asFuture().then((_) => _engine.suiteSink.close()),
       _engine.run()
     ]);
     return results.last;
   }
 }