Format all tests.

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.
 
 // OtherResources=empty_file
 // OtherResources=file_test.txt
 // OtherResources=fixed_length_file
 // OtherResources=read_as_text.dat
 // OtherResources=readline_test1.dat
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:collection';
 import 'dart:io';
 
 import "package:async_helper/async_helper.dart";
 import "package:expect/expect.dart";
 import "package:path/path.dart";
 
-class MyListOfOneElement
-    extends Object with ListMixin<int> implements List<int> {
+class MyListOfOneElement extends Object
+    with ListMixin<int>
+    implements List<int> {
   int _value;
   MyListOfOneElement(this._value);
   int get length => 1;
   operator [](int index) => _value;
-  void set length(int index) { throw "Unsupported"; }
+  void set length(int index) {
+    throw "Unsupported";
+  }
+
   operator []=(int index, value) {
     if (index != 0) {
       throw "Unsupported";
     } else {
       _value = value;
     }
   }
 }
 
 class FileTest {
   static Directory tempDirectory;
   static int numLiveAsyncTests = 0;
 
   static void asyncTestStarted() {
     asyncStart();
     ++numLiveAsyncTests;
   }
+
   static void asyncTestDone(String name) {
     asyncEnd();
     --numLiveAsyncTests;
     if (numLiveAsyncTests == 0) {
       deleteTempDirectory();
     }
   }
 
   static void createTempDirectory(Function doNext) {
     Directory.systemTemp.createTemp('dart_file').then((temp) {
       tempDirectory = temp;
       doNext();
     });
   }
 
   static void deleteTempDirectory() {
     tempDirectory.deleteSync(recursive: true);
   }
 
   // Test for file read functionality.
   static void testReadStream() {
     // Read a file and check part of it's contents.
     String filename = getFilename("file_test.txt");
     File file = new File(filename);
     Expect.isTrue('$file'.contains(file.path));
     var subscription;
     List<int> buffer = new List<int>();
-    subscription = file.openRead().listen(
-        (d) {
-          buffer.addAll(d);
-          if (buffer.length >= 12) {
-            subscription.cancel();
-            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.
-          }
-        });
+    subscription = file.openRead().listen((d) {
+      buffer.addAll(d);
+      if (buffer.length >= 12) {
+        subscription.cancel();
+        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 testReadWriteStream() {
     asyncTestStarted();
 
     // Read a file.
     String inFilename = getFilename("fixed_length_file");
     File file;
     int bytesRead;
 
     var file1 = new File(inFilename);
     List<int> buffer = new List<int>();
-    file1.openRead().listen(
-      (d) {
-        buffer.addAll(d);
-      },
-      onDone: () {
-        Expect.equals(42, buffer.length);
-        // Write the contents of the file just read into another file.
-        String outFilename =
-            tempDirectory.path + "/out_read_write_stream";
-        var file2 = new File(outFilename);
-        var output = file2.openWrite();
-        output.add(buffer);
-        output.flush().then((_) => output.close());
-        output.done.then((_) {
-          // Now read the contents of the file just written.
-          List<int> buffer2 = new List<int>();
-          new File(outFilename).openRead().listen(
-              (d) {
-                buffer2.addAll(d);
-              },
-              onDone: () {
-                Expect.equals(42, buffer2.length);
-                // Now compare the two buffers to check if they are
-                // identical.
-                for (int i = 0; i < buffer.length; i++) {
-                  Expect.equals(buffer[i],  buffer2[i]);
-                }
-                // Delete the output file.
-                file2.deleteSync();
-                Expect.isFalse(file2.existsSync());
-                asyncTestDone("testReadWriteStream");
-              });
-          });
+    file1.openRead().listen((d) {
+      buffer.addAll(d);
+    }, onDone: () {
+      Expect.equals(42, buffer.length);
+      // Write the contents of the file just read into another file.
+      String outFilename = tempDirectory.path + "/out_read_write_stream";
+      var file2 = new File(outFilename);
+      var output = file2.openWrite();
+      output.add(buffer);
+      output.flush().then((_) => output.close());
+      output.done.then((_) {
+        // Now read the contents of the file just written.
+        List<int> buffer2 = new List<int>();
+        new File(outFilename).openRead().listen((d) {
+          buffer2.addAll(d);
+        }, onDone: () {
+          Expect.equals(42, buffer2.length);
+          // Now compare the two buffers to check if they are
+          // identical.
+          for (int i = 0; i < buffer.length; i++) {
+            Expect.equals(buffer[i], buffer2[i]);
+          }
+          // Delete the output file.
+          file2.deleteSync();
+          Expect.isFalse(file2.existsSync());
+          asyncTestDone("testReadWriteStream");
+        });
       });
+    });
   }
 
   // Test for file stream buffered handling of large files.
   static void testReadWriteStreamLargeFile() {
     // 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";
+    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;
+    output.done
+        .then((_) {
+          Stream input = file.openRead();
+          int position = 0;
+          final int expectedLength = 200000;
 
-      // Start an independent asynchronous check on the length.
-      Future lengthTest() {
-        asyncTestStarted();
-        return file.length().then((len) {
-          Expect.equals(expectedLength, len);
-          asyncTestDone('testReadWriteStreamLargeFile: length check');
-        });
-      }
+          // Start an independent asynchronous check on the length.
+          Future lengthTest() {
+            asyncTestStarted();
+            return file.length().then((len) {
+              Expect.equals(expectedLength, len);
+              asyncTestDone('testReadWriteStreamLargeFile: length check');
+            });
+          }
 
-      // Immediate read should read 0 bytes.
-      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');
+          // Immediate read should read 0 bytes.
+          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;
-            }).whenComplete(completer.complete);
-          });
-        return completer.future;
-      }
+            }, 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');
-    });
+          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((_) {
       var copy = outputFile.openRead();
       int position = 0;
-      copy.listen(
-          (d) {
-            for (int i = 0; i < d.length; i++) {
-              Expect.equals(buffer[(position + i) % buffer.length], d[i]);
-            }
-            position += d.length;
-          },
-          onDone: () {
-            Expect.equals(2 * buffer.length, position);
-            outputFile.delete().then((ignore) { done.complete(); });
-          });
+      copy.listen((d) {
+        for (int i = 0; i < d.length; i++) {
+          Expect.equals(buffer[(position + i) % buffer.length], d[i]);
+        }
+        position += d.length;
+      }, onDone: () {
+        Expect.equals(2 * buffer.length, position);
+        outputFile.delete().then((ignore) {
+          done.complete();
+        });
       });
+    });
     return done.future;
   }
 
   static void testRead() {
     asyncStart();
     // Read a file and check part of it's contents.
     String filename = getFilename("file_test.txt");
     File file = new File(filename);
     file.open(mode: READ).then((RandomAccessFile file) {
       List<int> buffer = new List<int>(10);
       file.readInto(buffer, 0, 5).then((bytes_read) {
         Expect.equals(5, bytes_read);
         file.readInto(buffer, 5, 10).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.
+          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) => asyncEnd());
         });
       });
     });
   }
 
   static void testReadSync() {
     // Read a file and check part of it's contents.
     String filename = getFilename("file_test.txt");
     RandomAccessFile raf = (new File(filename)).openSync();
     List<int> buffer = new List<int>(42);
     int bytes_read = 0;
     bytes_read = raf.readIntoSync(buffer, 0, 12);
     Expect.equals(12, bytes_read);
     bytes_read = raf.readIntoSync(buffer, 12, 42);
     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.
+    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.
     raf.closeSync();
 
     filename = getFilename("fixed_length_file");
     File file = new File(filename);
     int len = file.lengthSync();
     int read(int length) {
       var f = file.openSync();
       int res = f.readSync(length).length;
       f.closeSync();
       return res;
     }
+
     Expect.equals(0, read(0));
     Expect.equals(1, read(1));
     Expect.equals(len - 1, read(len - 1));
     Expect.equals(len, read(len));
     Expect.equals(len, read(len + 1));
     Expect.equals(len, read(len * 2));
     Expect.equals(len, read(len * 10));
   }
 
   // Test for file read and write functionality.
