Fix race condition in tests/standalone/io/file_test

dart/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 116 matching lines @@
                 file2.deleteSync();
                 Expect.isFalse(file2.existsSync());
                 asyncTestDone("testReadWriteStream");
               });
           });
       });
   }
 
   // Test for file stream buffered handling of large files.
   static void testReadWriteStreamLargeFile() {
-    asyncTestStarted();
-
     // Create the test data - arbitrary binary data.
     List<int> buffer = new List<int>(100000);
     for (var i = 0; i < buffer.length; ++i) {
       buffer[i] = i % 256;
     }
     String filename =
         tempDirectory.path + "/out_read_write_stream_large_file";
     File file = new File(filename);
     IOSink output = file.openWrite();
     output.add(buffer);
     output.add(buffer);
     output.flush().then((_) => output.close());
+
+    asyncTestStarted();
     output.done.then((_) {
       Stream input = file.openRead();
       int position = 0;
       final int expectedLength = 200000;
+
       // Start an independent asynchronous check on the length.
-      asyncTestStarted();
-      file.length().then((len) {
-        Expect.equals(expectedLength, len);
-        asyncTestDone('testReadWriteStreamLargeFile: length check');
-      });
+      Future lengthTest() {
+        asyncTestStarted();
+        return file.length().then((len) {
+          Expect.equals(expectedLength, len);
+          asyncTestDone('testReadWriteStreamLargeFile: length check');
+        });
+      }
 
       // Immediate read should read 0 bytes.
-      input.listen(
-        (d) {
-          for (int i = 0; i < d.length; ++i) {
-            Expect.equals(buffer[(i + position) % buffer.length], d[i]);
-          }
-          position += d.length;
-        },
-        onError: (error, trace) {
-          print('Error on input in testReadWriteStreamLargeFile');
-          print('with error $error');
-          if (trace != null) print("StackTrace: $trace");
-          throw error;
-        },
-        onDone: () {
-          Expect.equals(expectedLength, position);
-          testPipe(file, buffer)
-              .then((_) => file.delete())

[kustermann, 2015/02/11 13:38:23]

This `file.delete()` was racing with `file.length()` above I think.

-              .then((_) {
-                  asyncTestDone('testReadWriteStreamLargeFile: main test');
-              })
-              .catchError((e, trace) {
-                print('Exception while deleting ReadWriteStreamLargeFile file');
-                print('Exception $e');
-                if (trace != null) print("StackTrace: $trace");
-              });
-        });
+      Future contentTest() {
+        asyncTestStarted();
+        var completer = new Completer();
+        input.listen(
+          (data) {
+            for (int i = 0; i < data.length; ++i) {
+              Expect.equals(buffer[(i + position) % buffer.length], data[i]);
+            }
+            position += data.length;
+          },
+          onError: (error, trace) {
+            print('Error on input in testReadWriteStreamLargeFile');
+            print('with error $error');
+            if (trace != null) print("StackTrace: $trace");
+            throw error;
+          },
+          onDone: () {
+            Expect.equals(expectedLength, position);
+            testPipe(file, buffer).then((_) {
+              asyncTestDone('testReadWriteStreamLargeFile: main test');
+            }).catchError((error, trace) {
+              print('Exception while deleting ReadWriteStreamLargeFile file');
+              print('Exception $error');
+              if (trace != null) print("StackTrace: $trace");
+              throw error;
+            }).whenComplete(completer.complete);
+          });
+        return completer.future;
+      }
+
+      return Future.forEach([lengthTest, contentTest], (test) => test());
+    }).whenComplete(file.delete).whenComplete(() {
+      asyncTestDone('testReadWriteStreamLargeFile finished');
     });
   }
 
   static Future testPipe(File file, buffer) {
     String outputFilename = '${file.path}_copy';
     File outputFile = new File(outputFilename);
     var input = file.openRead();
     var output = outputFile.openWrite();
     Completer done = new Completer();
     input.pipe(output).then((_) {
@@ skipping 1138 matching lines @@
       testLastModified();
       testDoubleAsyncOperation();
       asyncEnd();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }