Fix standalone/FileTest

tests/standalone/src/FileTest.dart

 // Copyright (c) 2011, 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.
 
 
 class FileTest {
+  static Directory tempDirectory;
+  static int numLiveAsyncTests = 0;
+
+  static void asyncTestStarted() { ++numLiveAsyncTests; }
+  static void asyncTestDone() {
+    --numLiveAsyncTests;
+    if (numLiveAsyncTests == 0) {
+      deleteTempDirectory();
+    }
+  }
+
+  static void createTempDirectory(Function doNext) {
+    tempDirectory = new Directory('');
+    tempDirectory.createTempHandler = doNext;
+    tempDirectory.createTemp();
+  }
+
+  static void deleteTempDirectory() {
+    tempDirectory.deleteSync();
+  }
+
   // Test for file read functionality.
   static int testReadStream() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
     FileInputStream input = file.openInputStream();
     List<int> buffer = new List<int>(42);
     int bytesRead = input.readInto(buffer, 0, 12);
     Expect.equals(12, bytesRead);
     bytesRead = input.readInto(buffer, 12, 30);
@@ skipping 18 matching lines @@
   static int testReadWriteStream() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     File file = new File(inFilename);
     FileInputStream input = file.openInputStream();
     List<int> buffer1 = new List<int>(42);
     int bytesRead = input.readInto(buffer1, 0, 42);
     Expect.equals(42, bytesRead);
     input.close();
     // Write the contents of the file just read into another file.
-    String outFilenameBase = getFilename("tests/vm/data/fixed_length_file");
-    String outFilename = outFilenameBase + "_out_read_write_stream";
+    String outFilename = tempDirectory.path + "/out_read_write_stream";
     file = new File(outFilename);
     OutputStream output = file.openOutputStream();
     bool writeDone = output.writeFrom(buffer1, 0, 42);
     Expect.equals(true, writeDone);
     output.close();
     // Now read the contents of the file just written.
     List<int> buffer2 = new List<int>(42);
     file = new File(outFilename);
     input = file.openInputStream();
     bytesRead = input.readInto(buffer2, 0, 42);
@@ skipping 75 matching lines @@
     File file = new File(inFilename);
     file.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
     file.openHandler = () {
       List<int> buffer1 = new List<int>(42);
       file.readListHandler = (bytes_read) {
         Expect.equals(42, bytes_read);
         file.closeHandler = () {
           // Write the contents of the file just read into another file.
-          String outFilenameBase =
-              getFilename("tests/vm/data/fixed_length_file");
-          String outFilename = outFilenameBase + "_out_read_write";
+          String outFilename = tempDirectory.path + "/out_read_write";
           file = new File(outFilename);
           file.errorHandler = (s) {
             Expect.fail("No errors expected");
           };
           file.createHandler = () {
             file.fullPathHandler = (s) {
               Expect.isTrue(new File(s).existsSync());
               if (s[0] != '/' && s[0] != '\\' && s[1] != ':') {
                 Expect.fail("Not a full path");
               }
@@ skipping 13 matching lines @@
                           // Now compare the two buffers to check if they
                           // are identical.
                           Expect.equals(buffer1.length, buffer2.length);
                           for (int i = 0; i < buffer1.length; i++) {
                             Expect.equals(buffer1[i],  buffer2[i]);
                           }
                           // Delete the output file.
                           file.deleteHandler = () {
                             file.existsHandler = (exists) {
                               Expect.isFalse(exists);
+                              asyncTestDone();
                             };
                             file.exists();
                           };
                           file.delete();
                         };
                         file.close();
                       };
                       file.readList(buffer2, 0, 42);
                     };
                     file.open();
                   };
                   file.close();
                 };
                 file.writeList(buffer1, 0, bytes_read);
               };
               file.open(true);
             };
             file.fullPath();
           };
           file.create();
         };
         file.close();
       };
       file.readList(buffer1, 0, 42);
     };
+    asyncTestStarted();
     file.open();
     return 1;
 
   }
 
   static int testReadWriteSync() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     File file = new File(inFilename);
     file.openSync();
     List<int> buffer1 = new List<int>(42);
     int bytes_read = 0;
     int bytes_written = 0;
     bytes_read = file.readListSync(buffer1, 0, 42);
     Expect.equals(42, bytes_read);
     file.closeSync();
     // Write the contents of the file just read into another file.
-    String outFilenameBase = getFilename("tests/vm/data/fixed_length_file");
-    String outFilename = outFilenameBase + "_out_read_write_sync";
+    String outFilename = tempDirectory.path + "/out_read_write_sync";
     file = new File(outFilename);
     file.createSync();
     String path = file.fullPathSync();
     if (path[0] != '/' && path[0] != '\\' && path[1] != ':') {
       Expect.fail("Not a full path");
     }
     Expect.isTrue(new File(path).existsSync());
     file.openSync(true);
     file.writeListSync(buffer1, 0, bytes_read);
     file.closeSync();