@@ skipping 22 matching lines @@
                     List<int> buffer2 = new List<int>(bytes_read);
                     final File file3 = new File(outFilename);
                     file3.open(mode: READ).then((openedFile3) {
                       openedFile3.readInto(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]);
+                            Expect.equals(buffer1[i], buffer2[i]);
                           }
                           // Delete the output file.
                           final file4 = file3;
                           file4.delete().then((ignore) {
                             file4.exists().then((exists) {
                               Expect.isFalse(exists);
                               asyncTestDone("testReadWrite");
                             });
                           });
                         });
@@ skipping 21 matching lines @@
     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, 2, buffer.length - 2);
-    Expect.equals(content.length + content.length - 4,
-                  openedFile.lengthSync());
+    Expect.equals(content.length + content.length - 4, openedFile.lengthSync());
     Expect.equals(content + content.substring(2, content.length - 2),
-                  file.readAsStringSync());
+        file.readAsStringSync());
     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();
@@ skipping 43 matching lines @@
     output.close();
     output.done.then((_) {
       RandomAccessFile raf = file.openSync();
       Expect.equals(38, raf.lengthSync());
       raf.close().then((ignore) {
         asyncTestDone("testOutputStreamWriteString");
       });
     });
   }
 
-
   static void testReadWriteSync() {
     // Read a file.
     String inFilename = getFilename("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.readIntoSync(buffer1, 0, 42);
     Expect.equals(42, bytes_read);
     file.closeSync();
@@ skipping 11 matching lines @@
     openedFile.closeSync();
     // Now read the contents of the file just written.
     List<int> buffer2 = new List<int>(bytes_read);
     openedFile = (new File(outFilename)).openSync();
     bytes_read = openedFile.readIntoSync(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]);
+      Expect.equals(buffer1[i], buffer2[i]);
     }
     // Delete the output file.
     outFile.deleteSync();
     Expect.isFalse(outFile.existsSync());
   }
 
   static void testReadWriteNoArgsSync() {
     // Read a file.
     String inFilename = getFilename("fixed_length_file");
     RandomAccessFile file = (new File(inFilename)).openSync();
@@ skipping 17 matching lines @@
     openedFile.closeSync();
     // Now read the contents of the file just written.
     List<int> buffer2 = new List<int>(bytes_read);
     openedFile = (new File(outFilename)).openSync();
     bytes_read = openedFile.readIntoSync(buffer2, 0);
     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]);
