Implement a Base64 codec
Implement a Base64 codec similar to codecs in 'dart:convert'.
`CryptoUtils.bytesToBase64` and `CryptoUtils.base64StringToBytes`
remain for backward compatibility, but they internally invoke
`Base64.encode` and `Base64.decode` respectively
BUG=
R=lrn@google.com, sgjesse@google.com
Review URL: https://codereview.chromium.org//1159093002
diff --git a/lib/crypto.dart b/lib/crypto.dart
index 892626f..eb2905a 100644
--- a/lib/crypto.dart
+++ b/lib/crypto.dart
@@ -10,6 +10,7 @@
import 'dart:math';
import 'dart:typed_data';
+import 'dart:convert';
part 'src/crypto_utils.dart';
part 'src/hash_utils.dart';
@@ -17,6 +18,7 @@
part 'src/md5.dart';
part 'src/sha1.dart';
part 'src/sha256.dart';
+part 'src/base64.dart';
/**
* Interface for cryptographic hash functions.
diff --git a/lib/src/base64.dart b/lib/src/base64.dart
new file mode 100644
index 0000000..7ccf4aa
--- /dev/null
+++ b/lib/src/base64.dart
@@ -0,0 +1,377 @@
+part of crypto;
+
+const Base64Codec BASE64 = const Base64Codec();
+
+const List<int> _decodeTable =
+ const [ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -1, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, 0, -2, -2,
+ -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63,
+ -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2 ];
+
+const String _encodeTableUrlSafe =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+const String _encodeTable =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+const List<String> _URL_SAFE_CHARACTERS = const ['+', '/'];
+const List<String> _URL_UNSAFE_CHARACTERS = const ['-', '_'];
+
+const int _LINE_LENGTH = 76;
+const int _PAD = 61; // '='
+const int _CR = 13; // '\r'
+const int _LF = 10; // '\n'
+
+class Base64Codec extends Codec<List<int>, String> {
+
+ final bool _urlSafe;
+ final bool _addLineSeparator;
+
+ /**
+ * Instantiates a new [Base64Codec].
+ *
+ * The optional [urlSafe] argument specifies if [encoder] and [encode]
+ * should generate a string, that is safe to use in an URL.
+ *
+ * If [urlSafe] is `true` (and not overriden at the method invocation)
+ * the [encoder] and [encode] use '-' instead of '+' and '_' instead of '/'.
+ *
+ * The default value of [urlSafe] is `false`.
+ *
+ * The optional [addLineSeparator] argument specifies if the [encoder] and
+ * [encode] should add line separators.
+ *
+ * If `addLineSeparator` is `true` [encode] adds an
+ * optional line separator (CR + LF) for each 76 char output.
+ *
+ * The default value of [addLineSeparator] if `false`.
+ */
+ const Base64Codec({bool urlSafe: false, bool addLineSeparator: false})
+ : _urlSafe = urlSafe,
+ _addLineSeparator = addLineSeparator;
+
+ String get name => "base64";
+
+ String encode(List<int> bytes,
+ {bool urlSafe,
+ bool addLineSeparator}) {
+ if (urlSafe == null) urlSafe = _urlSafe;
+ if (addLineSeparator == null) addLineSeparator = _addLineSeparator;
+ return new Base64Encoder(urlSafe: urlSafe,
+ addLineSeparator: addLineSeparator).convert(bytes);
+
+
+ }
+
+ Base64Encoder get encoder => new Base64Encoder(
+ urlSafe: _urlSafe,
+ addLineSeparator: _addLineSeparator);
+
+ Base64Decoder get decoder => new Base64Decoder();
+
+}
+
+/**
+ * This class encodes byte strings (lists of unsigned
+ * 8-bit integers) to strings according to Base64.
+ */
+class Base64Encoder extends Converter<List<int>, String> {
+ final bool _urlSafe;
+ final bool _addLineSeparator;
+
+ /**
+ * Instantiates a new [Base64Encoder].
+ *
+ * The optional [urlSafe] argument specifies if [convert]
+ * should generate a string, that is safe to use in an URL.
+ *
+ * If it is `true` the [convert] use
+ * '-' instead of '+' and '_' instead of '/'.
+ *
+ * The default value of [urlSafe] is `false`.
+ *
+ * The optional [addLineSeparator] argument specifies if [convert]
+ * should add line separators.
+ *
+ * If it is `true` [convert] adds an optional line separator(CR + LF)
+ * for each 76 char output.
+ *
+ * The default value of [addLineSeparator] if `false`.
+ */
+ const Base64Encoder({bool urlSafe: false, bool addLineSeparator: false})
+ : _urlSafe = urlSafe,
+ _addLineSeparator = addLineSeparator;
+
+ /**
+ * Converts [bytes] to its Base64 representation as a string.
+ *
+ * if [start] and [end] are provided, only the sublist
+ * `bytes.sublist(start, end)` is converted.
+ */
+
+ String convert(List<int> bytes, [int start = 0, int end]) {
+ int bytes_length = bytes.length;
+ RangeError.checkValidRange(start, end, bytes_length);
+ if (end == null) end = bytes_length;
+ int length = end - start;
+ if (length == 0) {
+ return "";
+ }
+ final String lookup = _urlSafe ? _encodeTableUrlSafe : _encodeTable;
+ // Size of 24 bit chunks.
+ final int remainderLength = length.remainder(3);
+ final int chunkLength = length - remainderLength;
+ // Size of base output.
+ int baseOutputLength = ((length ~/ 3) * 4);
+ int remainderOutputLength = ((remainderLength > 0) ? 4 : 0);
+ int outputLength = baseOutputLength + remainderOutputLength;
+ // Add extra for line separators.
+ if (_addLineSeparator) {
+ outputLength += ((outputLength - 1) ~/ _LINE_LENGTH) << 1;
+ }
+ List<int> out = new List<int>(outputLength);
+
+ // Encode 24 bit chunks.
+ int j = 0, i = start, c = 0;
+ while (i < chunkLength) {
+ int x = ((bytes[i++] << 16) & 0x00FFFFFF) |
+ ((bytes[i++] << 8) & 0x00FFFFFF) |
+ bytes[i++];
+ out[j++] = lookup.codeUnitAt(x >> 18);
+ out[j++] = lookup.codeUnitAt((x >> 12) & 0x3F);
+ out[j++] = lookup.codeUnitAt((x >> 6) & 0x3F);
+ out[j++] = lookup.codeUnitAt(x & 0x3F);
+ // Add optional line separator for each 76 char output.
+ if (_addLineSeparator && ++c == 19 && j < outputLength - 2) {
+ out[j++] = _CR;
+ out[j++] = _LF;
+ c = 0;
+ }
+ }
+
+ // If input length if not a multiple of 3, encode remaining bytes and
+ // add padding.
+ if (remainderLength == 1) {
+ int x = bytes[i];
+ out[j++] = lookup.codeUnitAt(x >> 2);
+ out[j++] = lookup.codeUnitAt((x << 4) & 0x3F);
+ out[j++] = _PAD;
+ out[j++] = _PAD;
+ } else if (remainderLength == 2) {
+ int x = bytes[i];
+ int y = bytes[i + 1];
+ out[j++] = lookup.codeUnitAt(x >> 2);
+ out[j++] = lookup.codeUnitAt(((x << 4) | (y >> 4)) & 0x3F);
+ out[j++] = lookup.codeUnitAt((y << 2) & 0x3F);
+ out[j++] = _PAD;
+ }
+
+ return new String.fromCharCodes(out);
+ }
+
+ _Base64EncoderSink startChunkedConversion(Sink<String> sink) {
+ StringConversionSink stringSink;
+ if (sink is StringConversionSink) {
+ stringSink = sink;
+ } else {
+ stringSink = new StringConversionSink.from(sink);
+ }
+ return new _Base64EncoderSink(stringSink, _urlSafe, _addLineSeparator);
+ }
+}
+
+class _Base64EncoderSink extends ChunkedConversionSink<List<int>> {
+
+ final Base64Encoder _encoder;
+ final ChunkedConversionSink<String> _outSink;
+ final List<int> _buffer = new List<int>();
+ int _bufferCount = 0;
+
+ _Base64EncoderSink(this._outSink, urlSafe, addLineSeparator)
+ : _encoder = new Base64Encoder(urlSafe: urlSafe,
+ addLineSeparator: addLineSeparator);
+
+
+ void add(List<int> chunk) {
+ var nextBufferCount = (chunk.length + _bufferCount) % 3;
+
+ int decodableLength = _bufferCount + chunk.length - nextBufferCount;
+
+ if (_bufferCount + chunk.length > _buffer.length) {
+ _buffer.replaceRange(_bufferCount,
+ _buffer.length,
+ chunk.sublist(0, _buffer.length - _bufferCount));
+ _buffer.addAll(chunk.sublist(_buffer.length - _bufferCount));
+ } else {
+ _buffer.replaceRange(_bufferCount, _bufferCount + chunk.length, chunk);
+ }
+
+ _outSink.add(_encoder.convert(_buffer, 0, decodableLength));
+ _buffer.removeRange(0, decodableLength);
+ _bufferCount = nextBufferCount;
+ }
+
+ void close() {
+ if (_bufferCount > 0) {
+ _outSink.add(_encoder.convert(_buffer.sublist(0, _bufferCount)));
+ }
+ _outSink.close();
+ }
+}
+
+/**
+ * This class decodes strings to lists of bytes(lists of
+ * unsigned 8-bit integers) according to Base64.
+ */
+class Base64Decoder extends Converter<String, List<int>> {
+
+ /**
+ * Instantiates a new [Base64Decoder]
+ */
+ const Base64Decoder();
+
+ List<int> convert(String input, {bool alwaysPadding: false}) {
+ int length = input.length;
+ if (length == 0) {
+ return new List<int>(0);
+ }
+
+ // Count '\r', '\n' and illegal characters, check if
+ // '/', '+' / '-', '_' are used consistently, for illegal characters,
+ // throw an exception.
+ int extrasLength = 0;
+ bool expectedSafe = false;
+ bool expectedUnsafe = false;
+
+ for (int i = 0; i < length; i++) {
+ int c = _decodeTable[input.codeUnitAt(i)];
+ if (c < 0) {
+ extrasLength++;
+ if (c == -2) {
+ throw new FormatException('Invalid character', input, i);
+ }
+ } else if (input[i] == _URL_UNSAFE_CHARACTERS[0] ||
+ input[i] == _URL_UNSAFE_CHARACTERS[1]) {
+
+ if (expectedSafe) {
+ throw new FormatException('Unsafe character in URL-safe string',
+ input, i);
+ }
+ expectedUnsafe = true;
+ } else if (input[i] == _URL_SAFE_CHARACTERS[0] ||
+ input[i] == _URL_SAFE_CHARACTERS[1]) {
+ if (expectedUnsafe) {
+ throw new FormatException('Invalid character', input, i);
+ }
+ expectedSafe = true;
+ }
+ }
+
+ if ((length - extrasLength) % 4 != 0) {
+ throw new FormatException('''Size of Base 64 characters in Input
+ must be a multiple of 4''', input, length - extrasLength);
+ }
+
+ // Count pad characters.
+ int padLength = 0;
+ for (int i = length - 1; i >= 0; i--) {
+ int currentCodeUnit = input.codeUnitAt(i);
+ if (_decodeTable[currentCodeUnit] > 0) break;
+ if (currentCodeUnit == _PAD) padLength++;
+ }
+ int outputLength = (((length - extrasLength) * 6) >> 3) - padLength;
+ List<int> out = new List<int>(outputLength);
+
+ for (int i = 0, o = 0; o < outputLength; ) {
+ // Accumulate 4 valid 6 bit Base 64 characters into an int.
+ int x = 0;
+ for (int j = 4; j > 0; ) {
+ int c = _decodeTable[input.codeUnitAt(i++)];
+ if (c >= 0) {
+ x = ((x << 6) & 0x00FFFFFF) | c;
+ j--;
+ }
+ }
+ out[o++] = x >> 16;
+ if (o < outputLength) {
+ out[o++] = (x >> 8) & 0xFF;
+ if (o < outputLength) out[o++] = x & 0xFF;
+ }
+ }
+
+ return out;
+ }
+
+ _Base64DecoderSink startChunkedConversion(Sink<List<int>> sink) {
+ if (sink is! ByteConversionSink) {
+ sink = new ByteConversionSink.from(sink);
+ }
+ return new _Base64DecoderSink(sink);
+ }
+}
+
+
+class _Base64DecoderSink extends ChunkedConversionSink<String> {
+
+ final Base64Decoder _decoder = new Base64Decoder();
+ final ChunkedConversionSink<List<int>> _outSink;
+ String _buffer = "";
+ bool _isSafe = false;
+ bool _isUnsafe = false;
+
+ _Base64DecoderSink(this._outSink);
+
+ void add(String chunk) {
+ int nextBufferLength = (chunk.length + _buffer.length) % 4;
+
+ if (chunk.length + _buffer.length >= 4) {
+ int remainder = chunk.length - nextBufferLength;
+ String decodable = _buffer + chunk.substring(0, remainder);
+ _buffer = chunk.substring(remainder);
+
+ for (int i = 0;i < decodable.length; i++) {
+ if (decodable[i] == _URL_UNSAFE_CHARACTERS[0] ||
+ decodable[i] == _URL_UNSAFE_CHARACTERS[1]) {
+ if (_isSafe) {
+ throw new FormatException('Unsafe character in URL-safe string',
+ decodable, i);
+ }
+ _isUnsafe = true;
+ } else if (decodable[i] == _URL_SAFE_CHARACTERS[0] ||
+ decodable[i] == _URL_SAFE_CHARACTERS[1]) {
+ if (_isUnsafe) {
+ throw new FormatException('Invalid character', decodable, i);
+ }
+ _isSafe = true;
+ }
+ }
+
+ _outSink.add(_decoder.convert(decodable));
+ } else {
+ _buffer += chunk;
+ }
+ }
+
+ void close() {
+ if (!_buffer.isEmpty) {
+ throw new FormatException(
+ "Size of Base 64 input must be a multiple of 4",
+ _buffer,
+ _buffer.length);
+ }
+ _outSink.close();
+ }
+}
+
diff --git a/lib/src/crypto_utils.dart b/lib/src/crypto_utils.dart
index 515c1e9..7111d6f 100644
--- a/lib/src/crypto_utils.dart
+++ b/lib/src/crypto_utils.dart
@@ -13,148 +13,15 @@
return result.toString();
}
- static const int PAD = 61; // '='
- static const int CR = 13; // '\r'
- static const int LF = 10; // '\n'
- static const int LINE_LENGTH = 76;
-
- static const String _encodeTable =
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
- static const String _encodeTableUrlSafe =
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-
- // Lookup table used for finding Base 64 alphabet index of a given byte.
- // -2 : Outside Base 64 alphabet.
- // -1 : '\r' or '\n'
- // 0 : = (Padding character).
- // >0 : Base 64 alphabet index of given byte.
- static const List<int> _decodeTable =
- const [ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -1, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63,
- 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, 0, -2, -2,
- -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63,
- -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
- -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2 ];
-
static String bytesToBase64(List<int> bytes,
[bool urlSafe = false,
bool addLineSeparator = false]) {
- int len = bytes.length;
- if (len == 0) {
- return "";
- }
- final String lookup = urlSafe ? _encodeTableUrlSafe : _encodeTable;
- // Size of 24 bit chunks.
- final int remainderLength = len.remainder(3);
- final int chunkLength = len - remainderLength;
- // Size of base output.
- int outputLen = ((len ~/ 3) * 4) + ((remainderLength > 0) ? 4 : 0);
- // Add extra for line separators.
- if (addLineSeparator) {
- outputLen += ((outputLen - 1) ~/ LINE_LENGTH) << 1;
- }
- List<int> out = new List<int>(outputLen);
-
- // Encode 24 bit chunks.
- int j = 0, i = 0, c = 0;
- while (i < chunkLength) {
- int x = ((bytes[i++] << 16) & 0xFFFFFF) |
- ((bytes[i++] << 8) & 0xFFFFFF) |
- bytes[i++];
- out[j++] = lookup.codeUnitAt(x >> 18);
- out[j++] = lookup.codeUnitAt((x >> 12) & 0x3F);
- out[j++] = lookup.codeUnitAt((x >> 6) & 0x3F);
- out[j++] = lookup.codeUnitAt(x & 0x3f);
- // Add optional line separator for each 76 char output.
- if (addLineSeparator && ++c == 19 && j < outputLen - 2) {
- out[j++] = CR;
- out[j++] = LF;
- c = 0;
- }
- }
-
- // If input length if not a multiple of 3, encode remaining bytes and
- // add padding.
- if (remainderLength == 1) {
- int x = bytes[i];
- out[j++] = lookup.codeUnitAt(x >> 2);
- out[j++] = lookup.codeUnitAt((x << 4) & 0x3F);
- out[j++] = PAD;
- out[j++] = PAD;
- } else if (remainderLength == 2) {
- int x = bytes[i];
- int y = bytes[i + 1];
- out[j++] = lookup.codeUnitAt(x >> 2);
- out[j++] = lookup.codeUnitAt(((x << 4) | (y >> 4)) & 0x3F);
- out[j++] = lookup.codeUnitAt((y << 2) & 0x3F);
- out[j++] = PAD;
- }
-
- return new String.fromCharCodes(out);
+ return BASE64.encode(bytes,
+ urlSafe: urlSafe,
+ addLineSeparator: addLineSeparator);
}
static List<int> base64StringToBytes(String input) {
- int len = input.length;
- if (len == 0) {
- return new List<int>(0);
- }
-
- // Count '\r', '\n' and illegal characters, For illegal characters,
- // throw an exception.
- int extrasLen = 0;
- for (int i = 0; i < len; i++) {
- int c = _decodeTable[input.codeUnitAt(i)];
- if (c < 0) {
- extrasLen++;
- if (c == -2) {
- throw new FormatException('Invalid character: ${input[i]}');
- }
- }
- }
-
- if ((len - extrasLen) % 4 != 0) {
- throw new FormatException('''Size of Base 64 characters in Input
- must be a multiple of 4. Input: $input''');
- }
-
- // Count pad characters.
- int padLength = 0;
- for (int i = len - 1; i >= 0; i--) {
- int currentCodeUnit = input.codeUnitAt(i);
- if (_decodeTable[currentCodeUnit] > 0) break;
- if (currentCodeUnit == PAD) padLength++;
- }
- int outputLen = (((len - extrasLen) * 6) >> 3) - padLength;
- List<int> out = new List<int>(outputLen);
-
- for (int i = 0, o = 0; o < outputLen; ) {
- // Accumulate 4 valid 6 bit Base 64 characters into an int.
- int x = 0;
- for (int j = 4; j > 0; ) {
- int c = _decodeTable[input.codeUnitAt(i++)];
- if (c >= 0) {
- x = ((x << 6) & 0xFFFFFF) | c;
- j--;
- }
- }
- out[o++] = x >> 16;
- if (o < outputLen) {
- out[o++] = (x >> 8) & 0xFF;
- if (o < outputLen) out[o++] = x & 0xFF;
- }
- }
- return out;
+ return BASE64.decode(input);
}
-
}
diff --git a/test/base64_test.dart b/test/base64_test.dart
index b5647b0..725ac3f 100644
--- a/test/base64_test.dart
+++ b/test/base64_test.dart
@@ -6,6 +6,7 @@
library base64_test;
import 'dart:math';
+import 'dart:async';
import "package:crypto/crypto.dart";
import "package:test/test.dart";
@@ -16,7 +17,23 @@
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('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('old api', _testOldApi);
+ test('url safe streaming encoder/decoder', _testUrlSafeStreaming);
test('performance', _testPerformance);
+
+
}
// Data from http://tools.ietf.org/html/rfc4648.
@@ -24,6 +41,45 @@
const [ '', 'f', 'fo', 'foo', 'foob', 'fooba', 'foobar'];
const _RESULTS =
const [ '', 'Zg==', 'Zm8=', 'Zm9v', 'Zm9vYg==', 'Zm9vYmE=', 'Zm9vYmFy'];
+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];
+const _STREAMING_DECODER_INPUT_FOR_ZEROES =
+ const ['AAAA', 'AAA=', 'AA==', ''];
+var _STREAMING_DECODED_ZEROES = [0, 0, 0, 0, 0, 0];
+
+var _DECOMPOSITIONS_FOR_DECODING = [
+ ["A", "", "BCD"], ["A", "BCD", "", ""], ["A", "B", "", "", "CD", ""],
+ ["", "A", "BC", "", "D"], ["", "AB", "C", "", "", "D"], ["AB", "CD", ""],
+ ["", "ABC", "", "D"], ["", "ABC", "D", ""], ["", "", "ABCD", ""],
+ ["A", "B", "C", "D"], ["", "A", "B", "C", "D", ""],
+ ["", "A", "B", "", "", "C", "", "D", ""]];
+
+const _DECOMPOSITION_DECODED = const [0, 16, 131];
+
+var _DECOMPOSITIONS_FOR_ENCODING = [
+ [[196, 16], [], [158], [196]],
+ [[196, 16], [158, 196], [], []],
+ [[196], [], [16], [], [], [158], [], [196]],
+ [[196], [], [16], [158, 196], [], []],
+ [[], [196], [], [], [16, 158], [], [196]],
+ [[], [196], [16, 158, 196], []],
+ [[196, 16, 158], [], [], [196]],
+ [[196, 16, 158], [], [196], []],
+ [[196, 16, 158, 196], [], [], []]];
+
+const _DECOMPOSITION_ENCODED = 'xBCexA==';
+
+const _INCONSISTENT_SAFE_RESULT = 'A+_x';
+
+const _INCONSISTENT_SAFE_STREAMING_RESULT = const ['A+AAA', '_x='];
// Test data with only zeroes.
var inputsWithZeroes = [[0, 0, 0], [0, 0], [0], []];
@@ -61,52 +117,132 @@
void _testEncoder() {
for (var i = 0; i < _INPUTS.length; i++) {
- expect(CryptoUtils.bytesToBase64(_INPUTS[i].codeUnits), _RESULTS[i]);
+ expect(BASE64.encode(_INPUTS[i].codeUnits), _RESULTS[i]);
}
for (var i = 0; i < inputsWithZeroes.length; i++) {
- expect(CryptoUtils.bytesToBase64(inputsWithZeroes[i]),
- _RESULTS_WITH_ZEROS[i]);
+ expect(BASE64.encode(inputsWithZeroes[i]),
+ _RESULTS_WITH_ZEROS[i]);
}
- expect(
- CryptoUtils.bytesToBase64(_LONG_LINE.codeUnits, addLineSeparator : true),
- _LONG_LINE_RESULT);
- expect(CryptoUtils.bytesToBase64(_LONG_LINE.codeUnits),
- _LONG_LINE_RESULT_NO_BREAK);
+ expect(BASE64.encode(_LONG_LINE.codeUnits, addLineSeparator : true),
+ _LONG_LINE_RESULT);
+ expect(BASE64.encode(_LONG_LINE.codeUnits),
+ _LONG_LINE_RESULT_NO_BREAK);
}
void _testDecoder() {
for (var i = 0; i < _RESULTS.length; i++) {
expect(
- new String.fromCharCodes(CryptoUtils.base64StringToBytes(_RESULTS[i])),
+ new String.fromCharCodes(BASE64.decode(_RESULTS[i])),
_INPUTS[i]);
}
+
for (var i = 0; i < _RESULTS_WITH_ZEROS.length; i++) {
- expect(CryptoUtils.base64StringToBytes(_RESULTS_WITH_ZEROS[i]),
+ expect(BASE64.decode(_RESULTS_WITH_ZEROS[i]),
inputsWithZeroes[i]);
}
- var longLineDecoded = CryptoUtils.base64StringToBytes(_LONG_LINE_RESULT);
+
+ var longLineDecoded = BASE64.decode(_LONG_LINE_RESULT);
expect(new String.fromCharCodes(longLineDecoded), _LONG_LINE);
- var longLineResultNoBreak =
- CryptoUtils.base64StringToBytes(_LONG_LINE_RESULT);
+
+ var longLineResultNoBreak = BASE64.decode(_LONG_LINE_RESULT);
expect(new String.fromCharCodes(longLineResultNoBreak), _LONG_LINE);
}
+Future _testStreamingEncoder() async {
+ expect(
+ await new Stream.fromIterable(_STREAMING_ENCODER_INPUT)
+ .transform(BASE64.encoder)
+ .join(),
+ _STREAMING_ENCODED);
+}
+
+Future _testStreamingDecoder() async {
+ expect(
+ await new Stream.fromIterable(_STREAMING_DECODER_INPUT)
+ .transform(BASE64.decoder)
+ .expand((l) => l)
+ .toList(),
+ _STREAMING_DECODED);
+
+ expect(
+ await new Stream.fromIterable(_STREAMING_DECODER_INPUT_FOR_ZEROES)
+ .transform(BASE64.decoder)
+ .expand((l) => l)
+ .toList(),
+ _STREAMING_DECODED_ZEROES);
+}
+
+Future _testStreamingDecoderForMalformedInput() async {
+ expect(new Stream.fromIterable(['ABz'])
+ .transform(BASE64.decoder)
+ .toList(),
+ throwsFormatException);
+
+ expect(new Stream.fromIterable(['AB', 'Lx', 'z', 'xx'])
+ .transform(BASE64.decoder)
+ .toList(),
+ throwsFormatException);
+}
+
+Future _testStreamingEncoderForDecompositions() async {
+ for(var decomposition in _DECOMPOSITIONS_FOR_ENCODING) {
+ expect(
+ await new Stream.fromIterable(decomposition)
+ .transform(BASE64.encoder)
+ .join(),
+ _DECOMPOSITION_ENCODED);
+ }
+}
+
+Future _testStreamingDecoderForDecompositions() async {
+ for(var decomposition in _DECOMPOSITIONS_FOR_DECODING) {
+ expect(
+ await new Stream.fromIterable(decomposition)
+ .transform(BASE64.decoder)
+ .expand((x) => x)
+ .toList(),
+ _DECOMPOSITION_DECODED);
+ }
+}
+
void _testDecoderForMalformedInput() {
expect(() {
- CryptoUtils.base64StringToBytes('AB~');
+ BASE64.decode('AB~');
}, throwsFormatException);
expect(() {
- CryptoUtils.base64StringToBytes('A');
+ BASE64.decode('A');
}, throwsFormatException);
}
+Future _testUrlSafeStreaming() async {
+ String encUrlSafe = '-_A=';
+ List<List<int>> dec = [BASE64.decode('+/A=')];
+ var streamedResult = await new Stream.fromIterable(dec)
+ .transform(new Base64Encoder(urlSafe: true)).join();
+
+ expect(streamedResult, encUrlSafe);
+}
+
+void _testConsistentSafeUnsafeDecode() {
+ expect(() {
+ BASE64.decode(_INCONSISTENT_SAFE_RESULT);
+ }, throwsFormatException);
+}
+
+Future _testConsistentSafeUnsafeStreamDecode() {
+ expect(new Stream.fromIterable(_INCONSISTENT_SAFE_STREAMING_RESULT)
+ .transform(BASE64.decoder)
+ .toList(),
+ throwsFormatException);
+}
+
void _testUrlSafeEncodeDecode() {
- List<int> decUrlSafe = CryptoUtils.base64StringToBytes('-_A=');
- List<int> dec = CryptoUtils.base64StringToBytes('+/A=');
+ List<int> decUrlSafe = BASE64.decode('-_A=');
+ List<int> dec = BASE64.decode('+/A=');
expect(decUrlSafe, orderedEquals(dec));
- expect(CryptoUtils.bytesToBase64(dec, urlSafe: true), '-_A=');
- expect(CryptoUtils.bytesToBase64(dec), '+/A=');
+ expect(BASE64.encode(dec, urlSafe: true), '-_A=');
+ expect(BASE64.encode(dec), '+/A=');
}
void _testEncodeDecodeLists() {
@@ -116,8 +252,8 @@
for (int k = 0; k < i; k++) {
x[k] = j;
}
- var enc = CryptoUtils.bytesToBase64(x);
- var dec = CryptoUtils.base64StringToBytes(enc);
+ var enc = BASE64.encode(x);
+ var dec = BASE64.decode(enc);
expect(dec, orderedEquals(x));
}
}
@@ -130,6 +266,13 @@
}
}
+void _testOldApi() {
+ for (int i = 0; i < _INPUTS.length; i++) {
+ expect(CryptoUtils.bytesToBase64(_INPUTS[i].codeUnits), _RESULTS[i]);
+ expect(CryptoUtils.base64StringToBytes(_RESULTS[i]), _INPUTS[i].codeUnits);
+ }
+}
+
void _testPerformance() {
var l = new List<int>(1024);
var iters = 5000;
@@ -137,17 +280,17 @@
String enc;
var w = new Stopwatch()..start();
for( int i = 0; i < iters; ++i ) {
- enc = CryptoUtils.bytesToBase64(l);
+ enc = BASE64.encode(l);
}
int ms = w.elapsedMilliseconds;
int perSec = (iters * l.length) * 1000 ~/ ms;
// print("Encode 1024 bytes for $iters times: $ms msec. $perSec b/s");
w..reset();
for( int i = 0; i < iters; ++i ) {
- CryptoUtils.base64StringToBytes(enc);
+ BASE64.decode(enc);
}
ms = w.elapsedMilliseconds;
perSec = (iters * l.length) * 1000 ~/ ms;
- // print('''Decode into ${l.length} bytes for $iters
+ // ('''Decode into ${l.length} bytes for $iters
// times: $ms msec. $perSec b/s''');
}
