Rename fletch -> dartino

tests/agent_tests/agent_tests.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:io' show
     Directory,
     File,
     FileSystemException,
     Process,
     ProcessSignal,
     Socket,
     SocketException;
 
 import 'dart:convert' show
     LineSplitter,
     UTF8,
     Utf8Decoder;
 
 import 'dart:async' show
     Future;
 
 import 'package:expect/expect.dart' show
     Expect;
 
-import 'package:fletch_agent/messages.dart' show
+import 'package:dartino_agent/messages.dart' show
     PACKAGE_FILE_NAME;
 
-import 'package:fletch_agent/agent_connection.dart' show
+import 'package:dartino_agent/agent_connection.dart' show
     AgentConnection,
     AgentException,
     VmData;
 
-import 'package:fletchc/src/guess_configuration.dart' show
+import 'package:dartino_compiler/src/guess_configuration.dart' show
     executable;
 
-import '../fletchc/run.dart' show
+import '../dartino_compiler/run.dart' show
     export;
 
 typedef Future NoArgFuture();
 
 List<AgentTest> AGENT_TESTS = <AgentTest>[
   new AgentLifeCycleTest(),
   new AgentUpgradeProtocolTest(),
   new AgentUnsupportedCommandsTest(),
 ];
 
-const String fletchVmExecutable = const String.fromEnvironment('fletch-vm');
+const String dartinoVmExecutable = const String.fromEnvironment('dartino-vm');
 const String buildDirectory =
     const String.fromEnvironment('test.dart.build-dir');
 const int SIGINT = 2;
 
 abstract class AgentTest {
   final String name;
   final String outputDirectory;
   final String host = '127.0.0.1';
   final int port;
   Process process;
   Future stdoutFuture;
   Future stderrFuture;
   Map<String, String> environment;
 
-  /// Each agent test must be assigned a unique port on which the fletch agent
+  /// Each agent test must be assigned a unique port on which the dartino agent
   /// for the specific test is listening. The port must be unique since the
   /// tests are run in parallel.
   AgentTest(String name, int port)
       : this.name = name,
         this.port = port,
         outputDirectory = '$buildDirectory/tests/$name' {
     environment = {
-      'FLETCH_VM': fletchVmExecutable,
+      'DARTINO_VM': dartinoVmExecutable,
       'AGENT_IP': host,
       'AGENT_PORT': port.toString(),
-      'AGENT_PID_FILE': '$outputDirectory/fletch-agent.pid',
-      'AGENT_LOG_FILE': '$outputDirectory/fletch-agent.log',
+      'AGENT_PID_FILE': '$outputDirectory/dartino-agent.pid',
+      'AGENT_LOG_FILE': '$outputDirectory/dartino-agent.log',
       'VM_LOG_DIR': outputDirectory,
       'VM_PID_DIR': outputDirectory,
       'AGENT_UPGRADE_DRY_RUN': 'true',
     };
   }
 
   Future<Null> execute();
 
   void createOutputDirectory() {
     new Directory(outputDirectory).createSync(recursive: true);
   }
 
   void deleteOutputDirectory() {
     new Directory(outputDirectory).deleteSync(recursive: true);
   }
 
   Future<Null> createSnapshot() async {
-    // Find the path to the fletch agent script.
-    Uri script = executable.resolve('../../pkg/fletch_agent/bin/agent.dart');
-    await export(script.toFilePath(), '$outputDirectory/fletch-agent.snapshot');
-    print('Agent snapshot generated: $outputDirectory/fletch-agent.snapshot');
+    // Find the path to the dartino agent script.
+    Uri script = executable.resolve('../../pkg/dartino_agent/bin/agent.dart');
+    await export(script.toFilePath(), '$outputDirectory/dartino-agent.snapshot');
+    print('Agent snapshot generated: $outputDirectory/dartino-agent.snapshot');
   }
 
   Future<Null> start() async {
     process = await Process.start(
-        fletchVmExecutable,
-        ['$outputDirectory/fletch-agent.snapshot'],
+        dartinoVmExecutable,
+        ['$outputDirectory/dartino-agent.snapshot'],
         environment: environment);
     stdoutFuture = process.stdout.transform(UTF8.decoder)
         .transform(new LineSplitter())
         .listen(print).asFuture();
     stderrFuture = process.stderr.transform(UTF8.decoder)
         .transform(new LineSplitter())
         .listen(print).asFuture();
     print('Running agent with pid ${process.pid}');
   }
 
@@ skipping 52 matching lines @@
   }
   return tests;
 }
 
 class AgentLifeCycleTest extends AgentTest {
   AgentLifeCycleTest() : super('testAgentLifeCycle', 20000);
 
   Future<Null> execute() async {
     // Check the version.
     await withConnection((AgentConnection connection) async {
-      String version = await connection.fletchVersion();
+      String version = await connection.dartinoVersion();
       Expect.isTrue(version.length > 0, 'No version found.');
     });
 
     // Start a VM.
     VmData data;
     await withConnection((AgentConnection connection) async {
       data = await connection.startVm();
-      Expect.isNotNull(data, 'Failed to spawn new fletch VM');
+      Expect.isNotNull(data, 'Failed to spawn new dartino VM');
       Expect.isNotNull(data.id, 'Null is not a valid VM pid');
       Expect.notEquals(0, data.id, 'Invalid pid returned for VM');
       Expect.isNotNull(data.port, 'Null is not a valid VM port');
       Expect.notEquals(0, data.port, 'Invalid port returned for VM');
       // This will not work on Windows, since the ProcessSignal argument
-      // is ignored and the fletch-vm is killed.
-      Expect.isTrue(await checkVmState(data.id, true), 'Fletch vm not running');
+      // is ignored and the dartino-vm is killed.
+      Expect.isTrue(await checkVmState(data.id, true), 'Dartino vm not running');
       print('Started 1. VM with id ${data.id} on port ${data.port}.');
     });
 
     // Stop the spawned vm.
     await withConnection((AgentConnection connection) async {
       await connection.stopVm(data.id);
       Expect.isFalse(await checkVmState(data.id, false),
-          'Fletch vm still running');
+          'Dartino vm still running');
       print('Stopped VM with id ${data.id} on port ${data.port}.');
     });
 
     // Start a new vm.
     await withConnection((AgentConnection connection) async {
       data = await connection.startVm();
-      Expect.isNotNull(data, 'Failed to spawn new fletch VM');
+      Expect.isNotNull(data, 'Failed to spawn new dartino VM');
       Expect.isNotNull(data.id, 'Null is not a valid VM pid');
       Expect.notEquals(0, data.id, 'Invalid pid returned for VM');
       Expect.isNotNull(data.port, 'Null is not a valid VM port');
       Expect.notEquals(0, data.port, 'Invalid port returned for VM');
       // This will not work on Windows, since the ProcessSignal argument
-      // is ignored and the fletch-vm is killed.
-      Expect.isTrue(await checkVmState(data.id, true), 'Fletch vm not running');
+      // is ignored and the dartino-vm is killed.
+      Expect.isTrue(await checkVmState(data.id, true), 'Dartino vm not running');
       print('Started 2. VM with id ${data.id} on port ${data.port}.');
     });
 
     // Kill the spawned vm using a signal.
     await withConnection((AgentConnection connection) async {
       await connection.signalVm(data.id, SIGINT);
       Expect.isFalse(await checkVmState(data.id, false),
-          'Fletch vm still running');
+          'Dartino vm still running');
       print('Killed VM with id ${data.id} on port ${data.port}.');
     });
   }
 }
 
 /// The AgentUpgrade test sends over mock binary data (as List<int> data),
 /// representing the new agent package that should be used to upgrade the
 /// agent.
-/// When running the test we start the fletch agent with AGENT_UPGRADE_DRY_RUN
+/// When running the test we start the dartino agent with AGENT_UPGRADE_DRY_RUN
 /// set so it won't actually do the dpkg. This allows us to test that the
-/// fletch agent correctly receives the mock data and writes it into the temp
+/// dartino agent correctly receives the mock data and writes it into the temp
 /// package file.
 class AgentUpgradeProtocolTest extends AgentTest {
   AgentUpgradeProtocolTest() : super('testAgentUpgrade', 20001);
 
   Future<Null> execute() async {
     await withConnection((AgentConnection connection) async {
       List<int> data = [72, 69, 76, 76, 79, 10];
       await connection.upgradeAgent('1-test', data);
       List<int> readData =
           await retry(100, () => new File(PACKAGE_FILE_NAME).readAsBytes());
@@ skipping 45 matching lines @@
 Future<bool> checkVmState(int vmId, bool expectRunning) {
   return retry(-1, () {
     bool running  = Process.killPid(vmId, ProcessSignal.SIGCONT);
     if (expectRunning != running)  {
       throw new Exception(
           'Vm with id $vmId not' + (expectRunning ? 'running' : 'stopped'));
     }
     return running;
   });
 }