Rename fletch -> dartino

tools/testing/dart/dartino_test_suite.dart

 // Copyright (c) 2015, the Dartino 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.md file.
 
 /// Test suite for running tests in a shared Dart VM.  Take a look at
-/// ../../../tests/fletch_tests/all_tests.dart for more information.
-library test.fletch_test_suite;
+/// ../../../tests/dartino_tests/all_tests.dart for more information.
+library test.dartino_test_suite;
 
 import 'dart:io' as io;
 
 import 'dart:convert' show
     JSON,
     LineSplitter,
     UTF8,
     Utf8Decoder;
 
 import 'dart:async' show
@@ skipping 14 matching lines @@
     TestCase;
 
 import 'runtime_configuration.dart' show
     RuntimeConfiguration;
 
 import 'status_file_parser.dart' show
     Expectation,
     ReadTestExpectationsInto,
     TestExpectations;
 
-import '../../../tests/fletch_tests/messages.dart' show
+import '../../../tests/dartino_tests/messages.dart' show
     ErrorMessage,
     Info,
     ListTests,
     ListTestsReply,
     Message,
     NamedMessage,
     RunTest,
     TestFailed,
     TestStdoutLine,
     TimedOut,
     messageTransformer;
 
-class FletchTestRuntimeConfiguration extends RuntimeConfiguration {
+class DartinoTestRuntimeConfiguration extends RuntimeConfiguration {
   final String system;
   final String dartBinary;
 
-  FletchTestRuntimeConfiguration(Map configuration)
+  DartinoTestRuntimeConfiguration(Map configuration)
       : system = configuration['system'],
         dartBinary = '${TestUtils.buildDir(configuration)}'
                      '${io.Platform.pathSeparator}dart',
         super.subclass();
 }
 
-class FletchTestSuite extends TestSuite {
+class DartinoTestSuite extends TestSuite {
   final String testSuiteDir;
 
   TestCompleter completer;
 
-  FletchTestSuite(Map configuration, this.testSuiteDir)
-      : super(configuration, "fletch_tests");
+  DartinoTestSuite(Map configuration, this.testSuiteDir)
+      : super(configuration, "dartino_tests");
 
   void forEachTest(
       void onTest(TestCase testCase),
       Map testCache,
       [void onDone()]) {
     this.doTest = onTest;
-    if (configuration['runtime'] != 'fletch_tests') {
+    if (configuration['runtime'] != 'dartino_tests') {
       onDone();
       return;
     }
 
-    FletchTestRuntimeConfiguration runtimeConfiguration =
+    DartinoTestRuntimeConfiguration runtimeConfiguration =
         new RuntimeConfiguration(configuration);
 
     TestExpectations expectations = new TestExpectations();
     String buildDir = TestUtils.buildDir(configuration);
     String version;
 
     // Define a path for temporary output generated during tests.
     String tempDirPath = '$buildDir/temporary_test_output';
     io.Directory tempDir = new io.Directory(tempDirPath);
     try {
       tempDir.deleteSync(recursive: true);
     } on io.FileSystemException catch (e) {
       // Ignored, we assume the file did not exist.
     }
 
     String javaHome = _guessJavaHome(configuration["arch"]);
     if (javaHome == null) {
       String arch = configuration["arch"];
       print("Notice: Java tests are disabled");
       print("Unable to find a JDK installation for architecture $arch");
       print("Install a JDK or set JAVA_PATH to an existing installation.");
       // TODO(zerny): Throw an error if no-java is not supplied.
     } else {
       print("Notice: Enabled Java tests using JDK at $javaHome");
     }
 
     bool helperProgramExited = false;
     io.Process vmProcess;
     ReadTestExpectationsInto(
-        expectations, '$testSuiteDir/fletch_tests.status',
+        expectations, '$testSuiteDir/dartino_tests.status',
         configuration).then((_) {
       return new io.File('$buildDir/gen/version.cc').readAsLines();
     }).then((List<String> versionFileLines) {
       // Search for the 'return "version_string";' line.
       for (String line in versionFileLines) {
         if (line.contains('return')) {
           version = line.substring(
               line.indexOf('"') + 1, line.lastIndexOf('"'));
         }
       }
       assert(version != null);
     }).then((_) {
       return io.ServerSocket.bind(io.InternetAddress.LOOPBACK_IP_V4, 0);
     }).then((io.ServerSocket server) {
       return io.Process.start(
           runtimeConfiguration.dartBinary,
-          ['-Dfletch-vm=$buildDir/fletch-vm',
-           '-Dfletch.version=$version',
+          ['-Ddartino-vm=$buildDir/dartino-vm',
+           '-Ddartino.version=$version',
            '-Ddart-sdk=third_party/dart/sdk/',
            '-Dtests-dir=tests/',
            '-Djava-home=$javaHome',
            '-Dtest.dart.build-dir=$buildDir',
            '-Dtest.dart.build-arch=${configuration["arch"]}',
            '-Dtest.dart.build-system=${configuration["system"]}',
            '-Dtest.dart.build-clang=${configuration["clang"]}',
            '-Dtest.dart.build-asan=${configuration["asan"]}',
            '-Dtest.dart.temp-dir=$tempDirPath',
            '-Dtest.dart.servicec-dir=tools/servicec/',
            '-c',
            '--packages=.packages',
-           '-Dtest.fletch_test_suite.port=${server.port}',
-           '$testSuiteDir/fletch_test_suite.dart']).then((io.Process process) {
+           '-Dtest.dartino_test_suite.port=${server.port}',
+           '$testSuiteDir/dartino_test_suite.dart']).then((io.Process process) {
              process.exitCode.then((_) {
                helperProgramExited = true;
                server.close();
              });
              vmProcess = process;
              return process.stdin.close();
            }).then((_) {
              return server.first.catchError((error) {
                // The VM died before we got a connection.
                assert(helperProgramExited);
                return null;
              });
            }).then((io.Socket socket) {
              server.close();
              return socket;
            });
     }).then((io.Socket socket) {
       assert(socket != null || helperProgramExited);
       completer = new TestCompleter(vmProcess, socket);
       completer.initialize();
       return completer.requestTestNames();
     }).then((List<String> testNames) {
       for (String name in testNames) {
         Set<Expectation> expectedOutcomes = expectations.expectations(name);
         TestCase testCase = new TestCase(
-            'fletch_tests/$name', <Command>[], configuration, expectedOutcomes);
-        var command = new FletchTestCommand(name, completer);
+            'dartino_tests/$name', <Command>[], configuration, expectedOutcomes);
+        var command = new DartinoTestCommand(name, completer);
         testCase.commands.add(command);
         if (!expectedOutcomes.contains(Expectation.SKIP)) {
           completer.expect(command);
         }
         enqueueNewTestCase(testCase);
       }
     }).then((_) {
       onDone();
     });
   }
@@ skipping 70 matching lines @@
     if (javaHome == null) return false;
     return new io.File('$javaHome/include/jni.h').existsSync();
   }
 }
 
 /// Pattern that matches warnings (from dart2js) that contain a comment saying
 /// "NO_LINT".
 final RegExp noLintFilter =
     new RegExp(r"[^\n]*\n[^\n]*\n[^\n]* // NO_LINT\n *\^+\n");
 
-class FletchTestOutputCommand implements CommandOutput {
+class DartinoTestOutputCommand implements CommandOutput {
   final Command command;
   final Duration time;
   final Message message;
   final List<String> stdoutLines;
 
-  FletchTestOutputCommand(
+  DartinoTestOutputCommand(
       this.command,
       this.message,
       this.time,
       this.stdoutLines);
 
   Expectation result(TestCase testCase) {
     switch (message.type) {
       case 'TestPassed':
         return Expectation.PASS;
 
@@ skipping 52 matching lines @@
         break;
     }
     return UTF8.encode(result);
   }
 
   List<String> get diagnostics => <String>[];
 
   bool get compilationSkipped => false;
 }
 
-class FletchTestCommand implements Command {
+class DartinoTestCommand implements Command {
   final String _name;
 
   final TestCompleter _completer;
 
-  FletchTestCommand(this._name, this._completer);
+  DartinoTestCommand(this._name, this._completer);
 
-  String get displayName => "fletch_test";
+  String get displayName => "dartino_test";
 
   int get maxNumRetries => 0;
 
-  Future<FletchTestOutputCommand> run(int timeout) {
+  Future<DartinoTestOutputCommand> run(int timeout) {
     Stopwatch sw = new Stopwatch()..start();
     return _completer.run(this, timeout).then((NamedMessage message) {
-      FletchTestOutputCommand output =
-          new FletchTestOutputCommand(
+      DartinoTestOutputCommand output =
+          new DartinoTestOutputCommand(
               this, message, sw.elapsed, _completer.testOutput[message.name]);
       _completer.done(this);
       return output;
     });
   }
 
-  String toString() => 'FletchTestCommand($_name)';
+  String toString() => 'DartinoTestCommand($_name)';
 
   set displayName(_) => throw "not supported";
 
   get commandLine => throw "not supported";
   set commandLine(_) => throw "not supported";
 
   String get reproductionCommand => throw "not supported";
 
   get outputIsUpToDate => throw "not supported";
 }
 
 class TestCompleter {
-  final Map<String, FletchTestCommand> expected =
-      new Map<String, FletchTestCommand>();
+  final Map<String, DartinoTestCommand> expected =
+      new Map<String, DartinoTestCommand>();
   final Map<String, Completer> completers = new Map<String, Completer>();
   final Completer<List<String>> testNamesCompleter =
       new Completer<List<String>>();
   final Map<String, List<String>> testOutput = new Map<String, List<String>>();
   final io.Process vmProcess;
   final io.Socket socket;
 
   int exitCode;
   String stderr = "";
 
@@ skipping 42 matching lines @@
     }
     process(messages);
   }
 
   Future<List<String>> requestTestNames() {
     if (socket == null) return new Future.value(<String>[]);
     socket.writeln(JSON.encode(const ListTests().toJson()));
     return testNamesCompleter.future;
   }
 
-  void expect(FletchTestCommand command) {
+  void expect(DartinoTestCommand command) {
     expected[command._name] = command;
   }
 
-  void done(FletchTestCommand command) {
+  void done(DartinoTestCommand command) {
     expected.remove(command._name);
     if (expected.isEmpty) {
       allDone();
     }
   }
 
-  Future run(FletchTestCommand command, int timeout) {
+  Future run(DartinoTestCommand command, int timeout) {
     if (command._name == "self/testNeverCompletes") {
       // Ensure timeout test times out quickly.
       timeout = 1;
     }
     socket.writeln(
         JSON.encode(new RunTest(command._name).toJson()));
     Timer timer = new Timer(new Duration(seconds: timeout), () {
       socket.writeln(
           JSON.encode(new TimedOut(command._name).toJson()));
     });
@@ skipping 52 matching lines @@
         process(messages);
       }
     });
   }
 
   void allDone() {
     // This should cause the vmProcess to exit.
     socket.close();
   }
 }