Use run_vm_tests.host to list VM tests if possible

tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 286 matching lines @@
 /**
  * A specialized [TestSuite] that runs tests written in C to unit test
  * the Dart virtual machine and its API.
  *
  * The tests are compiled into a monolithic executable by the build step.
  * The executable lists its tests when run with the --list command line flag.
  * Individual tests are run by specifying them on the command line.
  */
 class CCTestSuite extends TestSuite {
   final String testPrefix;
-  String runnerPath;
+  String targetRunnerPath;
+  String hostRunnerPath;
   final String dartDir;
   List<String> statusFilePaths;
   TestCaseEvent doTest;
   VoidFunction doDone;
   ReceivePort receiveTestName;
   TestExpectations testExpectations;
 
   CCTestSuite(Map configuration,
               String suiteName,
               String runnerName,
               List<String> this.statusFilePaths,
               {this.testPrefix: ''})
       : super(configuration, suiteName),
         dartDir = TestUtils.dartDir().toNativePath() {
-    runnerPath = '$buildDir/$runnerName';
+    // For running the tests we use the given '$runnerName' binary
+    targetRunnerPath = '$buildDir/$runnerName';
+
+    // For listing the tests we use the '$runnerName.host' binary if it exists
+    // and use '$runnerName' if it doesn't.
+    var binarySuffix = Platform.operatingSystem == 'windows' ? '.exe' : '';
+    var hostBinary = '$targetRunnerPath.host$binarySuffix';
+    if (new File(hostBinary).existsSync()) {
+      hostRunnerPath = hostBinary;
+    } else {
+      hostRunnerPath = targetRunnerPath;
+    }
   }
 
   void testNameHandler(String testName, ignore) {
     if (testName == "") {
       receiveTestName.close();
 
       if (doDone != null) doDone();
     } else {
       // Only run the tests that match the pattern. Use the name
       // "suiteName/testName" for cc tests.
       RegExp pattern = configuration['selectors'][suiteName];
       String constructedName = '$suiteName/$testPrefix$testName';
       if (!pattern.hasMatch(constructedName)) return;
 
       var expectations = testExpectations.expectations(
           '$testPrefix$testName');
 
       if (configuration["report"]) {
         SummaryReport.add(expectations);
       }
 
       if (expectations.contains(SKIP)) return;
 
       var args = TestUtils.standardOptions(configuration);
       args.add(testName);
 
       doTest(new TestCase(constructedName,
-                          [new Command(runnerPath, args)],
+                          [new Command(targetRunnerPath, args)],
                           configuration,
                           completeHandler,
                           expectations));
     }
   }
 
   void forEachTest(TestCaseEvent onTest, Map testCache, [VoidFunction onDone]) {
     doTest = onTest;
     doDone = onDone;
 
     var filesRead = 0;
     void statusFileRead() {
       filesRead++;
       if (filesRead == statusFilePaths.length) {
         receiveTestName = new ReceivePort();
         var port = spawnFunction(ccTestLister);
-        port.send(runnerPath, receiveTestName.toSendPort());
+        port.send(hostRunnerPath, receiveTestName.toSendPort());
         receiveTestName.receive(testNameHandler);
       }
     }
 
     testExpectations = new TestExpectations();
     for (var statusFilePath in statusFilePaths) {
       ReadTestExpectationsInto(testExpectations,
                                '$dartDir/$statusFilePath',
                                configuration,
                                statusFileRead);
@@ skipping 1552 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }