Make sure we always have an 'open' asyncStart, while running tests in file_test.

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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:collection';
 import 'dart:io';
@@ skipping 261 matching lines @@
     Expect.equals(1, file.openSync().readSync(1).length);
     Expect.equals(len - 1, file.openSync().readSync(len - 1).length);
     Expect.equals(len, file.openSync().readSync(len).length);
     Expect.equals(len, file.openSync().readSync(len + 1).length);
     Expect.equals(len, file.openSync().readSync(len * 2).length);
     Expect.equals(len, file.openSync().readSync(len * 10).length);
   }
 
   // Test for file read and write functionality.
   static void testReadWrite() {
+    asyncTestStarted();
     // Read a file.
     String inFilename = getFilename("tests/vm/data/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";
@@ skipping 31 matching lines @@
                       });
                     });
                   });
                 });
               });
             });
           });
         });
       });
     });
-    asyncTestStarted();
   }
 
   static void testWriteAppend() {
     String content = "foobar";
     String filename = tempDirectory.path + "/write_append";
     File file = new File(filename);
     file.createSync();
     Expect.isTrue(new File(filename).existsSync());
     List<int> buffer = content.codeUnits;
     RandomAccessFile openedFile = file.openSync(mode: WRITE);
     openedFile.writeFromSync(buffer, 0, buffer.length);
     openedFile.closeSync();
     // Reopen the file in write mode to ensure that we overwrite the content.
     openedFile = (new File(filename)).openSync(mode: WRITE);
     openedFile.writeFromSync(buffer, 0, buffer.length);
     Expect.equals(content.length, openedFile.lengthSync());
     openedFile.closeSync();
     // Open the file in append mode and ensure that we do not overwrite
     // the existing content.
     openedFile = (new File(filename)).openSync(mode: APPEND);
     openedFile.writeFromSync(buffer, 0, buffer.length);
     Expect.equals(content.length * 2, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testOutputStreamWriteAppend() {
+    asyncTestStarted();
     String content = "foobar";
     String filename = tempDirectory.path + "/outstream_write_append";
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.codeUnits;
     var output = file.openWrite();
     output.add(buffer);
     output.close();
     output.done.then((_) {
       File file2 = new File(filename);
       var appendingOutput = file2.openWrite(mode: APPEND);
       appendingOutput.add(buffer);
       appendingOutput.close();
       appendingOutput.done.then((_) {
         File file3 = new File(filename);
         file3.open(mode: READ).then((RandomAccessFile openedFile) {
           openedFile.length().then((int length) {
             Expect.equals(content.length * 2, length);
             openedFile.close().then((ignore) {
               file3.delete().then((ignore) {
                 asyncTestDone("testOutputStreamWriteAppend");
               });
             });
           });
         });
       });
     });
-    asyncTestStarted();
   }
 
   // Test for file read and write functionality.
   static void testOutputStreamWriteString() {
+    asyncTestStarted();
     String content = "foobar";
     String filename = tempDirectory.path + "/outstream_write_string";
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.codeUnits;
     var output = file.openWrite();
     output.write("abcdABCD");
     output.encoding = UTF8;
     output.write("abcdABCD");
     output.encoding = LATIN1;
     output.write("abcdABCD");
     output.encoding = ASCII;
     output.write("abcdABCD");
     output.encoding = UTF8;
     output.write("æøå");
     output.close();
     output.done.then((_) {
       RandomAccessFile raf = file.openSync();
       Expect.equals(38, raf.lengthSync());
       raf.close().then((ignore) {
         asyncTestDone("testOutputStreamWriteString");
       });
     });
-    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;
@@ skipping 226 matching lines @@
     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();
   }
 
   static void testTruncate() {
+    asyncTestStarted();
     File file = new File(tempDirectory.path + "/out_truncate");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     file.open(mode: WRITE).then((RandomAccessFile openedFile) {
       openedFile.writeFrom(buffer, 0, 10).then((ignore) {
         openedFile.length().then((length) {
           Expect.equals(10, length);
           openedFile.truncate(5).then((ignore) {
             openedFile.length().then((length) {
               Expect.equals(5, length);
               openedFile.close().then((ignore) {
                 file.delete().then((ignore) {
                   file.exists().then((exists) {
                     Expect.isFalse(exists);
                     asyncTestDone("testTruncate");
                   });
                 });
               });
             });
           });
         });
       });
     });
-    asyncTestStarted();
   }
 
   static void testTruncateSync() {
     File file = new File(tempDirectory.path + "/out_truncate_sync");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     RandomAccessFile openedFile = file.openSync(mode: WRITE);
     openedFile.writeFromSync(buffer, 0, 10);
     Expect.equals(10, openedFile.lengthSync());
     openedFile.truncateSync(5);
     Expect.equals(5, openedFile.lengthSync());
@@ skipping 398 matching lines @@
 
   static void testLastModifiedSync() {
     var modified = new File(Platform.executable).lastModifiedSync();
     Expect.isTrue(modified is DateTime);
     Expect.isTrue(modified.isBefore(new DateTime.now()));
   }
 
   // Test that opens the same file for writing then for appending to test
   // that the file is not truncated when opened for appending.
   static void testAppend() {
+    asyncTestStarted();
     var file = new File('${tempDirectory.path}/out_append');
     file.open(mode: WRITE).then((openedFile) {
       openedFile.writeString("asdf").then((ignore) {
         openedFile.close().then((ignore) {
           file.open(mode: APPEND).then((openedFile) {
             openedFile.length().then((length) {
               Expect.equals(4, length);
               openedFile.writeString("asdf").then((ignore) {
                 openedFile.length().then((length) {
                   Expect.equals(8, length);
                   openedFile.close().then((ignore) {
                     file.delete().then((ignore) {
                       file.exists().then((exists) {
                         Expect.isFalse(exists);
                         asyncTestDone("testAppend");
                       });
                     });
                   });
                 });
               });
             });
           });
         });
       });
     });
-    asyncTestStarted();
   }
 
   static void testAppendSync() {
     var file = new File('${tempDirectory.path}/out_append_sync');
     var openedFile = file.openSync(mode: WRITE);
     openedFile.writeStringSync("asdf");
     Expect.equals(4, openedFile.lengthSync());
     openedFile.closeSync();
     openedFile = file.openSync(mode: WRITE);
     openedFile.setPositionSync(4);
     openedFile.writeStringSync("asdf");
     Expect.equals(8, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
   }
 
   static void testWriteStringUtf8() {
+    asyncTestStarted();
     var file = new File('${tempDirectory.path}/out_write_string');
     var string = new String.fromCharCodes([0x192]);
     file.open(mode: WRITE).then((openedFile) {
       openedFile.writeString(string).then((_) {
         openedFile.length().then((l) {
           Expect.equals(2, l);
           openedFile.close().then((_) {
             file.open(mode: APPEND).then((openedFile) {
               openedFile.setPosition(2).then((_) {
                 openedFile.writeString(string).then((_) {
@@ skipping 11 matching lines @@
                       });
                     });
                   });
                 });
               });
             });
           });
         });
       });
     });
