Add ASCII encoding to lib/convert.

tests/lib/convert/ascii_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
 import 'dart:convert';
 
-var latin1Strings = [
+var asciiStrings = [
   "pure ascii",
-  "blåbærgrød",
-  "\x00 edge cases \xff"
+  "\x00 with control characters \n",
+  "\x01 edge cases \x7f"
 ];
 
-var nonLatin1Strings = [
-  "Edge case \u{100}",
+var nonAsciiStrings = [
+  "\x80 edge case first",
+  "Edge case ASCII \u{80}",
+  "Edge case byte \u{ff}",
   "Edge case super-BMP \u{10000}"
 ];
 
 void main() {
   // Build longer versions of the example strings.
-  for (int i = 0, n = latin1Strings.length; i < n ; i++) {
-    var string = latin1Strings[i];
+  for (int i = 0, n = asciiStrings.length; i < n ; i++) {
+    var string = asciiStrings[i];
     while (string.length < 1024) {
       string += string;
     }
-    latin1Strings.add(string);
+    asciiStrings.add(string);
   }
-  for (int i = 0, n = nonLatin1Strings.length; i < n ; i++) {
-    var string = nonLatin1Strings[i];
+  for (int i = 0, n = nonAsciiStrings.length; i < n ; i++) {
+    var string = nonAsciiStrings[i];
     while (string.length < 1024) {
       string += string;
     }
-    nonLatin1Strings.add(string);
+    nonAsciiStrings.add(string);
   }
   testDirectConversions();
   testChunkedConversions();
 }
 
 void testDirectConversions() {
-  for (var codec in [LATIN1, new Latin1Codec()]) {
-    for (var latin1String in latin1Strings) {
-      List bytes = codec.encoder.convert(latin1String);
-      Expect.listEquals(latin1String.codeUnits.toList(), bytes, latin1String);
+  for (var codec in [ASCII, new AsciiCodec()]) {
+    for (var asciiString in asciiStrings) {
+      List bytes = codec.encoder.convert(asciiString);
+      Expect.listEquals(asciiString.codeUnits.toList(), bytes, asciiString);
       String roundTripString = codec.decoder.convert(bytes);
-      Expect.equals(latin1String, roundTripString);
+      Expect.equals(asciiString, roundTripString);
       roundTripString = codec.decode(bytes);
-      Expect.equals(latin1String, roundTripString);
+      Expect.equals(asciiString, roundTripString);
     }
 
-    for (var nonLatin1String in nonLatin1Strings) {
+    for (var nonAsciiString in nonAsciiStrings) {
       Expect.throws(() {
-        print(codec.encoder.convert(nonLatin1String));
-      }, null, nonLatin1String);
+        print(codec.encoder.convert(nonAsciiString));
+      }, null, nonAsciiString);
     }
   }
 
-  var allowInvalidCodec = new Latin1Codec(allowInvalid: true);
+  var allowInvalidCodec = new AsciiCodec(allowInvalid: true);
   var invalidBytes = [0, 1, 0xff, 0xdead, 0];
   String decoded = allowInvalidCodec.decode(invalidBytes);
-  Expect.equals("\x00\x01\xFF\uFFFD\x00", decoded);
+  Expect.equals("\x00\x01\uFFFD\uFFFD\x00", decoded);
   decoded = allowInvalidCodec.decoder.convert(invalidBytes);
-  Expect.equals("\x00\x01\xFF\uFFFD\x00", decoded);
-  decoded = LATIN1.decode(invalidBytes, allowInvalid: true);
-  Expect.equals("\x00\x01\xFF\uFFFD\x00", decoded);
+  Expect.equals("\x00\x01\uFFFD\uFFFD\x00", decoded);
+  decoded = ASCII.decode(invalidBytes, allowInvalid: true);
+  Expect.equals("\x00\x01\uFFFD\uFFFD\x00", decoded);
 }
 
 List<int> encode(String str, int chunkSize,
                  Converter<String, List<int>> converter) {
   List<int> bytes = <int>[];
   ChunkedConversionSink byteSink =
       new ByteConversionSink.withCallback(bytes.addAll);
   var stringConversionSink = converter.startChunkedConversion(byteSink);
   for (int i = 0; i < str.length; i += chunkSize) {
     if (i + chunkSize <= str.length) {
@@ skipping 18 matching lines @@
     } else {
       byteConversionSink.add(bytes.sublist(i));
     }
   }
   byteConversionSink.close();
   return buf.toString();
 }
 
 void testChunkedConversions() {
   // Check encoding.
-  for (var converter in [LATIN1.encoder,
-                         new Latin1Codec().encoder,
-                         new Latin1Encoder()]) {
+  for (var converter in [ASCII.encoder,
+                         new AsciiCodec().encoder,
+                         new AsciiEncoder()]) {
     for (int chunkSize in [1, 2, 5, 50]) {
-      for (var latin1String in latin1Strings) {
-        var units = latin1String.codeUnits.toList();
-        List bytes = encode(latin1String, chunkSize, converter);
+      for (var asciiString in asciiStrings) {
+        var units = asciiString.codeUnits.toList();
+        List bytes = encode(asciiString, chunkSize, converter);
         Expect.listEquals(units, bytes);
       }
-      for (var nonLatin1String in nonLatin1Strings) {
+      for (var nonAsciiString in nonAsciiStrings) {
         Expect.throws(() {
-          encode(nonLatin1Strings, chunkSize, converter);
+          encode(nonAsciiStrings, chunkSize, converter);
         });
       }
     }
   }
   // Check decoding.
-  for (var converter in [LATIN1.decoder,
-                         new Latin1Codec().decoder,
-                         new Latin1Decoder()]) {
+  for (var converter in [ASCII.decoder,
+                         new AsciiCodec().decoder,
+                         new AsciiDecoder()]) {
     for (int chunkSize in [1, 2, 5, 50]) {
-      for (var latin1String in latin1Strings) {
-        var units = latin1String.codeUnits.toList();
-        Expect.equals(latin1String, decode(units, chunkSize, converter));
+      for (var asciiString in asciiStrings) {
+        var units = asciiString.codeUnits.toList();
+        Expect.equals(asciiString, decode(units, chunkSize, converter));
       }
-      for (var nonLatin1String in nonLatin1Strings) {
-        var units = nonLatin1String.codeUnits.toList();
+      for (var nonAsciiString in nonAsciiStrings) {
+        var units = nonAsciiString.codeUnits.toList();
         Expect.throws(() {
           decode(units, chunkSize, converter);
         });
       }
     }
   }
 }