+      Expect.equals(buffer1[i], buffer2[i]);
     }
     // Delete the output file.
     outFile.deleteSync();
     Expect.isFalse(outFile.existsSync());
   }
 
   static void testReadEmptyFileSync() {
     String fileName = tempDirectory.path + "/empty_file_sync";
     File file = new File(fileName);
     file.createSync();
@@ skipping 27 matching lines @@
     final File file = new File(fileName);
     file.create().then((ignore) {
       file.open(mode: WRITE).then((RandomAccessFile openedFile) {
         // Write bytes from 0 to 7.
         openedFile.writeFromSync([0], 0, 1);
         openedFile.writeFromSync(const [1], 0, 1);
         openedFile.writeFromSync(new MyListOfOneElement(2), 0, 1);
         var x = 12345678901234567890123456789012345678901234567890;
         var y = 12345678901234567890123456789012345678901234567893;
         openedFile.writeFromSync([y - x], 0, 1);
-        openedFile.writeFromSync([260], 0, 1);  // 260 = 256 + 4 = 0x104.
+        openedFile.writeFromSync([260], 0, 1); // 260 = 256 + 4 = 0x104.
         openedFile.writeFromSync(const [261], 0, 1);
         openedFile.writeFromSync(new MyListOfOneElement(262), 0, 1);
         x = 12345678901234567890123456789012345678901234567890;
         y = 12345678901234567890123456789012345678901234568153;
         openedFile.writeFrom([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();
@@ skipping 31 matching lines @@
       if (tmp != null) {
         tmp.deleteSync(recursive: true);
       }
     }
   }
 
   static void testDirectory() {
     asyncTestStarted();
     var tempDir = tempDirectory.path;
     var file = new File("${tempDir}/testDirectory");
-      file.create().then((ignore) {
-          Directory d = file.parent;
-          d.exists().then((xexists) {
-          Expect.isTrue(xexists);
-          Expect.isTrue(d.path.endsWith(tempDir));
-          file.delete().then((ignore) => asyncTestDone("testDirectory"));
-        });
+    file.create().then((ignore) {
+      Directory d = file.parent;
+      d.exists().then((xexists) {
+        Expect.isTrue(xexists);
+        Expect.isTrue(d.path.endsWith(tempDir));
+        file.delete().then((ignore) => asyncTestDone("testDirectory"));
       });
+    });
   }
 
   static void testDirectorySync() {
     var tempDir = tempDirectory.path;
     var file = new File("${tempDir}/testDirectorySync");
     // Non-existing file still provides the directory.
     Expect.equals("${tempDir}", file.parent.path);
     file.createSync();
     // Check that the path of the returned directory is the temp directory.
     Directory d = file.parent;
@@ skipping 203 matching lines @@
   }
 
   static testWriteFrom() async {
     asyncTestStarted();
     File file = new File(tempDirectory.path + "/out_write_from");
 
     var buffer = const [1, 2, 3];
     var openedFile = await file.open(mode: WRITE);
 
     await openedFile.writeFrom(buffer);
-    var result = []..addAll(buffer);;
+    var result = []..addAll(buffer);
+    ;
 
     write([start, end]) async {
       var returnValue = await openedFile.writeFrom(buffer, start, end);
       Expect.identical(openedFile, returnValue);
       result.addAll(buffer.sublist(start, end));
     }
+
     await write(0, 3);
     await write(0, 2);
     await write(1, 2);
     await write(1, 3);
     await write(2, 3);
     await write(0, 0);
 
     var bytesFromFile = await file.readAsBytes();
     Expect.listEquals(result, bytesFromFile);
 
     await openedFile.close();
 
     asyncTestDone("testWriteFrom");
   }
 
   static void testWriteFromSync() {
     File file = new File(tempDirectory.path + "/out_write_from_sync");
 
     var buffer = const [1, 2, 3];
     var openedFile = file.openSync(mode: WRITE);
 
     openedFile.writeFromSync(buffer);
-    var result = []..addAll(buffer);;
+    var result = []..addAll(buffer);
+    ;
 
     write([start, end]) {
       var returnValue = openedFile.writeFromSync(buffer, start, end);
       result.addAll(buffer.sublist(start, end));
     }
+
     write(0, 3);
     write(0, 2);
     write(1, 2);
     write(1, 3);
     write(2, 3);
 
     var bytesFromFile = file.readAsBytesSync();
     Expect.listEquals(result, bytesFromFile);
 
     openedFile.closeSync();
@@ skipping 87 matching lines @@
     }
     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);
-    File file =
-        new File(tempDirectory.path + "/out_close_exception_stream");
+    File file = new File(tempDirectory.path + "/out_close_exception_stream");
     file.createSync();
     var output = file.openWrite();
     output.close();
-    output.add(buffer);  // Ignored.
+    output.add(buffer); // Ignored.
     output.done.then((_) {
       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 + "/out_buffer_out_of_bounds");
+    File file = new File(tempDirectory.path + "/out_buffer_out_of_bounds");
     RandomAccessFile openedFile = file.openSync(mode: WRITE);
     try {
       List<int> buffer = new List<int>(10);
       openedFile.readIntoSync(buffer, 0, 12);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
@@ skipping 75 matching lines @@
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testOpenDirectoryAsFile() {
     var f = new File('.');
     var future = f.open(mode: READ);
-    future.then((r) => Expect.fail('Directory opened as file'))
-          .catchError((e) {});
+    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 FileSystemException);
     }
@@ skipping 77 matching lines @@
     var text = new File(name).readAsStringSync();
     Expect.isTrue(text.endsWith("42 bytes."));
     Expect.equals(42, text.length);
     name = getFilename("read_as_text.dat");
     text = new File(name).readAsStringSync();
     Expect.equals(6, text.length);
     var expected = [955, 120, 46, 32, 120, 10];
     Expect.listEquals(expected, text.codeUnits);
     // First character is not ASCII. The default ASCII decoder will throw.
     Expect.throws(() => new File(name).readAsStringSync(encoding: ASCII),
-                  (e) => e is FileSystemException);
+        (e) => e is FileSystemException);
     // We can use an ASCII decoder that inserts the replacement character.
     var lenientAscii = const AsciiCodec(allowInvalid: true);
     text = new File(name).readAsStringSync(encoding: lenientAscii);
     // Default replacement character is the Unicode replacement character.
-    expected = [UNICODE_REPLACEMENT_CHARACTER_RUNE,
-                UNICODE_REPLACEMENT_CHARACTER_RUNE,
-                120, 46, 32, 120, 10];
+    expected = [
+      UNICODE_REPLACEMENT_CHARACTER_RUNE,
+      UNICODE_REPLACEMENT_CHARACTER_RUNE,
+      120,
+      46,
+      32,
+      120,
+      10
+    ];
     Expect.listEquals(expected, text.codeUnits);
     text = new File(name).readAsStringSync(encoding: LATIN1);
     expected = [206, 187, 120, 46, 32, 120, 10];
     Expect.equals(7, text.length);
     Expect.listEquals(expected, text.codeUnits);
   }
 
   static void testReadAsTextSyncEmptyFile() {
     var name = getFilename("empty_file");
     var text = new File(name).readAsStringSync();
@@ skipping 18 matching lines @@
     var lines = new File(name).readAsLinesSync();
     Expect.equals(1, lines.length);
     var line = lines[0];
     Expect.isTrue(line.endsWith("42 bytes."));
     Expect.equals(42, line.length);
     name = getFilename("readline_test1.dat");
     lines = new File(name).readAsLinesSync();
     Expect.equals(10, lines.length);
   }
 
-
   static void testReadAsErrors() {
     asyncTestStarted();
     var f = new File('.');
     Expect.throws(f.readAsBytesSync, (e) => e is FileSystemException);
     Expect.throws(f.readAsStringSync, (e) => e is FileSystemException);
     Expect.throws(f.readAsLinesSync, (e) => e is FileSystemException);
     var readAsBytesFuture = f.readAsBytes();
-    readAsBytesFuture.then((bytes) => Expect.fail("no bytes expected"))
-    .catchError((e) {
+    readAsBytesFuture
+        .then((bytes) => Expect.fail("no bytes expected"))
+        .catchError((e) {
       var readAsStringFuture = f.readAsString(encoding: UTF8);
-      readAsStringFuture.then((text) => Expect.fail("no text expected"))
-      .catchError((e) {
+      readAsStringFuture
+          .then((text) => Expect.fail("no text expected"))
+          .catchError((e) {
         var readAsLinesFuture = f.readAsLines(encoding: UTF8);
-        readAsLinesFuture.then((lines) => Expect.fail("no lines expected"))
-        .catchError((e) {
+        readAsLinesFuture
+            .then((lines) => Expect.fail("no lines expected"))
+            .catchError((e) {
           asyncTestDone("testReadAsLines");
         });
       });
     });
   }
 
   static void testLastModified() {
     asyncTestStarted();
     new File(Platform.executable).lastModified().then((modified) {
       Expect.isTrue(modified is DateTime);
@@ skipping 11 matching lines @@
     });
   }
 
   static void testDoubleAsyncOperation() {
     asyncTestStarted();
     var file = new File(Platform.executable).openSync();
     var completer = new Completer();
     int done = 0;
     bool error = false;
     void getLength() {
-      file.length()
-          .catchError((e) { error = true; })
-          .whenComplete(() {
-            if (++done == 2) {
-              asyncTestDone("testDoubleAsyncOperation");
-              Expect.isTrue(error);
-              file.lengthSync();
-              file.closeSync();
-            }
-          });
+      file.length().catchError((e) {
+        error = true;
+      }).whenComplete(() {
+        if (++done == 2) {
+          asyncTestDone("testDoubleAsyncOperation");
+          Expect.isTrue(error);
+          file.lengthSync();
+          file.closeSync();
+        }
+      });
     }
+
     getLength();
     getLength();
     Expect.throws(() => file.lengthSync());
   }
 
   static void testLastModifiedSync() {
     var modified = new File(Platform.executable).lastModifiedSync();
     Expect.isTrue(modified is DateTime);
     Expect.isTrue(modified.isBefore(new DateTime.now()));
   }
@@ skipping 43 matching lines @@
     File file = new File(newFilePath);
     file.createSync();
     DateTime modifiedTime = new DateTime(2016, 1, 1);
     file.setLastModifiedSync(modifiedTime);
     FileStat stat = file.statSync();
     Expect.equals(2016, stat.modified.year);
     Expect.equals(1, stat.modified.month);
     Expect.equals(1, stat.modified.day);
   }
 
-
   static testSetLastModified() async {
     asyncTestStarted();
     String newFilePath = '${tempDirectory.path}/set_last_modified_test';
     File file = new File(newFilePath);
     file.createSync();
     DateTime modifiedTime = new DateTime(2016, 1, 1);
     await file.setLastModified(modifiedTime);
     FileStat stat = await file.stat();
     Expect.equals(2016, stat.modified.year);
     Expect.equals(1, stat.modified.month);
     Expect.equals(1, stat.modified.day);
     asyncTestDone("testSetLastModified");
   }
 
-
   static void testSetLastModifiedSyncDirectory() {
     Directory tmp = tempDirectory.createTempSync('file_last_modified_test_');
     String dirPath = '${tmp.path}/dir';
     new Directory(dirPath).createSync();
     try {
       DateTime modifiedTime = new DateTime(2016, 1, 1);
       new File(dirPath).setLastModifiedSync(modifiedTime);
       Expect.fail('Expected operation to throw');
     } catch (e) {
       if (e is! FileSystemException) {
@@ skipping 10 matching lines @@
     File file = new File(newFilePath);
     file.createSync();
     DateTime accessedTime = new DateTime(2016, 1, 1);
     file.setLastAccessedSync(accessedTime);
     FileStat stat = file.statSync();
     Expect.equals(2016, stat.accessed.year);
     Expect.equals(1, stat.accessed.month);
     Expect.equals(1, stat.accessed.day);
   }
 
-
   static testSetLastAccessed() async {
     asyncTestStarted();
     String newFilePath = '${tempDirectory.path}/set_last_accessed_test';
     File file = new File(newFilePath);
     file.createSync();
     DateTime accessedTime = new DateTime(2016, 1, 1);
     await file.setLastAccessed(accessedTime);
     FileStat stat = await file.stat();
     Expect.equals(2016, stat.accessed.year);
     Expect.equals(1, stat.accessed.month);
     Expect.equals(1, stat.accessed.day);
     asyncTestDone("testSetLastAccessed");
   }
 
-
   static void testSetLastAccessedSyncDirectory() {
     Directory tmp = tempDirectory.createTempSync('file_last_accessed_test_');
     String dirPath = '${tmp.path}/dir';
     new Directory(dirPath).createSync();
     try {
       DateTime accessedTime = new DateTime(2016, 1, 1);
       new File(dirPath).setLastAccessedSync(accessedTime);
       Expect.fail('Expected operation to throw');
     } catch (e) {
       if (e is! FileSystemException) {
@@ skipping 63 matching lines @@
             file.open(mode: APPEND).then((openedFile) {
               openedFile.setPosition(2).then((_) {
                 openedFile.writeString(string).then((_) {
                   openedFile.length().then((l) {
                     Expect.equals(4, l);
                     openedFile.close().then((_) {
                       file.readAsString().then((readBack) {
                         Expect.stringEquals(readBack, '$string$string');
                         file.delete().then((_) {
                           file.exists().then((e) {
-                           Expect.isFalse(e);
-                           asyncTestDone("testWriteStringUtf8");
+                            Expect.isFalse(e);
+                            asyncTestDone("testWriteStringUtf8");
                           });
                         });
                       });
                     });
                   });
                 });
               });
             });
           });
         });
@@ skipping 13 matching lines @@
     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());
   }
 
   static void testRename({bool targetExists}) {
-    lift(Function f) =>
-      (futureValue) => futureValue.then((value) => f(value));
+    lift(Function f) => (futureValue) => futureValue.then((value) => f(value));
     asyncTestStarted();
 
     String source = join(tempDirectory.path, 'rename_${targetExists}_source');
     String dest = join(tempDirectory.path, 'rename_${targetExists}_dest');
     var file = new File(source);
     var newfile = new File(dest);
-    file.create()
-      .then((_) => targetExists ? newfile.create() : null)
-      .then((_) => file.rename(dest))
-      .then((_) => lift(Expect.isFalse)(file.exists()))
-      .then((_) => lift(Expect.isTrue)(newfile.exists()))
-      .then((_) => newfile.delete())
-      .then((_) => lift(Expect.isFalse)(newfile.exists()))
-      .then((_) {
-        if (Platform.operatingSystem != "windows") {
-          new Link(source).create(dest)
-            .then((_) => file.rename("xxx"))
-            .then((_) { throw "Rename of broken link succeeded"; })
-            .catchError((e) {
-              Expect.isTrue(e is FileSystemException);
-              asyncTestDone("testRename$targetExists");
-            });
-        } else {
+    file
+        .create()
+        .then((_) => targetExists ? newfile.create() : null)
+        .then((_) => file.rename(dest))
+        .then((_) => lift(Expect.isFalse)(file.exists()))
+        .then((_) => lift(Expect.isTrue)(newfile.exists()))
+        .then((_) => newfile.delete())
+        .then((_) => lift(Expect.isFalse)(newfile.exists()))
+        .then((_) {
+      if (Platform.operatingSystem != "windows") {
+        new Link(source).create(dest).then((_) => file.rename("xxx")).then((_) {
+          throw "Rename of broken link succeeded";
+        }).catchError((e) {
+          Expect.isTrue(e is FileSystemException);
           asyncTestDone("testRename$targetExists");
-        }
-      });
+        });
+      } else {
+        asyncTestDone("testRename$targetExists");
+      }
+    });
   }
 
   static void testRenameSync({bool targetExists}) {
     String source = join(tempDirectory.path, 'rename_source');
     String dest = join(tempDirectory.path, 'rename_dest');
     var file = new File(source);
     var newfile = new File(dest);
     file.createSync();
     if (targetExists) {
       newfile.createSync();
@@ skipping 88 matching lines @@
       testSetLastAccessedSyncDirectory();
       testDoubleAsyncOperation();
       asyncEnd();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }