Make it an error to call close twice on a file using the async API.

tests/standalone/src/io/FileErrorTest.dart

 // 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 error handling in file I/O.
 
 #import("dart:io");
 #import("dart:isolate");
 
 Directory tempDir() {
@@ skipping 284 matching lines @@
   };
 }
 
 bool checkWriteReadOnlyFileException(e) {
   Expect.isTrue(e is FileIOException);
   Expect.isTrue(e.osError != null);
   Expect.isTrue(e.osError.errorCode != OSError.noErrorCode);
   return true;
 }
 
-testWriteByteToReadOnlyFile() {
+
+// Create a test file in a temporary directory. Setup a port to signal
+// when the temporary directory should be deleted. Pass the file and
+// the port to the callback argument.
+createTestFile(callback) {
   Directory temp = tempDir();
   ReceivePort p = new ReceivePort();
   p.receive((x, y) {
     p.close();
     temp.deleteRecursivelySync();
   });
 
   var file = new File("${temp.path}/test_file");
   file.createSync();
-  var openedFile = file.openSync(FileMode.READ);
+  callback(file, p.toSendPort());
+}
 
-  // Writing to read only file should throw an exception.
-  Expect.throws(() => openedFile.writeByteSync(0),
-                (e) => checkWriteReadOnlyFileException(e));
 
-  openedFile.writeByte(0);
-  openedFile.onError = (e) {
-    checkWriteReadOnlyFileException(e);
-    openedFile.close(() => p.toSendPort().send(null));
-  };
+testWriteByteToReadOnlyFile() {
+  createTestFile((file, port) {
+      var openedFile = file.openSync(FileMode.READ);
+
+      // Writing to read only file should throw an exception.
+      Expect.throws(() => openedFile.writeByteSync(0),
+                    (e) => checkWriteReadOnlyFileException(e));
+
+      openedFile.writeByte(0);
+      openedFile.onError = (e) {
+        checkWriteReadOnlyFileException(e);
+        openedFile.close(() => port.send(null));
+    };
+  });
 }
 
 testWriteListToReadOnlyFile() {
-  Directory temp = tempDir();
-  ReceivePort p = new ReceivePort();
-  p.receive((x, y) {
-    p.close();
-    temp.deleteRecursivelySync();
+  createTestFile((file, port) {
+    var openedFile = file.openSync(FileMode.READ);
+
+    List data = [0, 1, 2, 3];
+    // Writing to read only file should throw an exception.
+    Expect.throws(() => openedFile.writeListSync(data, 0, data.length),
+                  (e) => checkWriteReadOnlyFileException(e));
+
+    openedFile.writeList(data, 0, data.length);
+    openedFile.onError = (e) {
+      checkWriteReadOnlyFileException(e);
+      openedFile.close(() => port.send(null));
+    };
   });
-
-  var file = new File("${temp.path}/test_file");
-  file.createSync();
-  var openedFile = file.openSync(FileMode.READ);
-
-  List data = [0, 1, 2, 3];
-  // Writing to read only file should throw an exception.
-  Expect.throws(() => openedFile.writeListSync(data, 0, data.length),
-                (e) => checkWriteReadOnlyFileException(e));
-
-  openedFile.writeList(data, 0, data.length);
-  openedFile.onError = (e) {
-    checkWriteReadOnlyFileException(e);
-    openedFile.close(() => p.toSendPort().send(null));
-  };
 }
 
 testTruncateReadOnlyFile() {
-  Directory temp = tempDir();
-  ReceivePort p = new ReceivePort();
-  p.receive((x, y) {
-    p.close();
-    temp.deleteRecursivelySync();
+  createTestFile((file, port) {
+    var openedFile = file.openSync(FileMode.WRITE);
+    openedFile.writeByteSync(0);
+    openedFile.closeSync();
+    openedFile = file.openSync(FileMode.READ);
+
+    // Truncating read only file should throw an exception.
+    Expect.throws(() => openedFile.truncateSync(0),
+                  (e) => checkWriteReadOnlyFileException(e));
+
+    openedFile.truncate(0, () => Expect.fail("Unreachable code"));
+    openedFile.onError = (e) {
+      checkWriteReadOnlyFileException(e);
+      openedFile.close(() => port.send(null));
+    };
   });
-
-  var file = new File("${temp.path}/test_file");
-  file.createSync();
-  var openedFile = file.openSync(FileMode.WRITE);
-  openedFile.writeByteSync(0);
-  openedFile.closeSync();
-  openedFile = file.openSync(FileMode.READ);
-
-  // Truncating read only file should throw an exception.
-  Expect.throws(() => openedFile.truncateSync(0),
-                (e) => checkWriteReadOnlyFileException(e));
-
-  openedFile.truncate(0, () => Expect.fail("Unreachable code"));
-  openedFile.onError = (e) {
-    checkWriteReadOnlyFileException(e);
-    openedFile.close(() => p.toSendPort().send(null));
-  };
 }
 
 bool checkFileClosedException(e) {
   Expect.isTrue(e is FileIOException);
   Expect.isTrue(e.toString().indexOf("File closed") != -1);
   Expect.isTrue(e.osError == null);
   return true;
 }
 
 testOperateOnClosedFile() {
-  Directory temp = tempDir();
-  ReceivePort p = new ReceivePort();
-  p.receive((x, y) {
-    p.close();
-    temp.deleteRecursivelySync();
+  createTestFile((file, port) {
+    var openedFile = file.openSync(FileMode.READ);
+    openedFile.closeSync();
+
+    List data = [0, 1, 2, 3];
+    Expect.throws(() => openedFile.readByteSync(),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.writeByteSync(0),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.writeListSync(data, 0, data.length),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.readListSync(data, 0, data.length),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.writeStringSync("Hello"),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.positionSync(),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.setPositionSync(0),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.truncateSync(0),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.lengthSync(),
+                  (e) => checkFileClosedException(e));
+    Expect.throws(() => openedFile.flushSync(),
+                  (e) => checkFileClosedException(e));
+
+    var errorCount = 0;
+    openedFile.readByte((byte) => Expect.fail("Unreachable code"));
+    errorCount++;
+    openedFile.writeByte(0);
+    errorCount++;
+    openedFile.readList(
+        data, 0, data.length, (bytesRead) => Expect.fail("Unreachable code"));
+    errorCount++;
+    openedFile.writeList(data, 0, data.length);
+    errorCount++;
+    openedFile.writeString("Hello");
+    errorCount++;
+    openedFile.position((position) => Expect.fail("Unreachable code"));
+    errorCount++;
+    openedFile.setPosition(0, () => Expect.fail("Unreachable code"));
+    errorCount++;
+    openedFile.truncate(0, () => Expect.fail("Unreachable code"));
+    errorCount++;
+    openedFile.length((length) => Expect.fail("Unreachable code"));
+    errorCount++;
+    openedFile.flush(() => Expect.fail("Unreachable code"));
+    errorCount++;
+
+    openedFile.onError = (e) {
+      checkFileClosedException(e);
+      if (--errorCount == 0) {
+        port.send(null);
+      }
+    };
   });
+}
 
-  var file = new File("${temp.path}/test_file");
-  file.createSync();
-  var openedFile = file.openSync(FileMode.READ);
-  openedFile.closeSync();
-
-  List data = [0, 1, 2, 3];
-  Expect.throws(() => openedFile.readByteSync(),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.writeByteSync(0),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.writeListSync(data, 0, data.length),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.readListSync(data, 0, data.length),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.writeStringSync("Hello"),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.positionSync(),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.setPositionSync(0),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.truncateSync(0),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.lengthSync(),
-                (e) => checkFileClosedException(e));
-  Expect.throws(() => openedFile.flushSync(),
-                (e) => checkFileClosedException(e));
-
-  var errorCount = 0;
-  openedFile.readByte((byte) => Expect.fail("Unreachable code"));
-  errorCount++;
-  openedFile.writeByte(0);
-  errorCount++;
-  openedFile.readList(
-      data, 0, data.length, (bytesRead) => Expect.fail("Unreachable code"));
-  errorCount++;
-  openedFile.writeList(data, 0, data.length);
-  errorCount++;
-  openedFile.writeString("Hello");
-  errorCount++;
-  openedFile.position((position) => Expect.fail("Unreachable code"));
-  errorCount++;
-  openedFile.setPosition(0, () => Expect.fail("Unreachable code"));
-  errorCount++;
-  openedFile.truncate(0, () => Expect.fail("Unreachable code"));
-  errorCount++;
-  openedFile.length((length) => Expect.fail("Unreachable code"));
-  errorCount++;
-  openedFile.flush(() => Expect.fail("Unreachable code"));
-  errorCount++;
-
-  openedFile.onError = (e) {
-    checkFileClosedException(e);
-    if (--errorCount == 0) {
-      p.toSendPort().send(null);
-    }
-  };
+testRepeatedlyCloseFile() {
+  createTestFile((file, port) {
+    var openedFile = file.openSync();
+    openedFile.close(() {
+      openedFile.onError = (e) {
+        Expect.isTrue(e is FileIOException);
+        port.send(null);
+      };
+      openedFile.close(() => null);
+    });
+  });
 }
 
 main() {
   testOpenNonExistent();
   testDeleteNonExistent();
   testLengthNonExistent();
   testCreateInNonExistentDirectory();
   testFullPathOnNonExistentDirectory();
   testDirectoryInNonExistentDirectory();
   testReadAsBytesNonExistent();
   testReadAsTextNonExistent();
   testReadAsLinesNonExistent();
   testWriteByteToReadOnlyFile();
   testWriteListToReadOnlyFile();
   testTruncateReadOnlyFile();
   testOperateOnClosedFile();
+  testRepeatedlyCloseFile();
 }