Allow Platform.executable for JIT app snapshots.

tests/standalone/io/file_test.dart

 // Copyright (c) 2013, 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.
 //
 // Dart test program for testing file I/O.
 
+// OtherResources=fixed_length_file
+// OtherResources=read_as_text.dat
+// OtherResources=readline_test1.dat
+
 import 'dart:async';
 import 'dart:convert';
 import 'dart:collection';
 import 'dart:io';
 
 import "package:async_helper/async_helper.dart";
 import "package:expect/expect.dart";
 import "package:path/path.dart";
 
 class MyListOfOneElement
@@ skipping 66 matching lines @@
             Expect.equals(116, buffer[11]);  // represents 't' in the file.
           }
         });
   }
 
   // Test for file read and write functionality.
   static void testReadWriteStream() {
     asyncTestStarted();
 
     // Read a file.
-    String inFilename = getFilename("tests/vm/data/fixed_length_file");
+    String inFilename = getFilename("fixed_length_file");
     File file;
     int bytesRead;
 
     var file1 = new File(inFilename);
     List<int> buffer = new List<int>();
     file1.openRead().listen(
       (d) {
         buffer.addAll(d);
       },
       onDone: () {
@@ skipping 163 matching lines @@
     Expect.equals(111, buffer[4]);  // represents 'o' in the file.
     Expect.equals(112, buffer[5]);  // represents 'p' in the file.
     Expect.equals(121, buffer[6]);  // represents 'y' in the file.
     Expect.equals(114, buffer[7]);  // represents 'r' in the file.
     Expect.equals(105, buffer[8]);  // represents 'i' in the file.
     Expect.equals(103, buffer[9]);  // represents 'g' in the file.
     Expect.equals(104, buffer[10]);  // represents 'h' in the file.
     Expect.equals(116, buffer[11]);  // represents 't' in the file.
     raf.closeSync();
 
-    filename = getFilename("tests/vm/data/fixed_length_file");
+    filename = getFilename("fixed_length_file");
     File file = new File(filename);
     int len = file.lengthSync();
     int read(int length) {
       var f = file.openSync();
       int res = f.readSync(length).length;
       f.closeSync();
       return res;
     }
     Expect.equals(0, read(0));
     Expect.equals(1, read(1));
     Expect.equals(len - 1, read(len - 1));
     Expect.equals(len, read(len));
     Expect.equals(len, read(len + 1));
     Expect.equals(len, read(len * 2));
     Expect.equals(len, read(len * 10));
   }
 
   // Test for file read and write functionality.
   static void testReadWrite() {
     asyncTestStarted();
     // Read a file.
-    String inFilename = getFilename("tests/vm/data/fixed_length_file");
+    String inFilename = getFilename("fixed_length_file");
     final File file = new File(inFilename);
     file.open(mode: READ).then((openedFile) {
       List<int> buffer1 = new List<int>(42);
       openedFile.readInto(buffer1, 0, 42).then((bytes_read) {
         Expect.equals(42, bytes_read);
         openedFile.close().then((ignore) {
           // Write the contents of the file just read into another file.
           String outFilename = tempDirectory.path + "/out_read_write";
           final File file2 = new File(outFilename);
           file2.create().then((ignore) {
@@ skipping 120 matching lines @@
       Expect.equals(38, raf.lengthSync());
       raf.close().then((ignore) {
         asyncTestDone("testOutputStreamWriteString");
       });
     });
   }
 
 
   static void testReadWriteSync() {
     // Read a file.
-    String inFilename = getFilename("tests/vm/data/fixed_length_file");
+    String inFilename = getFilename("fixed_length_file");
     RandomAccessFile file = (new File(inFilename)).openSync();
     List<int> buffer1 = new List<int>(42);
     int bytes_read = 0;
     int bytes_written = 0;
     bytes_read = file.readIntoSync(buffer1, 0, 42);
     Expect.equals(42, bytes_read);
     file.closeSync();
     // Write the contents of the file just read into another file.
     String outFilename = tempDirectory.path + "/out_read_write_sync";
     File outFile = new File(outFilename);
@@ skipping 17 matching lines @@
     for (int i = 0; i < buffer1.length; i++) {
       Expect.equals(buffer1[i],  buffer2[i]);
     }
     // Delete the output file.
     outFile.deleteSync();
     Expect.isFalse(outFile.existsSync());
   }
 
   static void testReadWriteNoArgsSync() {
     // Read a file.
-    String inFilename = getFilename("tests/vm/data/fixed_length_file");
+    String inFilename = getFilename("fixed_length_file");
     RandomAccessFile file = (new File(inFilename)).openSync();
     List<int> buffer1 = new List<int>(42);
     int bytes_read = 0;
     int bytes_written = 0;
     bytes_read = file.readIntoSync(buffer1);
     Expect.equals(42, bytes_read);
     file.closeSync();
     // Write the contents of the file just read into another file.
     String outFilename = tempDirectory.path + "/out_read_write_sync";
     File outFile = new File(outFilename);
@@ skipping 119 matching lines @@
     Expect.equals("${tempDir}", file.parent.path);
     file = new File("foo");
     Expect.equals(".", file.parent.path);
     file = new File(".");
     Expect.equals(".", file.parent.path);
   }
 
   // Test for file length functionality.
   static void testLength() {
     asyncTestStarted();
-    String filename = getFilename("tests/vm/data/fixed_length_file");
+    String filename = getFilename("fixed_length_file");
     File file = new File(filename);
     RandomAccessFile openedFile = file.openSync();
     openedFile.length().then((length) {
       Expect.equals(42, length);
       openedFile.close().then((ignore) => asyncTestDone("testLength"));
     });
     file.length().then((length) {
       Expect.equals(42, length);
     });
   }
 
   static void testLengthSync() {
-    String filename = getFilename("tests/vm/data/fixed_length_file");
+    String filename = getFilename("fixed_length_file");
     File file = new File(filename);
     RandomAccessFile openedFile = file.openSync();
     Expect.equals(42, file.lengthSync());
     Expect.equals(42, openedFile.lengthSync());
     openedFile.closeSync();
   }
 
   // Test for file position functionality.
   static void testPosition() {
     asyncTestStarted();
-    String filename = getFilename("tests/vm/data/fixed_length_file");
+    String filename = getFilename("fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     input.position().then((position) {
       Expect.equals(0, position);
       List<int> buffer = new List<int>(100);
       input.readInto(buffer, 0, 12).then((bytes_read) {
         input.position().then((position) {
           Expect.equals(12, position);
           input.readInto(buffer, 12, 18).then((bytes_read) {
             input.position().then((position) {
               Expect.equals(18, position);
               input.setPosition(8).then((ignore) {
                 input.position().then((position) {
                   Expect.equals(8, position);
                   input.close().then((ignore) => asyncTestDone("testPosition"));
                 });
               });
             });
           });
         });
       });
     });
   }
 
   static void testPositionSync() {
-    String filename = getFilename("tests/vm/data/fixed_length_file");
+    String filename = getFilename("fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     Expect.equals(0, input.positionSync());
     List<int> buffer = new List<int>(100);
     input.readIntoSync(buffer, 0, 12);
     Expect.equals(12, input.positionSync());
     input.readIntoSync(buffer, 12, 18);
     Expect.equals(18, input.positionSync());
     input.setPositionSync(8);
     Expect.equals(8, input.positionSync());
     input.closeSync();
@@ skipping 371 matching lines @@
     try {
       f.openSync();
       Expect.fail("Expected exception opening directory as file");
     } catch (e) {
       Expect.isTrue(e is FileSystemException);
     }
   }
 
   static void testReadAsBytes() {
     asyncTestStarted();
-    var name = getFilename("tests/vm/data/fixed_length_file");
+    var name = getFilename("fixed_length_file");
     var f = new File(name);
     f.readAsBytes().then((bytes) {
       Expect.isTrue(new String.fromCharCodes(bytes).endsWith("42 bytes."));
       Expect.equals(42, bytes.length);
       asyncTestDone("testReadAsBytes");
     });
   }
 
   static void testReadAsBytesEmptyFile() {
     asyncTestStarted();
     var name = getFilename("tests/vm/data/empty_file");
     var f = new File(name);
     f.readAsBytes().then((bytes) {
       Expect.equals(0, bytes.length);
       asyncTestDone("testReadAsBytesEmptyFile");
     });
   }
 
   static void testReadAsBytesSync() {
-    var name = getFilename("tests/vm/data/fixed_length_file");
+    var name = getFilename("fixed_length_file");
     var bytes = new File(name).readAsBytesSync();
     Expect.isTrue(new String.fromCharCodes(bytes).endsWith("42 bytes."));
     Expect.equals(bytes.length, 42);
   }
 
   static void testReadAsBytesSyncEmptyFile() {
     var name = getFilename("tests/vm/data/empty_file");
     var bytes = new File(name).readAsBytesSync();
     Expect.equals(bytes.length, 0);
   }
 
   static void testReadAsText() {
     asyncTestStarted();
-    var name = getFilename("tests/vm/data/fixed_length_file");
+    var name = getFilename("fixed_length_file");
     var f = new File(name);
     f.readAsString(encoding: UTF8).then((text) {
       Expect.isTrue(text.endsWith("42 bytes."));
       Expect.equals(42, text.length);
-      var name = getFilename("tests/standalone/io/read_as_text.dat");
+      var name = getFilename("read_as_text.dat");
       var f = new File(name);
       f.readAsString(encoding: UTF8).then((text) {
         Expect.equals(6, text.length);
         var expected = [955, 120, 46, 32, 120, 10];
         Expect.listEquals(expected, text.codeUnits);
         f.readAsString(encoding: LATIN1).then((text) {
           Expect.equals(7, text.length);
           var expected = [206, 187, 120, 46, 32, 120, 10];
           Expect.listEquals(expected, text.codeUnits);
           var readAsStringFuture = f.readAsString(encoding: ASCII);
@@ skipping 12 matching lines @@
     var name = getFilename("tests/vm/data/empty_file");
     var f = new File(name);
     f.readAsString(encoding: UTF8).then((text) {
       Expect.equals(0, text.length);
       asyncTestDone("testReadAsTextEmptyFile");
       return true;
     });
   }
 
   static void testReadAsTextSync() {
-    var name = getFilename("tests/vm/data/fixed_length_file");
+    var name = getFilename("fixed_length_file");
     var text = new File(name).readAsStringSync();
     Expect.isTrue(text.endsWith("42 bytes."));
     Expect.equals(42, text.length);
-    name = getFilename("tests/standalone/io/read_as_text.dat");
+    name = getFilename("read_as_text.dat");
     text = new File(name).readAsStringSync();
     Expect.equals(6, text.length);
     var expected = [955, 120, 46, 32, 120, 10];
     Expect.listEquals(expected, text.codeUnits);
     // First character is not ASCII. The default ASCII decoder will throw.
     Expect.throws(() => new File(name).readAsStringSync(encoding: ASCII),
                   (e) => e is FileSystemException);
     // We can use an ASCII decoder that inserts the replacement character.
     var lenientAscii = const AsciiCodec(allowInvalid: true);
     text = new File(name).readAsStringSync(encoding: lenientAscii);
     // Default replacement character is the Unicode replacement character.
     expected = [UNICODE_REPLACEMENT_CHARACTER_RUNE,
                 UNICODE_REPLACEMENT_CHARACTER_RUNE,
                 120, 46, 32, 120, 10];
     Expect.listEquals(expected, text.codeUnits);
     text = new File(name).readAsStringSync(encoding: LATIN1);
     expected = [206, 187, 120, 46, 32, 120, 10];
     Expect.equals(7, text.length);
     Expect.listEquals(expected, text.codeUnits);
   }
 
   static void testReadAsTextSyncEmptyFile() {
     var name = getFilename("tests/vm/data/empty_file");
     var text = new File(name).readAsStringSync();
     Expect.equals(0, text.length);
   }
 
   static void testReadAsLines() {
     asyncTestStarted();
-    var name = getFilename("tests/vm/data/fixed_length_file");
+    var name = getFilename("fixed_length_file");
     var f = new File(name);
     f.readAsLines(encoding: UTF8).then((lines) {
       Expect.equals(1, lines.length);
       var line = lines[0];
       Expect.isTrue(line.endsWith("42 bytes."));
       Expect.equals(42, line.length);
       asyncTestDone("testReadAsLines");
     });
   }
 
   static void testReadAsLinesSync() {
-    var name = getFilename("tests/vm/data/fixed_length_file");
+    var name = getFilename("fixed_length_file");
     var lines = new File(name).readAsLinesSync();
     Expect.equals(1, lines.length);
     var line = lines[0];
     Expect.isTrue(line.endsWith("42 bytes."));
     Expect.equals(42, line.length);
-    name = getFilename("tests/standalone/io/readline_test1.dat");
+    name = getFilename("readline_test1.dat");
     lines = new File(name).readAsLinesSync();
     Expect.equals(10, lines.length);
   }
 
 
   static void testReadAsErrors() {
     asyncTestStarted();
     var f = new File('.');
     Expect.throws(f.readAsBytesSync, (e) => e is FileSystemException);
     Expect.throws(f.readAsStringSync, (e) => e is FileSystemException);
@@ skipping 200 matching lines @@
       var brokenLink = new Link(source);
       brokenLink.createSync(dest);
       Expect.throws(() => file.renameSync('xxx'));
       brokenLink.deleteSync();
     }
   }
 
   // Helper method to be able to run the test from the runtime
   // directory, or the top directory.
   static String getFilename(String path) {
-    var testPath = Platform.script.resolve('../../../$path');
+    var testPath = Platform.script.resolve(path);
     return new File.fromUri(testPath).existsSync()
         ? testPath.toFilePath()
-        : Platform.script.resolve('../../../runtime/$path').toFilePath();
+        : Uri.parse(Platform.executable).resolve('../../runtime/$path').toFilePath();
   }
 
   // Main test entrypoint.
   static testMain() {
     asyncStart();
 
     testRead();
     testReadSync();
     testReadStream();
     testLengthSync();
@@ skipping 49 matching lines @@
       testLastModified();
       testDoubleAsyncOperation();
       asyncEnd();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }