Change the behavior of open on files to not truncate by default

tests/standalone/src/FileTest.dart

 // Copyright (c) 2011, 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.
 
 
 class FileTest {
   static Directory tempDirectory;
   static int numLiveAsyncTests = 0;
@@ skipping 10 matching lines @@
     tempDirectory = new Directory('');
     tempDirectory.createTempHandler = doNext;
     tempDirectory.createTemp();
   }
 
   static void deleteTempDirectory() {
     tempDirectory.deleteSync();
   }
 
   // Test for file read functionality.
-  static int testReadStream() {
+  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);
     InputStream input = file.openInputStream();
     List<int> buffer = new List<int>(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.
     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.
-    return 1;
   }
 
   // Test for file read and write functionality.
-  static int testReadWriteStream() {
+  static void testReadWriteStream() {
+    // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     File file;
     InputStream input;
     int bytesRead;
 
     // Test reading all using readInto.
     file = new File(inFilename);
     input = file.openInputStream();
     List<int> buffer1 = new List<int>(42);
     bytesRead = input.readInto(buffer1, 0, 42);
@@ skipping 40 matching lines @@
     bytesRead = input.readInto(buffer2, 0, 42);
     Expect.isTrue(input.closed);
     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]);
     }
     // Delete the output file.
     file.deleteSync();
     Expect.isFalse(file.existsSync());
-    return 1;
   }
 
-  static int testRead() {
+  static void testRead() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
     file.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
     file.openHandler = (RandomAccessFile file) {
       List<int> buffer = new List<int>(10);
       file.readListHandler = (bytes_read) {
         Expect.equals(5, bytes_read);
         file.readListHandler = (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();
         };
         file.readList(buffer, 5, 5);
       };
       file.readList(buffer, 0, 5);
     };
     file.open();
-    return 1;
   }
 
-  static int testReadSync() {
+  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);
     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.
-    return 1;
   }
 
   // Test for file read and write functionality.
-  static int testReadWrite() {
+  static void testReadWrite() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     File file = new File(inFilename);
     file.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
     file.openHandler = (RandomAccessFile openedFile) {
       List<int> buffer1 = new List<int>(42);
       openedFile.readListHandler = (bytes_read) {
         Expect.equals(42, bytes_read);
@@ skipping 42 matching lines @@
                         openedFile.close();
                       };
                       openedFile.readList(buffer2, 0, 42);
                     };
                     file.open();
                   };
                   openedFile.close();
                 };
                 openedFile.writeList(buffer1, 0, bytes_read);
               };
-              file.open(true);
+              file.open(FileMode.WRITE);
             };
             file.fullPath();
           };
           file.create();
         };
         openedFile.close();
       };
       openedFile.readList(buffer1, 0, 42);
     };
     asyncTestStarted();
     file.open();
-    return 1;
-
   }
 
-  static int testReadWriteSync() {
+  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;
     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 + "/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(true);
+    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);
     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.
     outFile.deleteSync();
     Expect.isFalse(outFile.existsSync());
-    return 1;
   }
 
