test.py: First step towards support of caching dart2js compilations across runtimes

tools/testing/dart/record_and_replay.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.
 
 library record_and_replay;
 
 import 'dart:io';
 import 'dart:json' as json;
 import 'dart:utf';
 
 import 'test_runner.dart';
 
 /*
  * Json files look like this:
  *
  * [
  *   {
  *     'name' : '...',
- *     'configuration' : '...',
  *     'command' : {
  *       'timeout_limit' : 60,
  *       'executable' : '...',
  *       'arguments' : ['arg1, 'arg2', '...'],
  *     },
  *     'command_output' : {
  *       'exit_code' : 42,
  *       'stdout' : '...',
  *       'stderr' : '...',
  *       'duration' : 1.5,
  *       'did_timeout' : false,
  *     },
  *   },
  *   ....
  * ]
  */
 
 
 class TestCaseRecorder {
   Path _outputPath;
   List<Map> _recordedCommandInvocations = [];
   var _cwd;
 
   TestCaseRecorder(this._outputPath) {
     _cwd  = Directory.current.path;
   }
 
-  void nextTestCase(TestCase testCase) {
-    assert(testCase.commands.length == 1);
-
-    var command = testCase.commands[0];
+  void nextCommand(Command command, int timeout) {
     assert(command.environment == null);
 
     var arguments = [];
     for (var rawArgument in command.arguments) {
       if (rawArgument.startsWith(_cwd)) {
         var relative = new Path(rawArgument).relativeTo(new Path(_cwd));
         arguments.add(relative.toNativePath());
       } else {
         arguments.add(rawArgument);
       }
     }
 
     var commandExecution = {
-      'name' : testCase.displayName,
-      'configuration' : testCase.configurationString,
+      'name' : command.displayName,
       'command' : {
-        'timeout_limit' : testCase.timeout,
+        'timeout_limit' : timeout,
         'executable' : command.executable,
         'arguments' : arguments,
       },
     };
     _recordedCommandInvocations.add(commandExecution);
   }
 
   void finish() {
     var file = new File.fromPath(_outputPath);
     var jsonString = json.stringify(_recordedCommandInvocations);
     file.writeAsStringSync(jsonString);
     print("TestCaseRecorder: written all TestCases to ${_outputPath}");
   }
 }
 
 class TestCaseOutputArchive {
-  Map<String, Map> _testCaseOutputRecords;
+  Map<String, Map> _commandOutputRecordings;
+  var _cwd;
+
+  TestCaseOutputArchive() {
+    _cwd  = Directory.current.path;
+  }
 
   void loadFromPath(Path recordingPath) {
     var file = new File.fromPath(recordingPath);
-    var testCases = json.parse(file.readAsStringSync());
-    _testCaseOutputRecords = {};
-    for (var testCase in testCases) {
-      var key = _indexKey(testCase['configuration'], testCase['name']);
-      _testCaseOutputRecords[key] = testCase['command_output'];
+    var commandRecordings = json.parse(file.readAsStringSync());
+    _commandOutputRecordings = {};
+    for (var commandRecording in commandRecordings) {
+      var key = _indexKey(commandRecording['command']['executable'],
+                          commandRecording['command']['arguments'].join(' '));
+      _commandOutputRecordings[key] = commandRecording['command_output'];
     }
   }
 
-  CommandOutput outputOf(TestCase testCase) {
-    var key = _indexKey(testCase.configurationString, testCase.displayName);
-    var command_output = _testCaseOutputRecords[key];
+  CommandOutput outputOf(Command command) {
+    var arguments = [];
+    for (var rawArgument in command.arguments) {
+      if (rawArgument.startsWith(_cwd)) {
+        var relative = new Path(rawArgument).relativeTo(new Path(_cwd));

[ricow1, 2013/07/30 09:30:11]

I like it :-), but please add a comment stating why we do this 

[kustermann, 2013/07/31 15:53:54]

Done.

+        arguments.add(relative.toNativePath());
+      } else {
+        arguments.add(rawArgument);
+      }
+    }
+
+    var key = _indexKey(command.executable, arguments.join(' '));
+    var command_output = _commandOutputRecordings[key];
     if (command_output == null) {
-      print("Sorry, but there is no command output for "
-            "${testCase.displayName}");
-
+      print("Sorry, but there is no command output for ${command.displayName}"
+            " ($command)");
       exit(42);
     }
 
     double seconds = command_output['duration'];
     var duration = new Duration(seconds: seconds.round(),
                                 milliseconds: (seconds/1000).round());
-    var commandOutput = new CommandOutput.fromCase(
-        testCase,
-        testCase.commands.first,
+    var commandOutput = createCommandOutput(
+        command,
         command_output['exit_code'],
-        false,
         command_output['did_timeout'],
         encodeUtf8(command_output['stdout']),
         encodeUtf8(command_output['stderr']),
         duration,
         false);
     return commandOutput;
   }
 
-  String _indexKey(String configuration, String name) {
-    return "${configuration}__$name";
+  String _indexKey(String executable, String arguments) {
+    return "${executable}__$arguments";
   }
 }