Rename RandomAccessFile.readList and RandomAccessFile.writeList to RandomAccessFile.readInto and Ra…

tests/standalone/io/file_test.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Dart test program for testing file I/O.
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
@@ skipping 185 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(mode: READ).then((RandomAccessFile file) {
       List<int> buffer = new List<int>(10);
-      file.readList(buffer, 0, 5).then((bytes_read) {
+      file.readInto(buffer, 0, 5).then((bytes_read) {
         Expect.equals(5, bytes_read);
-        file.readList(buffer, 5, 5).then((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.
           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 raf = (new File(filename)).openSync();
     List<int> buffer = new List<int>(42);
     int bytes_read = 0;
-    bytes_read = raf.readListSync(buffer, 0, 12);
+    bytes_read = raf.readIntoSync(buffer, 0, 12);
     Expect.equals(12, bytes_read);
-    bytes_read = raf.readListSync(buffer, 12, 30);
+    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.
@@ skipping 13 matching lines @@
     Expect.equals(len, file.openSync().readSync(len * 10).length);
   }
 
   // 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(mode: READ).then((openedFile) {
       List<int> buffer1 = new List<int>(42);
-      openedFile.readList(buffer1, 0, 42).then((bytes_read) {
+      openedFile.readInto(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 + "/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(mode: WRITE).then((openedFile2) {
-                openedFile2.writeList(buffer1, 0, bytes_read).then((ignore) {
+                openedFile2.writeFrom(buffer1, 0, bytes_read).then((ignore) {
                   openedFile2.close().then((ignore) {
                     List<int> buffer2 = new List<int>(bytes_read);
                     final File file3 = new File(outFilename);
                     file3.open(mode: READ).then((openedFile3) {
-                      openedFile3.readList(buffer2, 0, 42).then((bytes_read) {
+                      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]);
                           }
                           // Delete the output file.
                           final file4 = file3;
@@ skipping 18 matching lines @@
   }
 
   static void testWriteAppend() {
     String content = "foobar";
     String filename = tempDirectory.path + "/write_append";
     File file = new File(filename);
     file.createSync();
     Expect.isTrue(new File(filename).existsSync());
     List<int> buffer = content.codeUnits;
     RandomAccessFile openedFile = file.openSync(mode: WRITE);
-    openedFile.writeListSync(buffer, 0, buffer.length);
+    openedFile.writeFromSync(buffer, 0, buffer.length);
     openedFile.closeSync();
     // Reopen the file in write mode to ensure that we overwrite the content.
     openedFile = (new File(filename)).openSync(mode: WRITE);
-    openedFile.writeListSync(buffer, 0, buffer.length);
+    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.writeListSync(buffer, 0, buffer.length);
+    openedFile.writeFromSync(buffer, 0, buffer.length);
     Expect.equals(content.length * 2, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testOutputStreamWriteAppend() {
     String content = "foobar";
     String filename = tempDirectory.path + "/outstream_write_append";
     File file = new File(filename);
     file.createSync();
@@ skipping 52 matching lines @@
   }
 
 
   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);
+    bytes_read = file.readIntoSync(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(mode: WRITE);
-    openedFile.writeListSync(buffer1, 0, bytes_read);
+    openedFile.writeFromSync(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);
+    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]);
+    }
+    // Delete the output file.
+    outFile.deleteSync();
+    Expect.isFalse(outFile.existsSync());
+  }
+
+  static void testReadWriteNoArgsSync() {
+    // 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.readIntoSync(buffer1);
+    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(mode: WRITE);
+    openedFile.writeFromSync(buffer1);
+    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]);
     }
     // Delete the output file.
     outFile.deleteSync();
     Expect.isFalse(outFile.existsSync());
   }
 
   static void testReadEmptyFileSync() {
@@ skipping 24 matching lines @@
   }
 
   // Test for file write of different types of lists.
   static void testWriteVariousLists() {
     asyncTestStarted();
     final String fileName = "${tempDirectory.path}/testWriteVariousLists";
     final File file = new File(fileName);
     file.create().then((ignore) {
       file.open(mode: WRITE).then((RandomAccessFile openedFile) {
         // Write bytes from 0 to 7.
-        openedFile.writeList([0], 0, 1);
-        openedFile.writeList(const [1], 0, 1);
-        openedFile.writeList(new MyListOfOneElement(2), 0, 1);
+        openedFile.writeFrom([0], 0, 1);
+        openedFile.writeFrom(const [1], 0, 1);
+        openedFile.writeFrom(new MyListOfOneElement(2), 0, 1);
         var x = 12345678901234567890123456789012345678901234567890;
         var y = 12345678901234567890123456789012345678901234567893;
-        openedFile.writeList([y - x], 0, 1);
-        openedFile.writeList([260], 0, 1);  // 260 = 256 + 4 = 0x104.
-        openedFile.writeList(const [261], 0, 1);
-        openedFile.writeList(new MyListOfOneElement(262), 0, 1);
+        openedFile.writeFrom([y - x], 0, 1);
+        openedFile.writeFrom([260], 0, 1);  // 260 = 256 + 4 = 0x104.
+        openedFile.writeFrom(const [261], 0, 1);
+        openedFile.writeFrom(new MyListOfOneElement(262), 0, 1);
         x = 12345678901234567890123456789012345678901234567890;
         y = 12345678901234567890123456789012345678901234568153;
-        openedFile.writeList([y - x], 0, 1).then((ignore) {
+        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();
             Expect.equals(8, length);
             List data = new List(length);
-            openedFile2.readListSync(data, 0, length);
+            openedFile2.readIntoSync(data, 0, length);
             for (var i = 0; i < data.length; i++) {
               Expect.equals(i, data[i]);
             }
             openedFile2.closeSync();
             file2.deleteSync();
             asyncTestDone("testWriteVariousLists");
           });
         });
       });
     });
@@ skipping 83 matching lines @@
   }
 
   // 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);
-      input.readList(buffer, 0, 12).then((bytes_read) {
+      input.readInto(buffer, 0, 12).then((bytes_read) {
         input.position().then((position) {
           Expect.equals(12, position);
-          input.readList(buffer, 12, 6).then((bytes_read) {
+          input.readInto(buffer, 12, 18).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);
-    input.readListSync(buffer, 0, 12);
+    input.readIntoSync(buffer, 0, 12);
     Expect.equals(12, input.positionSync());
-    input.readListSync(buffer, 12, 6);
+    input.readIntoSync(buffer, 12, 18);
     Expect.equals(18, input.positionSync());
     input.setPositionSync(8);
     Expect.equals(8, input.positionSync());
     input.closeSync();
   }
 
   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.open(mode: WRITE).then((RandomAccessFile openedFile) {
-      openedFile.writeList(buffer, 0, 10).then((ignore) {
+      openedFile.writeFrom(buffer, 0, 10).then((ignore) {
         openedFile.length().then((length) {
           Expect.equals(10, length);
           openedFile.truncate(5).then((ignore) {
             openedFile.length().then((length) {
               Expect.equals(5, length);
               openedFile.close().then((ignore) {
                 file.delete().then((ignore) {
                   file.exists().then((exists) {
                     Expect.isFalse(exists);
                     asyncTestDone("testTruncate");
                   });
                 });
               });
             });
           });
         });
       });
     });
     asyncTestStarted();
   }
 
   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(mode: WRITE);
-    openedFile.writeListSync(buffer, 0, 10);
+    openedFile.writeFromSync(buffer, 0, 10);
     Expect.equals(10, openedFile.lengthSync());
     openedFile.truncateSync(5);
     Expect.equals(5, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
   }
 
   // Tests exception handling after file was closed.
   static void testCloseException() {
@@ skipping 27 matching lines @@
     } 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);
-      openedFile.readListSync(buffer, 0, 10);
+      openedFile.readIntoSync(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);
-      openedFile.writeListSync(buffer, 0, 10);
+      openedFile.writeFromSync(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 {
       openedFile.positionSync();
@@ skipping 45 matching lines @@
 
   // 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");
     RandomAccessFile openedFile = file.openSync(mode: WRITE);
     try {
       List<int> buffer = new List<int>(10);
-      openedFile.readListSync(buffer, 0, 12);
+      openedFile.readIntoSync(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);
-      openedFile.readListSync(buffer, 6, 6);
+      openedFile.readIntoSync(buffer, 6, 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);
-      openedFile.readListSync(buffer, -1, 1);
+      openedFile.readIntoSync(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);
-      openedFile.readListSync(buffer, 0, -1);
+      openedFile.readIntoSync(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);
-      openedFile.writeListSync(buffer, 0, 12);
+      openedFile.writeFromSync(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);
-      openedFile.writeListSync(buffer, 6, 6);
+      openedFile.writeFromSync(buffer, 6, 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);
-      openedFile.writeListSync(buffer, -1, 1);
+      openedFile.writeFromSync(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);
-      openedFile.writeListSync(buffer, 0, -1);
+      openedFile.writeFromSync(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();
   }
@@ skipping 338 matching lines @@
     testReadAsTextSyncEmptyFile();
     testReadAsLines();
     testReadAsLinesSync();
     testReadAsErrors();
     testLastModified();
     testLastModifiedSync();
 
     createTempDirectory(() {
       testReadWrite();
       testReadWriteSync();
+      testReadWriteNoArgsSync();
       testReadWriteStream();
       testReadEmptyFileSync();
       testReadEmptyFile();
       testReadWriteStreamLargeFile();
       testTruncate();
       testTruncateSync();
       testCloseException();
       testCloseExceptionStream();
       testBufferOutOfBoundsException();
       testAppend();
       testAppendSync();
       testWriteAppend();
       testOutputStreamWriteAppend();
       testOutputStreamWriteString();
       testWriteVariousLists();
       testDirectory();
       testDirectorySync();
       testWriteStringUtf8();
       testWriteStringUtf8Sync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }