Add an option for percent-encoding of the padding character to Base64Codec

test/base64_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.
 
 // Library tag to allow the test to run on Dartium.
 library base64_test;
 
 import 'dart:math';
 import 'dart:async';
 
 import "package:crypto/crypto.dart";
 import "package:test/test.dart";
 
 void main() {
   test('encoder', _testEncoder);
   test('decoder', _testDecoder);
   test('decoder for malformed input', _testDecoderForMalformedInput);
   test('encode decode lists', _testEncodeDecodeLists);
   test('url safe encode-decode', _testUrlSafeEncodeDecode);
   test('consistent safe/unsafe character decoding',
        _testConsistentSafeUnsafeDecode);
+  test('percent-encoded padding character encode-decode',
+       _testPaddingCharacter);
   test('streaming encoder', _testStreamingEncoder);
   test('streaming decoder', _testStreamingDecoder);
   test('streaming decoder for malformed input',
        _testStreamingDecoderForMalformedInput);
   test('streaming encoder for different decompositions of a list of bytes',
        _testStreamingEncoderForDecompositions);
   test('streaming decoder for different decompositions of a string',
        _testStreamingDecoderForDecompositions);
   test('consistent safe/unsafe character streaming decoding',
        _testConsistentSafeUnsafeStreamDecode);
+  test('streaming for encoded padding character',
+       _testStreamingForEncodedPadding);
   test('old api', _testOldApi);
   test('url safe streaming encoder/decoder', _testUrlSafeStreaming);
   test('performance', _testPerformance);
 
 
 }
 
 // Data from http://tools.ietf.org/html/rfc4648.
 const _INPUTS =
     const [ '', 'f', 'fo', 'foo', 'foob', 'fooba', 'foobar'];
 const _RESULTS =
     const [ '', 'Zg==', 'Zm8=', 'Zm9v', 'Zm9vYg==', 'Zm9vYmE=', 'Zm9vYmFy'];
+
+const _PADDING_INPUT = const [2, 8];
+
 var _STREAMING_ENCODER_INPUT =
     [[102, 102], [111, 102],
      [111, 111, 102, 111, 111, 98, 102, 111,
       111, 98, 97, 102, 111, 111, 98, 97, 114]];
 
 const _STREAMING_ENCODED = 'ZmZvZm9vZm9vYmZvb2JhZm9vYmFy';
 const _STREAMING_DECODER_INPUT =
     const ['YmFz', 'ZTY', '0I', 'GRlY29kZXI='];
 const _STREAMING_DECODED =
     const [98, 97, 115, 101, 54, 52, 32, 100, 101, 99, 111, 100, 101, 114];
@@ skipping 87 matching lines @@
         inputsWithZeroes[i]);
   }
 
   var longLineDecoded = BASE64.decode(_LONG_LINE_RESULT);
   expect(new String.fromCharCodes(longLineDecoded), _LONG_LINE);
 
   var longLineResultNoBreak = BASE64.decode(_LONG_LINE_RESULT);
   expect(new String.fromCharCodes(longLineResultNoBreak), _LONG_LINE);
 }
 
+void _testPaddingCharacter() {
+  var encoded = BASE64.encode(_PADDING_INPUT, encodePaddingCharacter: true);
+  expect(encoded, 'Agg%3D');
+  expect(BASE64.decode(encoded), _PADDING_INPUT);
+}
+
 Future _testStreamingEncoder() async {
   expect(
       await new Stream.fromIterable(_STREAMING_ENCODER_INPUT)
                       .transform(BASE64.encoder)
                       .join(),
       _STREAMING_ENCODED);
 }
 
 Future _testStreamingDecoder() async {
   expect(
@@ skipping 69 matching lines @@
   }, throwsFormatException);
 }
 
 Future _testConsistentSafeUnsafeStreamDecode() {
   expect(new Stream.fromIterable(_INCONSISTENT_SAFE_STREAMING_RESULT)
                    .transform(BASE64.decoder)
                    .toList(),
          throwsFormatException);
 }
 
+Future _testStreamingForEncodedPadding() async {
+  List<String> withEncodedPadding = ['AA%', '3D', '%', '3', 'DEFGZ'];
+  List<int> decoded = BASE64.decode('AA==EFGZ');
+  var streamedResult = await new Stream.fromIterable(withEncodedPadding)
+      .transform(BASE64.decoder).expand((x) => x).toList();
+
+  expect(streamedResult, decoded);
+}
+
 void _testUrlSafeEncodeDecode() {
   List<int> decUrlSafe = BASE64.decode('-_A=');
   List<int> dec = BASE64.decode('+/A=');
   expect(decUrlSafe, orderedEquals(dec));
   expect(BASE64.encode(dec, urlSafe: true), '-_A=');
   expect(BASE64.encode(dec), '+/A=');
 }
 
 void _testEncodeDecodeLists() {
   for (int i = 0; i < 10; i++) {
@@ skipping 37 matching lines @@
     // print("Encode 1024 bytes for $iters times: $ms msec. $perSec b/s");
     w..reset();
     for( int i = 0; i < iters; ++i ) {
       BASE64.decode(enc);
     }
     ms = w.elapsedMilliseconds;
     perSec = (iters * l.length) * 1000 ~/ ms;
     // ('''Decode into ${l.length} bytes for $iters
     //     times: $ms msec. $perSec b/s''');
 }