/*
* Copyright (C) 2012 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.common.io;
import static com.google.common.io.BaseEncoding.base16;
import static com.google.common.io.BaseEncoding.base32;
import static com.google.common.io.BaseEncoding.base32Hex;
import static com.google.common.io.BaseEncoding.base64;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Ascii;
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.io.BaseEncoding.DecodingException;
import junit.framework.TestCase;
import java.io.UnsupportedEncodingException;
/**
* Tests for {@code BaseEncoding}.
*
* @author Louis Wasserman
*/
@GwtCompatible(emulated = true)
public class BaseEncodingTest extends TestCase {
public static void assertEquals(byte[] expected, byte[] actual) {
assertEquals(expected.length, actual.length);
for (int i = 0; i < expected.length; i++) {
assertEquals(expected[i], actual[i]);
}
}
public void testSeparatorsExplicitly() {
testEncodes(base64().withSeparator("\n", 3), "foobar", "Zm9\nvYm\nFy");
testEncodes(base64().withSeparator("$", 4), "foobar", "Zm9v$YmFy");
testEncodes(base32().withSeparator("*", 4), "foobar", "MZXW*6YTB*OI==*====");
}
@SuppressWarnings("ReturnValueIgnored")
public void testSeparatorSameAsPadChar() {
try {
base64().withSeparator("=", 3);
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {}
try {
base64().withPadChar('#').withSeparator("!#!", 3);
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {}
}
@SuppressWarnings("ReturnValueIgnored")
public void testAtMostOneSeparator() {
BaseEncoding separated = base64().withSeparator("\n", 3);
try {
separated.withSeparator("$", 4);
fail("Expected UnsupportedOperationException");
} catch (UnsupportedOperationException expected) {}
}
public void testBase64() {
// The following test vectors are specified in RFC 4648 itself
testEncodingWithSeparators(base64(), "", "");
testEncodingWithSeparators(base64(), "f", "Zg==");
testEncodingWithSeparators(base64(), "fo", "Zm8=");
testEncodingWithSeparators(base64(), "foo", "Zm9v");
testEncodingWithSeparators(base64(), "foob", "Zm9vYg==");
testEncodingWithSeparators(base64(), "fooba", "Zm9vYmE=");
testEncodingWithSeparators(base64(), "foobar", "Zm9vYmFy");
}
public void testBase64LenientPadding() {
testDecodes(base64(), "Zg", "f");
testDecodes(base64(), "Zg=", "f");
testDecodes(base64(), "Zg==", "f"); // proper padding length
testDecodes(base64(), "Zg===", "f");
testDecodes(base64(), "Zg====", "f");
}
public void testBase64InvalidDecodings() {
// These contain bytes not in the decodabet.
assertFailsToDecode(base64(), "\u007f");
assertFailsToDecode(base64(), "Wf2!");
// This sentence just isn't base64() encoded.
assertFailsToDecode(base64(), "let's not talk of love or chains!");
// A 4n+1 length string is never legal base64().
assertFailsToDecode(base64(), "12345");
}
@SuppressWarnings("ReturnValueIgnored")
public void testBase64CannotUpperCase() {
try {
base64().upperCase();
fail();
} catch (IllegalStateException expected) {
// success
}
}
@SuppressWarnings("ReturnValueIgnored")
public void testBase64CannotLowerCase() {
try {
base64().lowerCase();
fail();
} catch (IllegalStateException expected) {
// success
}
}
public void testBase64AlternatePadding() {
BaseEncoding enc = base64().withPadChar('~');
testEncodingWithSeparators(enc, "", "");
testEncodingWithSeparators(enc, "f", "Zg~~");
testEncodingWithSeparators(enc, "fo", "Zm8~");
testEncodingWithSeparators(enc, "foo", "Zm9v");
testEncodingWithSeparators(enc, "foob", "Zm9vYg~~");
testEncodingWithSeparators(enc, "fooba", "Zm9vYmE~");
testEncodingWithSeparators(enc, "foobar", "Zm9vYmFy");
}
public void testBase64OmitPadding() {
BaseEncoding enc = base64().omitPadding();
testEncodingWithSeparators(enc, "", "");
testEncodingWithSeparators(enc, "f", "Zg");
testEncodingWithSeparators(enc, "fo", "Zm8");
testEncodingWithSeparators(enc, "foo", "Zm9v");
testEncodingWithSeparators(enc, "foob", "Zm9vYg");
testEncodingWithSeparators(enc, "fooba", "Zm9vYmE");
testEncodingWithSeparators(enc, "foobar", "Zm9vYmFy");
}
public void testBase32() {
// The following test vectors are specified in RFC 4648 itself
testEncodingWithCasing(base32(), "", "");
testEncodingWithCasing(base32(), "f", "MY======");
testEncodingWithCasing(base32(), "fo", "MZXQ====");
testEncodingWithCasing(base32(), "foo", "MZXW6===");
testEncodingWithCasing(base32(), "foob", "MZXW6YQ=");
testEncodingWithCasing(base32(), "fooba", "MZXW6YTB");
testEncodingWithCasing(base32(), "foobar", "MZXW6YTBOI======");
}
public void testBase32LenientPadding() {
testDecodes(base32(), "MZXW6", "foo");
testDecodes(base32(), "MZXW6=", "foo");
testDecodes(base32(), "MZXW6==", "foo");
testDecodes(base32(), "MZXW6===", "foo"); // proper padding length
testDecodes(base32(), "MZXW6====", "foo");
testDecodes(base32(), "MZXW6=====", "foo");
}
public void testBase32AlternatePadding() {
BaseEncoding enc = base32().withPadChar('~');
testEncodingWithCasing(enc, "", "");
testEncodingWithCasing(enc, "f", "MY~~~~~~");
testEncodingWithCasing(enc, "fo", "MZXQ~~~~");
testEncodingWithCasing(enc, "foo", "MZXW6~~~");
testEncodingWithCasing(enc, "foob", "MZXW6YQ~");
testEncodingWithCasing(enc, "fooba", "MZXW6YTB");
testEncodingWithCasing(enc, "foobar", "MZXW6YTBOI~~~~~~");
}
public void testBase32InvalidDecodings() {
// These contain bytes not in the decodabet.
assertFailsToDecode(base32(), "\u007f");
assertFailsToDecode(base32(), "Wf2!");
// This sentence just isn't base32() encoded.
assertFailsToDecode(base32(), "let's not talk of love or chains!");
// An 8n+{1,3,6} length string is never legal base32.
assertFailsToDecode(base32(), "A");
assertFailsToDecode(base32(), "ABC");
assertFailsToDecode(base32(), "ABCDEF");
}
public void testBase32UpperCaseIsNoOp() {
assertSame(base32(), base32().upperCase());
}
public void testBase32Hex() {
// The following test vectors are specified in RFC 4648 itself
testEncodingWithCasing(base32Hex(), "", "");
testEncodingWithCasing(base32Hex(), "f", "CO======");
testEncodingWithCasing(base32Hex(), "fo", "CPNG====");
testEncodingWithCasing(base32Hex(), "foo", "CPNMU===");
testEncodingWithCasing(base32Hex(), "foob", "CPNMUOG=");
testEncodingWithCasing(base32Hex(), "fooba", "CPNMUOJ1");
testEncodingWithCasing(base32Hex(), "foobar", "CPNMUOJ1E8======");
}
public void testBase32HexLenientPadding() {
testDecodes(base32Hex(), "CPNMU", "foo");
testDecodes(base32Hex(), "CPNMU=", "foo");
testDecodes(base32Hex(), "CPNMU==", "foo");
testDecodes(base32Hex(), "CPNMU===", "foo"); // proper padding length
testDecodes(base32Hex(), "CPNMU====", "foo");
testDecodes(base32Hex(), "CPNMU=====", "foo");
}
public void testBase32HexInvalidDecodings() {
// These contain bytes not in the decodabet.
assertFailsToDecode(base32Hex(), "\u007f");
assertFailsToDecode(base32Hex(), "Wf2!");
// This sentence just isn't base32 encoded.
assertFailsToDecode(base32Hex(), "let's not talk of love or chains!");
// An 8n+{1,3,6} length string is never legal base32.
assertFailsToDecode(base32Hex(), "A");
assertFailsToDecode(base32Hex(), "ABC");
assertFailsToDecode(base32Hex(), "ABCDEF");
}
public void testBase32HexUpperCaseIsNoOp() {
assertSame(base32Hex(), base32Hex().upperCase());
}
public void testBase16() {
testEncodingWithCasing(base16(), "", "");
testEncodingWithCasing(base16(), "f", "66");
testEncodingWithCasing(base16(), "fo", "666F");
testEncodingWithCasing(base16(), "foo", "666F6F");
testEncodingWithCasing(base16(), "foob", "666F6F62");
testEncodingWithCasing(base16(), "fooba", "666F6F6261");
testEncodingWithCasing(base16(), "foobar", "666F6F626172");
}
public void testBase16UpperCaseIsNoOp() {
assertSame(base16(), base16().upperCase());
}
private static void testEncodingWithCasing(
BaseEncoding encoding, String decoded, String encoded) {
testEncodingWithSeparators(encoding, decoded, encoded);
testEncodingWithSeparators(encoding.upperCase(), decoded, Ascii.toUpperCase(encoded));
testEncodingWithSeparators(encoding.lowerCase(), decoded, Ascii.toLowerCase(encoded));
}
private static void testEncodingWithSeparators(
BaseEncoding encoding, String decoded, String encoded) {
testEncoding(encoding, decoded, encoded);
// test separators work
for (int sepLength = 3; sepLength <= 5; sepLength++) {
for (String separator : ImmutableList.of(",", "\n", ";;", "")) {
testEncoding(encoding.withSeparator(separator, sepLength), decoded,
Joiner.on(separator).join(Splitter.fixedLength(sepLength).split(encoded)));
}
}
}
private static void testEncoding(BaseEncoding encoding, String decoded, String encoded) {
testEncodes(encoding, decoded, encoded);
testDecodes(encoding, encoded, decoded);
}
private static void testEncodes(BaseEncoding encoding, String decoded, String encoded) {
byte[] bytes;
try {
// GWT does not support String.getBytes(Charset)
bytes = decoded.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
throw new AssertionError();
}
assertEquals(encoded, encoding.encode(bytes));
}
private static void testDecodes(BaseEncoding encoding, String encoded, String decoded) {
byte[] bytes;
try {
// GWT does not support String.getBytes(Charset)
bytes = decoded.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
throw new AssertionError();
}
assertEquals(bytes, encoding.decode(encoded));
}
private static void assertFailsToDecode(BaseEncoding encoding, String cannotDecode) {
try {
encoding.decode(cannotDecode);
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {
// success
}
try {
encoding.decodeChecked(cannotDecode);
fail("Expected DecodingException");
} catch (DecodingException expected) {
// success
}
}
public void testToString() {
assertEquals("BaseEncoding.base64().withPadChar(=)", BaseEncoding.base64().toString());
assertEquals("BaseEncoding.base32Hex().omitPadding()",
BaseEncoding.base32Hex().omitPadding().toString());
assertEquals("BaseEncoding.base32().lowerCase().withPadChar($)",
BaseEncoding.base32().lowerCase().withPadChar('$').toString());
assertEquals("BaseEncoding.base16().withSeparator(\"\n\", 10)",
BaseEncoding.base16().withSeparator("\n", 10).toString());
}
}