@@ skipping 87 matching lines @@
     Expect.equals(12, input.positionSync());
     input.readListSync(buffer, 12, 6);
     Expect.equals(18, input.positionSync());
     input.setPositionSync(8);
     Expect.equals(8, input.positionSync());
     input.closeSync();
     return 1;
   }
 
   static int testTruncate() {
-    String filename = getFilename("tests/vm/data/fixed_length_file");
-    File file = new File("${filename}_out_truncate");
+    File file = new File(tempDirectory.path + "/out_truncate");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     file.errorHandler = (error) {
       Expect.fail("testTruncate: No errors expected");
     };
     file.openHandler = () {
       file.noPendingWriteHandler = () {
         file.lengthHandler = (length) {
           Expect.equals(10, length);
           file.truncateHandler = () {
             file.lengthHandler = (length) {
               Expect.equals(5, length);
               file.closeHandler = () {
                 file.deleteHandler = () {
                   file.existsHandler = (exists) {
                     Expect.isFalse(exists);
+                    asyncTestDone();
                   };
                   file.exists();
                 };
                 file.delete();
               };
               file.close();
             };
             file.length();
           };
           file.truncate(5);
         };
         file.length();
       };
       file.writeList(buffer, 0, 10);
     };
+    asyncTestStarted();
     file.open(true);
     return 1;
   }
 
   static int testTruncateSync() {
-    String filename = getFilename("tests/vm/data/fixed_length_file");
-    File file = new File("${filename}_out_truncate_sync");
+    File file = new File(tempDirectory.path + "/out_truncate_sync");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     file.openSync(true);
     file.writeListSync(buffer, 0, 10);
     Expect.equals(10, file.lengthSync());
     file.truncateSync(5);
     Expect.equals(5, file.lengthSync());
     file.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
     return 1;
   }
 
   // Tests exception handling after file was closed.
   static int testCloseException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
-    String filename = getFilename("tests/vm/data/fixed_length_file");
-    File input = new File(filename + "_out_close_exception");
+    File input = new File(tempDirectory.path + "/out_close_exception");
     input.openSync(true);
     input.closeSync();
     try {
       input.readByteSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
@@ skipping 71 matching lines @@
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     input.deleteSync();
     return 1;
   }
 
   // Tests stream exception handling after file was closed.
   static int testCloseExceptionStream() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
-    String filename = getFilename("tests/vm/data/fixed_length_file");
-    File file = new File(filename + "_out_close_exception_stream");
+    File file = new File(tempDirectory.path + "/out_close_exception_stream");
     file.createSync();
     FileInputStream input = file.openInputStream();
     input.close();
     try {
       List<int> buffer = new List<int>(42);
       input.readInto(buffer, 0, 12);
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
@@ skipping 14 matching lines @@
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     file.deleteSync();
     return 1;
   }
 
   // Tests buffer out of bounds exception.
   static int testBufferOutOfBoundsException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
-    String filename = getFilename("tests/vm/data/fixed_length_file");
-    File file = new File(filename + "_out_buffer_out_of_bounds");
+    File file = new File(tempDirectory.path + "/out_buffer_out_of_bounds");
     file.openSync(true);
     try {
       List<int> buffer = new List<int>(10);
       bool readDone = file.readListSync(buffer, 0, 12);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
@@ skipping 100 matching lines @@
 
   // Helper method to be able to run the test from the runtime
   // directory, or the top directory.
   static String getFilename(String path) =>
       new File(path).existsSync() ? path : 'runtime/' + path;
 
   // Main test entrypoint.
   static testMain() {
     Expect.equals(1, testRead());
     Expect.equals(1, testReadSync());
-    Expect.equals(1, testReadWrite());
-    Expect.equals(1, testReadWriteSync());
     Expect.equals(1, testReadStream());
-    Expect.equals(1, testReadWriteStream());
     Expect.equals(1, testLength());
     Expect.equals(1, testLengthSync());
     Expect.equals(1, testPosition());
     Expect.equals(1, testPositionSync());
-    Expect.equals(1, testTruncate());
-    Expect.equals(1, testTruncateSync());
-    Expect.equals(1, testCloseException());
-    Expect.equals(1, testCloseExceptionStream());
-    Expect.equals(1, testBufferOutOfBoundsException());
     Expect.equals(1, testMixedSyncAndAsync());
+    asyncTestStarted();
+    createTempDirectory(() {
+        Expect.equals(1, testReadWrite());
+        Expect.equals(1, testReadWriteSync());
+        Expect.equals(1, testReadWriteStream());
+        Expect.equals(1, testTruncate());
+        Expect.equals(1, testTruncateSync());
+        Expect.equals(1, testCloseException());
+        Expect.equals(1, testCloseExceptionStream());
+        Expect.equals(1, testBufferOutOfBoundsException());
+        asyncTestDone();
+      });
   }
 }
 
 main() {
   FileTest.testMain();
 }