Ensure FileTest.dart deletes temporary directories

tests/standalone/src/FileTest.dart

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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.
 //
 // Dart test program for testing file I/O.
 
 #import("dart:io");
 
 class FileTest {
   static Directory tempDirectory;
   static int numLiveAsyncTests = 0;
 
   static void asyncTestStarted() { ++numLiveAsyncTests; }
-  static void asyncTestDone() {
+  static void asyncTestDone(String name) {
     --numLiveAsyncTests;
     if (numLiveAsyncTests == 0) {
       deleteTempDirectory();
     }
   }
 
   static void createTempDirectory(Function doNext) {
     tempDirectory = new Directory('');
     tempDirectory.createTempHandler = doNext;
     tempDirectory.createTemp();
@@ skipping 200 matching lines @@
                           // 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.
                           final file4 = file3;
                           file4.deleteHandler = () {
                             file4.existsHandler = (exists) {
                               Expect.isFalse(exists);
-                              asyncTestDone();
+                              asyncTestDone("testReadWrite");
                             };
                             file4.exists();
                           };
                           file4.delete();
                         };
                         openedFile3.close();
                       };
                       openedFile3.readList(buffer2, 0, 42);
                     };
                     file3.open();
@@ skipping 40 matching lines @@
     file.deleteSync();
   }
 
   static void testOutputStreamWriteAppend() {
     String content = "foobar";
     String filename = tempDirectory.path + "/outstream_write_append";
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.charCodes();
     OutputStream outStream = file.openOutputStream();
-    outStream.closeHandler = () {
-      File file2 = new File(filename);
-      OutputStream appendingOutput = file2.openOutputStream(FileMode.APPEND);
-      appendingOutput.write(buffer);
-      appendingOutput.closeHandler = () {
-        File file3 = new File(filename);
-        file3.openHandler = (RandomAccessFile openedFile) {
-          openedFile.lengthHandler = (int length) {
-            Expect.equals(content.length * 2, length);
-            openedFile.closeHandler = () {
-              asyncTestDone();
-            };
-            openedFile.close();
-          };
-          openedFile.length();
-        };
-        file3.open();
-      };
-      appendingOutput.close();
-    };
-    asyncTestStarted();
     outStream.write(buffer);
     outStream.close();

[ricow1, 2012/02/13 11:40:45]

how do we know that the output has been written to outStream when we write to
appendingOutput?

[Søren Gjesse, 2012/02/13 11:58:04]

Output streams are buffering streams which will flush buffered data when
closing.

+    File file2 = new File(filename);
+    OutputStream appendingOutput = file2.openOutputStream(FileMode.APPEND);
+    appendingOutput.write(buffer);
+    appendingOutput.close();
+    File file3 = new File(filename);
+    file3.openHandler = (RandomAccessFile openedFile) {
+      openedFile.lengthHandler = (int length) {
+        Expect.equals(content.length * 2, length);
+        openedFile.closeHandler = () {
+          file3.deleteHandler = () {
+            asyncTestDone("testOutputStreamWriteAppend");
+          };
+          file3.delete();
+        };
+        openedFile.close();
+      };
+      openedFile.length();
+    };
+    file3.open();
+    asyncTestStarted();
   }
 
-  
+
   static void testReadWriteSync() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/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.readListSync(buffer1, 0, 42);
     Expect.equals(42, bytes_read);
     file.closeSync();
@@ skipping 43 matching lines @@
     };
     file.createHandler = () {
       file.openHandler = (RandomAccessFile openedFile) {
         openedFile.readByteHandler = (int byte) {
           Expect.fail("Read byte from empty file");
         };
         openedFile.errorHandler = (String err) {
           Expect.isTrue(err.indexOf("failed") != -1);
           openedFile.closeHandler = () {
             file.deleteHandler = () {
-              asyncTestDone();
+              asyncTestDone("testReadEmptyFile");
             };
             file.delete();
           };
           openedFile.close();
         };
         openedFile.readByte();
       };
       file.open();
     };
     asyncTestStarted();
@@ skipping 80 matching lines @@
       openedFile.noPendingWriteHandler = () {
         openedFile.lengthHandler = (length) {
           Expect.equals(10, length);
           openedFile.truncateHandler = () {
             openedFile.lengthHandler = (length) {
               Expect.equals(5, length);
               openedFile.closeHandler = () {
                 file.deleteHandler = () {
                   file.existsHandler = (exists) {
                     Expect.isFalse(exists);
-                    asyncTestDone();
+                    asyncTestDone("testTruncate");
                   };
                   file.exists();
                 };
                 file.delete();
               };
               openedFile.close();
             };
             openedFile.length();
           };
           openedFile.truncate(5);
@@ skipping 250 matching lines @@
             openedFile.lengthHandler = (length) {
               Expect.equals(4, length);
               openedFile.setPositionHandler = () {
                 openedFile.noPendingWriteHandler = () {
                   openedFile.lengthHandler = (length) {
                     Expect.equals(8, length);
                     openedFile.closeHandler = () {
                       file.deleteHandler = () {
                         file.existsHandler = (exists) {
                           Expect.isFalse(exists);
-                          asyncTestDone();
+                          asyncTestDone("testAppend");
                         };
                         file.exists();
                       };
                       file.delete();
                     };
                     openedFile.close();
                   };
                   openedFile.length();
                 };
                 openedFile.writeString("asdf");
@@ skipping 35 matching lines @@
   // Main test entrypoint.
   static testMain() {
     testRead();
     testReadSync();
     testReadStream();
     testLength();
     testLengthSync();
     testPosition();
     testPositionSync();
     testMixedSyncAndAsync();
-    asyncTestStarted();
+
     createTempDirectory(() {
         testReadWrite();
         testReadWriteSync();
         testReadWriteStream();
         testReadEmptyFileSync();
         testReadEmptyFile();
         testTruncate();
         testTruncateSync();
         testCloseException();
         testCloseExceptionStream();
         testBufferOutOfBoundsException();
         testAppend();
         testAppendSync();
         testWriteAppend();
         testOutputStreamWriteAppend();
-        asyncTestDone();
       });
   }
 }
 
 main() {
   FileTest.testMain();
 }