-  static int testReadEmptyFileSync() {
+  static void testReadEmptyFileSync() {
     String fileName = tempDirectory.path + "/empty_file_sync";
     File file = new File(fileName);
     file.createSync();
     RandomAccessFile openedFile = file.openSync();
     Expect.throws(() => openedFile.readByteSync(), (e) => e is FileIOException);
-    return 1;
   }
 
-  static int testReadEmptyFile() {
+  static void testReadEmptyFile() {
     String fileName = tempDirectory.path + "/empty_file";
     File file = new File(fileName);
     file.createHandler = () {
       file.openHandler = (RandomAccessFile openedFile) {
         openedFile.readByteHandler = (int byte) {
           Expect.fail("Read byte from empty file");
         };
         openedFile.errorHandler = (String err) {
           Expect.isTrue(err.indexOf("failed") != -1);
         };
         openedFile.readByte();
       };
       file.open();
     };
     asyncTestStarted();
     file.create();
-    return 1;
   }
 
   // Test for file length functionality.
-  static int testLength() {
+  static void testLength() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     input.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
     input.lengthHandler = (length) {
       Expect.equals(42, length);
       input.close();
     };
     input.length();
-    return 1;
   }
 
-  static int testLengthSync() {
+  static void testLengthSync() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     Expect.equals(42, input.lengthSync());
     input.closeSync();
-    return 1;
   }
 
   // Test for file position functionality.
-  static int testPosition() {
+  static void testPosition() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     input.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
     input.positionHandler = (position) {
       Expect.equals(0, position);
       List<int> buffer = new List<int>(100);
       input.readListHandler = (bytes_read) {
         input.positionHandler = (position) {
@@ skipping 11 matching lines @@
               input.setPosition(8);
             };
           };
           input.readList(buffer, 12, 6);
         };
         input.position();
       };
       input.readList(buffer, 0, 12);
     };
     input.position();
-    return 1;
   }
 
-  static int testPositionSync() {
+  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);
     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();
-    return 1;
   }
 
-  static int testTruncate() {
+  static void testTruncate() {
     File file = new File(tempDirectory.path + "/out_truncate");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     file.errorHandler = (error) {
       Expect.fail("testTruncate: No errors expected");
     };
     file.openHandler = (RandomAccessFile openedFile) {
       openedFile.noPendingWriteHandler = () {
         openedFile.lengthHandler = (length) {
           Expect.equals(10, length);
           openedFile.truncateHandler = () {
@@ skipping 13 matching lines @@
             };
             openedFile.length();
           };
           openedFile.truncate(5);
         };
         openedFile.length();
       };
       openedFile.writeList(buffer, 0, 10);
     };
     asyncTestStarted();
-    file.open(true);
-    return 1;
+    file.open(FileMode.WRITE);
   }
 
-  static int testTruncateSync() {
+  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(true);
+    RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     openedFile.writeListSync(buffer, 0, 10);
     Expect.equals(10, openedFile.lengthSync());
     openedFile.truncateSync(5);
     Expect.equals(5, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
-    return 1;
   }
 
   // Tests exception handling after file was closed.
-  static int testCloseException() {
+  static void testCloseException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File input = new File(tempDirectory.path + "/out_close_exception");
-    RandomAccessFile openedFile = input.openSync(true);
+    RandomAccessFile openedFile = input.openSync(FileMode.WRITE);
     openedFile.closeSync();
     try {
       openedFile.readByteSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
@@ skipping 63 matching lines @@
     try {
       openedFile.flushSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     input.deleteSync();
-    return 1;
   }
 
   // Tests stream exception handling after file was closed.
-  static int testCloseExceptionStream() {
+  static void testCloseExceptionStream() {
     List<int> buffer = new List<int>(42);
     File file = new File(tempDirectory.path + "/out_close_exception_stream");
     file.createSync();
     InputStream input = file.openInputStream();
     Expect.isTrue(input.closed);
     Expect.isNull(input.readInto(buffer, 0, 12));
     OutputStream output = file.openOutputStream();
     output.close();
     Expect.throws(( ) => output.writeFrom(buffer, 0, 12),
                   (e) => e is FileIOException);
     file.deleteSync();
-    return 1;
   }
 
   // Tests buffer out of bounds exception.
-  static int testBufferOutOfBoundsException() {
+  static void testBufferOutOfBoundsException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File file = new File(tempDirectory.path + "/out_buffer_out_of_bounds");
-    RandomAccessFile openedFile = file.openSync(true);
+    RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     try {
       List<int> buffer = new List<int>(10);
       bool readDone = openedFile.readListSync(buffer, 0, 12);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
@@ skipping 69 matching lines @@
       bool readDone = openedFile.writeListSync(buffer, 0, -1);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     openedFile.closeSync();
     file.deleteSync();
-    return 1;
   }
 
-  static int testMixedSyncAndAsync() {
+  static void testMixedSyncAndAsync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
     f.existsHandler = (exists) {
       try {
         f.existsSync();
         Expect.fail("Expected exception");
       } catch (var e) {
         Expect.isTrue(e is FileIOException);
       }
     };
     f.exists();
-    return 1;
+  }
+
+  // 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() {
+    var file = new File('${tempDirectory.path}/out_append');
+    file.openHandler = (openedFile) {
+      openedFile.noPendingWriteHandler = () {
+        openedFile.closeHandler = () {
+          file.openHandler = (openedFile) {
+            openedFile.lengthHandler = (length) {
+              Expect.equals(4, length);
+              openedFile.setPositionHandler = () {
+                openedFile.noPendingWriteHandler = () {
+                  openedFile.lengthHandler = (length) {
+                    Expect.equals(8, length);
+                    openedFile.closeHandler = () {
+                      file.deleteHandler = () {
+                        file.existsHandler = (exists) {
+                          Expect.isFalse(exists);
+                          asyncTestDone();
+                        };
+                        file.exists();
+                      };
+                      file.delete();
+                    };
+                    openedFile.close();
+                  };
+                  openedFile.length();
+                };
+                openedFile.writeString("asdf");
+              };
+              openedFile.setPosition(4);
+            };
+            openedFile.length();
+          };
+          file.open(FileMode.APPEND);
+        };
+        openedFile.close();
+      };
+      openedFile.writeString("asdf");
+    };
+    asyncTestStarted();
+    file.open(FileMode.WRITE);
+  }
+
+  static void testAppendSync() {
+    var file = new File('${tempDirectory.path}/out_append_sync');
+    var openedFile = file.openSync(FileMode.WRITE);
+    openedFile.writeStringSync("asdf");
+    Expect.equals(4, openedFile.lengthSync());
+    openedFile.closeSync();
+    openedFile = file.openSync(FileMode.WRITE);
+    openedFile.setPositionSync(4);
+    openedFile.writeStringSync("asdf");
+    Expect.equals(8, openedFile.lengthSync());
+    openedFile.closeSync();
+    file.deleteSync();
+    Expect.isFalse(file.existsSync());
   }
 
   // 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;
 
   // Main test entrypoint.
   static testMain() {
-    Expect.equals(1, testRead());
-    Expect.equals(1, testReadSync());
-    Expect.equals(1, testReadStream());
-    Expect.equals(1, testLength());
-    Expect.equals(1, testLengthSync());
-    Expect.equals(1, testPosition());
-    Expect.equals(1, testPositionSync());
-    Expect.equals(1, testMixedSyncAndAsync());
+    testRead();
+    testReadSync();
+    testReadStream();
+    testLength();
+    testLengthSync();
+    testPosition();
+    testPositionSync();
+    testMixedSyncAndAsync();
     asyncTestStarted();
     createTempDirectory(() {
-        Expect.equals(1, testReadWrite());
-        Expect.equals(1, testReadWriteSync());
-        Expect.equals(1, testReadWriteStream());
-        Expect.equals(1, testReadEmptyFileSync());
-        Expect.equals(1, testReadEmptyFile());
-        Expect.equals(1, testTruncate());
-        Expect.equals(1, testTruncateSync());
-        Expect.equals(1, testCloseException());
-        Expect.equals(1, testCloseExceptionStream());
-        Expect.equals(1, testBufferOutOfBoundsException());
+        testReadWrite();
+        testReadWriteSync();
+        testReadWriteStream();
+        testReadEmptyFileSync();
+        testReadEmptyFile();
+        testTruncate();
+        testTruncateSync();
+        testCloseException();
+        testCloseExceptionStream();
+        testBufferOutOfBoundsException();
+        testAppend();
+        testAppendSync();
         asyncTestDone();
       });
   }
 }
 
 main() {
   FileTest.testMain();
 }