Make common file mode and encoding constants available on the top level in dart:io

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 183 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: FileMode.READ).then((RandomAccessFile file) {
+    file.open(mode: READ).then((RandomAccessFile file) {
       List<int> buffer = new List<int>(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.
@@ skipping 41 matching lines @@
     Expect.equals(len, file.openSync().readSync(len + 1).length);
     Expect.equals(len, file.openSync().readSync(len * 2).length);
     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: FileMode.READ).then((openedFile) {
+    file.open(mode: READ).then((openedFile) {
       List<int> buffer1 = new List<int>(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 + "/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: FileMode.WRITE).then((openedFile2) {
+              file2.open(mode: WRITE).then((openedFile2) {
                 openedFile2.writeList(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: FileMode.READ).then((openedFile3) {
+                    file3.open(mode: 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]);
                           }
                           // Delete the output file.
@@ skipping 18 matching lines @@
     asyncTestStarted();
   }
 
   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: FileMode.WRITE);
+    RandomAccessFile openedFile = file.openSync(mode: WRITE);
     openedFile.writeListSync(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: FileMode.WRITE);
+    openedFile = (new File(filename)).openSync(mode: WRITE);
     openedFile.writeListSync(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: FileMode.APPEND);
+    openedFile = (new File(filename)).openSync(mode: APPEND);
     openedFile.writeListSync(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();
     List<int> buffer = content.codeUnits;
     var output = file.openWrite();
     output.add(buffer);
     output.close();
     output.done.then((_) {
       File file2 = new File(filename);
-      var appendingOutput = file2.openWrite(mode: FileMode.APPEND);
+      var appendingOutput = file2.openWrite(mode: APPEND);
       appendingOutput.add(buffer);
       appendingOutput.close();
       appendingOutput.done.then((_) {
         File file3 = new File(filename);
-        file3.open(mode: FileMode.READ).then((RandomAccessFile openedFile) {
+        file3.open(mode: READ).then((RandomAccessFile openedFile) {
           openedFile.length().then((int length) {
             Expect.equals(content.length * 2, length);
             openedFile.close().then((ignore) {
               file3.delete().then((ignore) {
                 asyncTestDone("testOutputStreamWriteAppend");
               });
             });
           });
         });
       });
     });
     asyncTestStarted();
   }
 
   // Test for file read and write functionality.
   static void testOutputStreamWriteString() {
     String content = "foobar";
     String filename = tempDirectory.path + "/outstream_write_string";
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.codeUnits;
     var output = file.openWrite();
     output.write("abcdABCD");
-    output.encoding = Encoding.UTF_8;
+    output.encoding = UTF_8;
     output.write("abcdABCD");
-    output.encoding = Encoding.ISO_8859_1;
+    output.encoding = ISO_8859_1;
     output.write("abcdABCD");
-    output.encoding = Encoding.ASCII;
+    output.encoding = ASCII;
     output.write("abcdABCD");
-    output.encoding = Encoding.UTF_8;
+    output.encoding = UTF_8;
     output.write("æøå");
     output.close();
     output.done.then((_) {
       RandomAccessFile raf = file.openSync();
       Expect.equals(38, raf.lengthSync());
       raf.close().then((ignore) {
         asyncTestDone("testOutputStreamWriteString");
       });
     });
     asyncTestStarted();
@@ skipping 12 matching lines @@
     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: FileMode.WRITE);
+    RandomAccessFile openedFile = outFile.openSync(mode: 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);
@@ skipping 13 matching lines @@
     Expect.equals(-1, openedFile.readByteSync());
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testReadEmptyFile() {
     String fileName = tempDirectory.path + "/empty_file";
     File file = new File(fileName);
     asyncTestStarted();
     file.create().then((ignore) {
-      file.open(mode: FileMode.READ).then((RandomAccessFile openedFile) {
+      file.open(mode: READ).then((RandomAccessFile openedFile) {
         var readByteFuture = openedFile.readByte();
         readByteFuture.then((int byte) {
           Expect.equals(-1, byte);
           openedFile.close().then((ignore) {
             asyncTestDone("testReadEmptyFile");
           });
         });
       });
     });
   }
 
   // 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: FileMode.WRITE).then((RandomAccessFile openedFile) {
+      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);
         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);
@@ skipping 140 matching lines @@
     input.readListSync(buffer, 12, 6);
     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: FileMode.WRITE).then((RandomAccessFile openedFile) {
+    file.open(mode: WRITE).then((RandomAccessFile openedFile) {
       openedFile.writeList(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: FileMode.WRITE);
+    RandomAccessFile openedFile = file.openSync(mode: 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());
   }
 
   // Tests exception handling after file was closed.
   static void testCloseException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File input = new File(tempDirectory.path + "/out_close_exception");
-    RandomAccessFile openedFile = input.openSync(mode: FileMode.WRITE);
+    RandomAccessFile openedFile = input.openSync(mode: WRITE);
     openedFile.closeSync();
     try {
       openedFile.readByteSync();
     } on FileIOException catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
@@ skipping 87 matching lines @@
       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");
-    RandomAccessFile openedFile = file.openSync(mode: FileMode.WRITE);
+    RandomAccessFile openedFile = file.openSync(mode: WRITE);
     try {
       List<int> buffer = new List<int>(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);
@@ skipping 73 matching lines @@
       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(mode: FileMode.READ);
+    var future = f.open(mode: READ);
     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) {
@@ skipping 54 matching lines @@
   }
 
   static void testReadAsText() {
     var port = new ReceivePort();
     port.receive((result, replyTo) {
       port.close();
       Expect.equals(1, result);
     });
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
-    f.readAsString(encoding: Encoding.UTF_8).then((text) {
+    f.readAsString(encoding: UTF_8).then((text) {
       Expect.isTrue(text.endsWith("42 bytes."));
       Expect.equals(42, text.length);
       var name = getDataFilename("tests/standalone/io/read_as_text.dat");
       var f = new File(name);
-      f.readAsString(encoding: Encoding.UTF_8).then((text) {
+      f.readAsString(encoding: UTF_8).then((text) {
         Expect.equals(6, text.length);
         var expected = [955, 120, 46, 32, 120, 10];
         Expect.listEquals(expected, text.codeUnits);
-        f.readAsString(encoding: Encoding.ISO_8859_1).then((text) {
+        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.codeUnits);
-          var readAsStringFuture = f.readAsString(encoding: Encoding.ASCII);
+          var readAsStringFuture = f.readAsString(encoding: ASCII);
           readAsStringFuture.then((text) {
             Expect.fail("Non-ascii char should cause error");
           }).catchError((e) {
             port.toSendPort().send(1);
           });
         });
       });
     });
   }
 
   static void testReadAsTextEmptyFile() {
     var port = new ReceivePort();
     port.receive((result, replyTo) {
       port.close();
       Expect.equals(0, result);
     });
     var name = getFilename("tests/vm/data/empty_file");
     var f = new File(name);
-    f.readAsString(encoding: Encoding.UTF_8).then((text) {
+    f.readAsString(encoding: UTF_8).then((text) {
       port.toSendPort().send(text.length);
       return true;
     });
   }
 
   static void testReadAsTextSync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var text = new File(name).readAsStringSync();
     Expect.isTrue(text.endsWith("42 bytes."));
     Expect.equals(42, text.length);
     name = getDataFilename("tests/standalone/io/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);
-    text = new File(name).readAsStringSync(encoding: Encoding.ASCII);
+    text = new File(name).readAsStringSync(encoding: ASCII);
     // Default replacement character is '?', char code 63.
     expected = [63, 63, 120, 46, 32, 120, 10];
     Expect.listEquals(expected, text.codeUnits);
-    text = new File(name).readAsStringSync(encoding: Encoding.ISO_8859_1);
+    text = new File(name).readAsStringSync(encoding: ISO_8859_1);
     expected = [206, 187, 120, 46, 32, 120, 10];
     Expect.equals(7, text.length);
     Expect.listEquals(expected, text.codeUnits);
   }
 
   static void testReadAsTextSyncEmptyFile() {
     var name = getFilename("tests/vm/data/empty_file");
     var text = new File(name).readAsStringSync();
     Expect.equals(0, text.length);
   }
 
   static void testReadAsLines() {
     var port = new ReceivePort();
     port.receive((result, replyTo) {
       port.close();
       Expect.equals(42, result);
     });
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
-    f.readAsLines(encoding: Encoding.UTF_8).then((lines) {
+    f.readAsLines(encoding: UTF_8).then((lines) {
       Expect.equals(1, lines.length);
       var line = lines[0];
       Expect.isTrue(line.endsWith("42 bytes."));
       port.toSendPort().send(line.length);
     });
   }
 
   static void testReadAsLinesSync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var lines = new File(name).readAsLinesSync();
@@ skipping 13 matching lines @@
       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"))
     .catchError((e) {
-      var readAsStringFuture = f.readAsString(encoding: Encoding.UTF_8);
+      var readAsStringFuture = f.readAsString(encoding: UTF_8);
       readAsStringFuture.then((text) => Expect.fail("no text expected"))
       .catchError((e) {
-        var readAsLinesFuture = f.readAsLines(encoding: Encoding.UTF_8);
+        var readAsLinesFuture = f.readAsLines(encoding: UTF_8);
         readAsLinesFuture.then((lines) => Expect.fail("no lines expected"))
         .catchError((e) {
           port.toSendPort().send(1);
         });
       });
     });
   }
 
   static void testLastModified() {
     var port = new ReceivePort();
     new File(new Options().executable).lastModified().then((modified) {
       Expect.isTrue(modified is DateTime);
       Expect.isTrue(modified.isBefore(new DateTime.now()));
       port.close();
     });
   }
 
   static void testLastModifiedSync() {
     var modified = new File(new Options().executable).lastModifiedSync();
     Expect.isTrue(modified is DateTime);
     Expect.isTrue(modified.isBefore(new DateTime.now()));
   }
 
   // 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.open(mode: FileMode.WRITE).then((openedFile) {
+    file.open(mode: WRITE).then((openedFile) {
       openedFile.writeString("asdf").then((ignore) {
         openedFile.close().then((ignore) {
-          file.open(mode: FileMode.APPEND).then((openedFile) {
+          file.open(mode: APPEND).then((openedFile) {
             openedFile.length().then((length) {
               Expect.equals(4, length);
               openedFile.writeString("asdf").then((ignore) {
                 openedFile.length().then((length) {
                   Expect.equals(8, length);
                   openedFile.close().then((ignore) {
                     file.delete().then((ignore) {
                       file.exists().then((exists) {
                         Expect.isFalse(exists);
                         asyncTestDone("testAppend");
                       });
                     });
                   });
                 });
               });
             });
           });
         });
       });
     });
     asyncTestStarted();
   }
 
   static void testAppendSync() {
     var file = new File('${tempDirectory.path}/out_append_sync');
-    var openedFile = file.openSync(mode: FileMode.WRITE);
+    var openedFile = file.openSync(mode: WRITE);
     openedFile.writeStringSync("asdf");
     Expect.equals(4, openedFile.lengthSync());
     openedFile.closeSync();
-    openedFile = file.openSync(mode: FileMode.WRITE);
+    openedFile = file.openSync(mode: WRITE);
     openedFile.setPositionSync(4);
     openedFile.writeStringSync("asdf");
     Expect.equals(8, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
   }
 
   static void testWriteStringUtf8() {
     var file = new File('${tempDirectory.path}/out_write_string');
     var string = new String.fromCharCodes([0x192]);
-    file.open(mode: FileMode.WRITE).then((openedFile) {
+    file.open(mode: WRITE).then((openedFile) {
       openedFile.writeString(string).then((_) {
         openedFile.length().then((l) {
           Expect.equals(2, l);
           openedFile.close().then((_) {
-            file.open(mode: FileMode.APPEND).then((openedFile) {
+            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");
                           });
                         });
                       });
                     });
                   });
                 });
               });
             });
           });
         });
       });
     });
     asyncTestStarted();
   }
 
   static void testWriteStringUtf8Sync() {
     var file = new File('${tempDirectory.path}/out_write_string_sync');
     var string = new String.fromCharCodes([0x192]);
-    var openedFile = file.openSync(mode: FileMode.WRITE);
+    var openedFile = file.openSync(mode: WRITE);
     openedFile.writeStringSync(string);
     Expect.equals(2, openedFile.lengthSync());
     openedFile.closeSync();
-    openedFile = file.openSync(mode: FileMode.APPEND);
+    openedFile = file.openSync(mode: APPEND);
     openedFile.setPositionSync(2);
     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());
   }
 
@@ skipping 54 matching lines @@
       testDirectorySync();
       testWriteStringUtf8();
       testWriteStringUtf8Sync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }