diff options
Diffstat (limited to 'guava-gwt/test-super/com/google/common/io/super/com/google/common/io/BaseEncodingTest.java')
| -rw-r--r-- | guava-gwt/test-super/com/google/common/io/super/com/google/common/io/BaseEncodingTest.java | 315 |
1 files changed, 315 insertions, 0 deletions
diff --git a/guava-gwt/test-super/com/google/common/io/super/com/google/common/io/BaseEncodingTest.java b/guava-gwt/test-super/com/google/common/io/super/com/google/common/io/BaseEncodingTest.java new file mode 100644 index 000000000..cbfa51fad --- /dev/null +++ b/guava-gwt/test-super/com/google/common/io/super/com/google/common/io/BaseEncodingTest.java @@ -0,0 +1,315 @@ +/* + * 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()); + } +} + |