-    asyncTestStarted();
   }
 
   static void testWriteStringUtf8Sync() {
     var file = new File('${tempDirectory.path}/out_write_string_sync');
     var string = new String.fromCharCodes([0x192]);
     var openedFile = file.openSync(mode: WRITE);
     openedFile.writeStringSync(string);
     Expect.equals(2, openedFile.lengthSync());
     openedFile.closeSync();
     openedFile = file.openSync(mode: APPEND);
     openedFile.setPositionSync(2);
     openedFile.writeStringSync(string);
     Expect.equals(4, openedFile.lengthSync());
     openedFile.closeSync();
     var readBack = file.readAsStringSync();
     Expect.stringEquals(readBack, '$string$string');
     file.deleteSync();
     Expect.isFalse(file.existsSync());
   }
 
   // Test that opens the same file for writing then for appending to test
   // that the file is not truncated when opened for appending.
   static void testRename() {
+    asyncTestStarted();
     var file = new File('${tempDirectory.path}/rename_name');
     file.create().then((file) {
       file.rename("${tempDirectory.path}/rename_newname").then((newfile) {
         file.exists().then((e) {
           Expect.isFalse(e);
           newfile.exists().then((e) {
             Expect.isTrue(e);
             newfile.delete().then((_) {
               file.exists().then((e) {
                 Expect.isFalse(e);
@@ skipping 12 matching lines @@
 
                 } else {
                   asyncTestDone("testRename");
                 }
               });
             });
           });
         });
       });
     });
-    asyncTestStarted();
   }
 
   static void testRenameSync() {
     var file = new File('${tempDirectory.path}/rename_name_sync');
     file.createSync();
     var newfile = file.renameSync('${tempDirectory.path}/rename_newname_sync');
     Expect.isFalse(file.existsSync());
     Expect.isTrue(newfile.existsSync());
     newfile.deleteSync();
     Expect.isFalse(newfile.existsSync());
     if (Platform.operatingSystem != "windows") {
       var brokenLink = new Link('${tempDirectory.path}/rename_name_sync');
       brokenLink.createSync('${tempDirectory.path}/rename_newname_sync');
       Expect.throws(() => file.renameSync('xxx'));
     }
   }
 
   // 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';
 
   static String getDataFilename(String path) =>
       new File(path).existsSync() ? path : '../$path';
 
   // Main test entrypoint.
   static testMain() {
+    asyncStart();
+
     testRead();
     testReadSync();
     testReadStream();
     testLengthSync();
     testPositionSync();
     testOpenDirectoryAsFile();
     testOpenDirectoryAsFileSync();
     testOpenFile();
     testReadAsBytesSync();
     testReadAsBytesSyncEmptyFile();
@@ skipping 29 matching lines @@
       testOutputStreamWriteAppend();
       testOutputStreamWriteString();
       testWriteVariousLists();
       testDirectory();
       testDirectorySync();
       testWriteStringUtf8();
       testWriteStringUtf8Sync();
       testRename();
       testRenameSync();
       testLastModified();
+      asyncEnd();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }