Big merge from experimental to bleeding edge.

tests/standalone/io/file_test.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 file I/O.
 
-import "dart:io";
-import "dart:isolate";
+import 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
 
 class MyListOfOneElement implements List {
   int _value;
   MyListOfOneElement(this._value);
   int get length => 1;
   operator [](int index) => _value;
 }
 
 class FileTest {
   static Directory tempDirectory;
@@ skipping 21 matching lines @@
   }
 
   // Test for file read functionality.
   static void testReadStream() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
     Expect.isTrue('$file'.contains(file.name));
     InputStream input = file.openInputStream();
     input.onData = () {
-      List<int> buffer = new List<int>(42);
+      List<int> buffer = new List<int>.fixedLength(42);
       int bytesRead = input.readInto(buffer, 0, 12);
       Expect.equals(12, bytesRead);
       bytesRead = input.readInto(buffer, 12, 30);
       input.close();
       Expect.equals(30, bytesRead);
       Expect.equals(47, buffer[0]);  // represents '/' in the file.
       Expect.equals(47, buffer[1]);  // represents '/' in the file.
       Expect.equals(32, buffer[2]);  // represents ' ' in the file.
       Expect.equals(67, buffer[3]);  // represents 'C' in the file.
       Expect.equals(111, buffer[4]);  // represents 'o' in the file.
@@ skipping 15 matching lines @@
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     File file;
     InputStream input;
     int bytesRead;
 
     // Test reading all using readInto.
     var file1 = new File(inFilename);
     var input1 = file1.openInputStream();
     List<int> buffer1;
     input1.onData = () {
-      buffer1 = new List<int>(42);
+      buffer1 = new List<int>.fixedLength(42);
       bytesRead = input1.readInto(buffer1, 0, 42);
       Expect.equals(42, bytesRead);
     };
     input1.onError = (e) { throw e; };
     input1.onClosed = () {
       Expect.isTrue(input1.closed);
 
       // Test reading all using readInto and read.
       var file2 = new File(inFilename);
       var input2 = file2.openInputStream();
@@ skipping 35 matching lines @@
             String outFilename =
                 tempDirectory.path.concat("/out_read_write_stream");
             file = new File(outFilename);
             OutputStream output = file.openOutputStream();
             bool writeDone = output.writeFrom(buffer1, 0, 42);
             Expect.equals(false, writeDone);
             output.onNoPendingWrites = () {
               output.close();
               output.onClosed = () {
                 // Now read the contents of the file just written.
-                List<int> buffer2 = new List<int>(42);
+                List<int> buffer2 = new List<int>.fixedLength(42);
                 var file6 = new File(outFilename);
                 var input6 = file6.openInputStream();
                 input6.onData = () {
                   bytesRead = input6.readInto(buffer2, 0, 42);
                   Expect.equals(42, bytesRead);
                   // Now compare the two buffers to check if they are identical.
                   for (int i = 0; i < buffer1.length; i++) {
                     Expect.equals(buffer1[i],  buffer2[i]);
                   }
                 };
@@ skipping 10 matching lines @@
         };
       };
     };
   }
 
   // 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);
+    List<int> buffer = new List<int>.fixedLength(100000);
     for (var i = 0; i < buffer.length; ++i) {
       buffer[i] = i % 256;
     }
     String filename =
         tempDirectory.path.concat("/out_read_write_stream_large_file");
     File file = new File(filename);
     OutputStream output = file.openOutputStream();
     // Test a write immediately after the output stream is created.
     output.writeFrom(buffer, 0, 20000);
 
@@ skipping 11 matching lines @@
       InputStream input = file.openInputStream();
       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');
       });
 
-      List<int> inputBuffer = new List<int>(expectedLength + 100000);
+      List<int> inputBuffer =
+          new List<int>.fixedLength(expectedLength + 100000);
       // Immediate read should read 0 bytes.
       Expect.equals(0, input.available());
       Expect.equals(false, input.closed);
       int bytesRead = input.readInto(inputBuffer);
       Expect.equals(0, bytesRead);
       Expect.equals(0, input.available());
       Expect.isFalse(input.closed);
       input.onError = (e) {
         print('Error handler called on input in testReadWriteStreamLargeFile');
         print('with error $e');
@@ skipping 18 matching lines @@
         Expect.isTrue(input.closed);
         input.close();  // This should be safe to call.
 
         Expect.equals(expectedLength, position);
         for (int i = 0; i < position; ++i) {
           Expect.equals(buffer[i % buffer.length], inputBuffer[i]);
         }
 
         Future testPipeDone = testPipe(file, buffer);
 
-        Future futureDeleted = testPipeDone.chain((ignored) => file.delete());
-        futureDeleted.handleException((e) {
+        Future futureDeleted = testPipeDone.then((ignored) => file.delete());
+        futureDeleted.then((ignored) {
+            asyncTestDone('testReadWriteStreamLargeFile: main test');
+        }).catchError((e) {
           print('Exception while deleting ReadWriteStreamLargeFile file');
           print('Exception $e');
-          return false;  // Throw exception further.
-        });
-        futureDeleted.then((ignored) {
-            asyncTestDone('testReadWriteStreamLargeFile: main test');
         });
       };
       // Try a read again after handlers are set.
       bytesRead = input.readInto(inputBuffer);
       Expect.equals(0, bytesRead);
       Expect.equals(0, input.available());
       Expect.isFalse(input.closed);
     };
   }
 
@@ skipping 23 matching lines @@
     };
     return done.future;
   }
 
   static void testRead() {
     ReceivePort port = new ReceivePort();
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
     file.open(FileMode.READ).then((RandomAccessFile file) {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       file.readList(buffer, 0, 5).then((bytes_read) {
         Expect.equals(5, bytes_read);
         file.readList(buffer, 5, 5).then((bytes_read) {
           Expect.equals(5, bytes_read);
           Expect.equals(47, buffer[0]);  // represents '/' in the file.
           Expect.equals(47, buffer[1]);  // represents '/' in the file.
           Expect.equals(32, buffer[2]);  // represents ' ' in the file.
           Expect.equals(67, buffer[3]);  // represents 'C' in the file.
           Expect.equals(111, buffer[4]);  // represents 'o' in the file.
           Expect.equals(112, buffer[5]);  // represents 'p' in the file.
           Expect.equals(121, buffer[6]);  // represents 'y' in the file.
           Expect.equals(114, buffer[7]);  // represents 'r' in the file.
           Expect.equals(105, buffer[8]);  // represents 'i' in the file.
           Expect.equals(103, buffer[9]);  // represents 'g' in the file.
           file.close().then((ignore) => port.close());
         });
       });
     });
   }
 
   static void testReadSync() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     RandomAccessFile file = (new File(filename)).openSync();
-    List<int> buffer = new List<int>(42);
+    List<int> buffer = new List<int>.fixedLength(42);
     int bytes_read = 0;
     bytes_read = file.readListSync(buffer, 0, 12);
     Expect.equals(12, bytes_read);
     bytes_read = file.readListSync(buffer, 12, 30);
     Expect.equals(30, bytes_read);
     Expect.equals(47, buffer[0]);  // represents '/' in the file.
     Expect.equals(47, buffer[1]);  // represents '/' in the file.
     Expect.equals(32, buffer[2]);  // represents ' ' in the file.
     Expect.equals(67, buffer[3]);  // represents 'C' in the file.
     Expect.equals(111, buffer[4]);  // represents 'o' in the file.
     Expect.equals(112, buffer[5]);  // represents 'p' in the file.
     Expect.equals(121, buffer[6]);  // represents 'y' in the file.
     Expect.equals(114, buffer[7]);  // represents 'r' in the file.
     Expect.equals(105, buffer[8]);  // represents 'i' in the file.
     Expect.equals(103, buffer[9]);  // represents 'g' in the file.
     Expect.equals(104, buffer[10]);  // represents 'h' in the file.
     Expect.equals(116, buffer[11]);  // represents 't' in the file.
   }
 
   // Test for file read and write functionality.
   static void testReadWrite() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     final File file = new File(inFilename);
     file.open(FileMode.READ).then((openedFile) {
-      List<int> buffer1 = new List<int>(42);
+      List<int> buffer1 = new List<int>.fixedLength(42);
       openedFile.readList(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.concat("/out_read_write");
           final File file2 = new File(outFilename);
           file2.create().then((ignore) {
             file2.fullPath().then((s) {
               Expect.isTrue(new File(s).existsSync());
               if (s[0] != '/' && s[0] != '\\' && s[1] != ':') {
                 Expect.fail("Not a full path");
               }
               file2.open(FileMode.WRITE).then((openedFile2) {
                 openedFile2.writeList(buffer1, 0, bytes_read).then((ignore) {
                   openedFile2.close().then((ignore) {
-                    List<int> buffer2 = new List<int>(bytes_read);
+                    List<int> buffer2 = new List<int>.fixedLength(bytes_read);
                     final File file3 = new File(outFilename);
                     file3.open(FileMode.READ).then((openedFile3) {
                       openedFile3.readList(buffer2, 0, 42).then((bytes_read) {
                         Expect.equals(42, bytes_read);
                         openedFile3.close().then((ignore) {
                           // 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]);
@@ skipping 104 matching lines @@
       };
     };
     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);
+    List<int> buffer1 = new List<int>.fixedLength(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 outFilename = tempDirectory.path.concat("/out_read_write_sync");
     File outFile = new File(outFilename);
     outFile.createSync();
     String path = outFile.fullPathSync();
     if (path[0] != '/' && path[0] != '\\' && path[1] != ':') {
       Expect.fail("Not a full path");
     }
     Expect.isTrue(new File(path).existsSync());
     RandomAccessFile openedFile = outFile.openSync(FileMode.WRITE);
     openedFile.writeListSync(buffer1, 0, bytes_read);
     openedFile.closeSync();
     // Now read the contents of the file just written.
-    List<int> buffer2 = new List<int>(bytes_read);
+    List<int> buffer2 = new List<int>.fixedLength(bytes_read);
     openedFile = (new File(outFilename)).openSync();
     bytes_read = openedFile.readListSync(buffer2, 0, 42);
     Expect.equals(42, bytes_read);
     openedFile.closeSync();
     // 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.
@@ skipping 47 matching lines @@
         openedFile.writeList(new MyListOfOneElement(262), 0, 1);
         x = 12345678901234567890123456789012345678901234567890;
         y = 12345678901234567890123456789012345678901234568153;
         openedFile.writeList([y - x], 0, 1).then((ignore) {
           openedFile.close().then((ignore) {
             // Check the written bytes.
             final File file2 = new File(fileName);
             var openedFile2 = file2.openSync();
             var length = openedFile2.lengthSync();
             Expect.equals(8, length);
-            List data = new List(length);
+            List data = new List.fixedLength(length);
             openedFile2.readListSync(data, 0, length);
             for (var i = 0; i < data.length; i++) {
               Expect.equals(i, data[i]);
             }
             openedFile2.closeSync();
             file2.deleteSync();
             asyncTestDone("testWriteVariousLists");
           });
         });
       });
     });
   }
 
   static void testDirectory() {
     asyncTestStarted();
 
     // Port to verify that the test completes.
     var port = new ReceivePort();
     port.receive((message, replyTo) {
       port.close();
       Expect.equals(1, message);
       asyncTestDone("testDirectory");
     });
 
     var tempDir = tempDirectory.path;
     var file = new File("${tempDir}/testDirectory");
     var errors = 0;
     var dirFuture = file.directory();
-    dirFuture.then((d) => Expect.fail("non-existing file"));
-    dirFuture.handleException((e) {
+    dirFuture.then((d) => Expect.fail("non-existing file"))
+    .catchError((e) {
       file.create().then((ignore) {
         file.directory().then((Directory d) {
           d.exists().then((exists) {
             Expect.isTrue(exists);
             Expect.isTrue(d.path.endsWith(tempDir));
             file.delete().then((ignore) {
               var fileDir = new File(".");
               var dirFuture2 = fileDir.directory();
-              dirFuture2.then((d) => Expect.fail("non-existing file"));
-              dirFuture2.handleException((e) {
+              dirFuture2.then((d) => Expect.fail("non-existing file"))
+              .catchError((e) {
                 var fileDir = new File(tempDir);
                 var dirFuture3 = fileDir.directory();
-                dirFuture3.then((d) => Expect.fail("non-existing file"));
-                dirFuture3.handleException((e) {
+                dirFuture3.then((d) => Expect.fail("non-existing file"))
+                .catchError((e) {
                   port.toSendPort().send(1);
-                  return true;
                 });
-                return true;
               });
             });
           });
         });
       });
-      return true;
     });
   }
 
   static void testDirectorySync() {
     var tempDir = tempDirectory.path;
     var file = new File("${tempDir}/testDirectorySync");
     // Non-existing file should throw exception.
     Expect.throws(file.directorySync, (e) { return e is FileIOException; });
     file.createSync();
     // Check that the path of the returned directory is the temp directory.
@@ skipping 32 matching lines @@
     openedFile.closeSync();
   }
 
   // Test for file position functionality.
   static void testPosition() {
     var port = new ReceivePort();
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     input.position().then((position) {
       Expect.equals(0, position);
-      List<int> buffer = new List<int>(100);
+      List<int> buffer = new List<int>.fixedLength(100);
       input.readList(buffer, 0, 12).then((bytes_read) {
         input.position().then((position) {
           Expect.equals(12, position);
           input.readList(buffer, 12, 6).then((bytes_read) {
             input.position().then((position) {
               Expect.equals(18, position);
               input.setPosition(8).then((ignore) {
                 input.position().then((position) {
                   Expect.equals(8, position);
                   input.close().then((ignore) => port.close());
                 });
               });
             });
           });
         });
       });
     });
   }
 
   static void testPositionSync() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     Expect.equals(0, input.positionSync());
-    List<int> buffer = new List<int>(100);
+    List<int> buffer = new List<int>.fixedLength(100);
     input.readListSync(buffer, 0, 12);
     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();
   }
 
   static void testTruncate() {
@@ skipping 66 matching lines @@
       openedFile.writeStringSync("Test");
     } on FileIOException catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(100);
+      List<int> buffer = new List<int>.fixedLength(100);
       openedFile.readListSync(buffer, 0, 10);
     } on FileIOException catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(100);
+      List<int> buffer = new List<int>.fixedLength(100);
       openedFile.writeListSync(buffer, 0, 10);
     } on FileIOException catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
@@ skipping 24 matching lines @@
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     input.deleteSync();
   }
 
   // Tests stream exception handling after file was closed.
   static void testCloseExceptionStream() {
     asyncTestStarted();
-    List<int> buffer = new List<int>(42);
+    List<int> buffer = new List<int>.fixedLength(42);
     File file =
         new File(tempDirectory.path.concat("/out_close_exception_stream"));
     file.createSync();
     InputStream input = file.openInputStream();
     input.onClosed = () {
       Expect.isTrue(input.closed);
       Expect.equals(0, input.readInto(buffer, 0, 12));
       OutputStream output = file.openOutputStream();
       output.close();
       Expect.throws(() => output.writeFrom(buffer, 0, 12));
       output.onClosed = () {
         file.deleteSync();
         asyncTestDone("testCloseExceptionStream");
       };
     };
   }
 
   // Tests buffer out of bounds exception.
   static void testBufferOutOfBoundsException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File file =
         new File(tempDirectory.path.concat("/out_buffer_out_of_bounds"));
     RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.readListSync(buffer, 0, 12);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.readListSync(buffer, 6, 6);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.readListSync(buffer, -1, 1);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.readListSync(buffer, 0, -1);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.writeListSync(buffer, 0, 12);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.writeListSync(buffer, 6, 6);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.writeListSync(buffer, -1, 1);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      List<int> buffer = new List<int>(10);
+      List<int> buffer = new List<int>.fixedLength(10);
       openedFile.writeListSync(buffer, 0, -1);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testOpenDirectoryAsFile() {
     var f = new File('.');
     var future = f.open(FileMode.READ);
-    future.then((r) => Expect.fail('Directory opened as file'));
-    future.handleException((e) => true);
+    future.then((r) => Expect.fail('Directory opened as file'))
+          .catchError((e) {});
   }
 
   static void testOpenDirectoryAsFileSync() {
     var f = new File('.');
     try {
       f.openSync();
       Expect.fail("Expected exception opening directory as file");
     } catch (e) {
       Expect.isTrue(e is FileIOException);
     }
@@ skipping 68 matching lines @@
         Expect.equals(6, text.length);
         var expected = [955, 120, 46, 32, 120, 10];
         Expect.listEquals(expected, text.charCodes);
         f.readAsString(Encoding.ISO_8859_1).then((text) {
           Expect.equals(7, text.length);
           var expected = [206, 187, 120, 46, 32, 120, 10];
           Expect.listEquals(expected, text.charCodes);
           var readAsStringFuture = f.readAsString(Encoding.ASCII);
           readAsStringFuture.then((text) {
             Expect.fail("Non-ascii char should cause error");
-          });
-          readAsStringFuture.handleException((e) {
+          }).catchError((e) {
             port.toSendPort().send(1);
-            return true;
           });
         });
       });
     });
   }
 
   static void testReadAsTextEmptyFile() {
     var port = new ReceivePort();
     port.receive((result, replyTo) {
       port.close();
@@ skipping 63 matching lines @@
     var port = new ReceivePort();
     port.receive((message, _) {
       port.close();
       Expect.equals(1, message);
     });
     var f = new File('.');
     Expect.throws(f.readAsBytesSync, (e) => e is FileIOException);
     Expect.throws(f.readAsStringSync, (e) => e is FileIOException);
     Expect.throws(f.readAsLinesSync, (e) => e is FileIOException);
     var readAsBytesFuture = f.readAsBytes();
-    readAsBytesFuture.then((bytes) => Expect.fail("no bytes expected"));
-    readAsBytesFuture.handleException((e) {
+    readAsBytesFuture.then((bytes) => Expect.fail("no bytes expected"))
+    .catchError((e) {
       var readAsStringFuture = f.readAsString(Encoding.UTF_8);
-      readAsStringFuture.then((text) => Expect.fail("no text expected"));
-      readAsStringFuture.handleException((e) {
+      readAsStringFuture.then((text) => Expect.fail("no text expected"))
+      .catchError((e) {
         var readAsLinesFuture = f.readAsLines(Encoding.UTF_8);
-        readAsLinesFuture.then((lines) => Expect.fail("no lines expected"));
-        readAsLinesFuture.handleException((e) {
+        readAsLinesFuture.then((lines) => Expect.fail("no lines expected"))
+        .catchError((e) {
           port.toSendPort().send(1);
-          return true;
         });
-        return true;
       });
-      return true;
     });
   }
 
   static void testLastModified() {
     var port = new ReceivePort();
     new File(new Options().executable).lastModified().then((modified) {
       Expect.isTrue(modified is Date);
       Expect.isTrue(modified < new Date.now());
       port.close();
     });
@@ skipping 161 matching lines @@
       testDirectorySync();
       testWriteStringUtf8();
       testWriteStringUtf8Sync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }