@Override protected String getEncodedValue(String value, boolean omitPadding) { BaseEncoding encoding = BaseEncoding.base32(); encoding = omitPadding ? encoding.omitPadding() : encoding; return new String(encoding.decode(value), StandardCharsets.UTF_8); }
public void testToString() { assertEquals("BaseEncoding.base64().withPadChar('=')", base64().toString()); assertEquals("BaseEncoding.base32Hex().omitPadding()", base32Hex().omitPadding().toString()); assertEquals( "BaseEncoding.base32().lowerCase().withPadChar('$')", base32().lowerCase().withPadChar('$').toString()); assertEquals( "BaseEncoding.base16().withSeparator(\"\n\", 10)", base16().withSeparator("\n", 10).toString()); } }
@Override protected String getEncodedValue(String value, boolean omitPadding) { BaseEncoding encoding = BaseEncoding.base32(); encoding = omitPadding ? encoding.omitPadding() : encoding; return encoding.encode(value.getBytes(StandardCharsets.UTF_8)); }
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 testBase32Offset() { testEncodesWithOffset(base32(), "foobar", 0, 6, "MZXW6YTBOI======"); testEncodesWithOffset(base32(), "foobar", 1, 5, "N5XWEYLS"); testEncodesWithOffset(base32(), "foobar", 2, 3, "N5RGC==="); testEncodesWithOffset(base32(), "foobar", 3, 1, "MI======"); testEncodesWithOffset(base32(), "foobar", 4, 0, ""); }
@GwtIncompatible // Reader/Writer public void testBase32Streaming() throws IOException { // The following test vectors are specified in RFC 4648 itself testStreamingEncodingWithCasing(base32(), "", ""); testStreamingEncodingWithCasing(base32(), "f", "MY======"); testStreamingEncodingWithCasing(base32(), "fo", "MZXQ===="); testStreamingEncodingWithCasing(base32(), "foo", "MZXW6==="); testStreamingEncodingWithCasing(base32(), "foob", "MZXW6YQ="); testStreamingEncodingWithCasing(base32(), "fooba", "MZXW6YTB"); testStreamingEncodingWithCasing(base32(), "foobar", "MZXW6YTBOI======"); }
public void testBase32InvalidDecodings() { // These contain bytes not in the decodabet. assertFailsToDecode(base32(), "A ", "Unrecognized character: 0x20"); assertFailsToDecode(base32(), "Wf2!", "Unrecognized character: f"); // 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", "Invalid input length 1"); assertFailsToDecode(base32(), "ABC"); assertFailsToDecode(base32(), "ABCDEF"); // These have a combination of invalid length, unrecognized characters and wrong padding. assertFailsToDecode(base32(), "AB=C", "Unrecognized character: ="); assertFailsToDecode(base32(), "A=BCDE", "Invalid input length 6"); assertFailsToDecode(base32(), "?", "Invalid input length 1"); }
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==*===="); }
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~~~~~~"); }
String hashTableName(String rawName) { // Take 40 bits from the raw name byte[] bytes = Hashing.murmur3_128().hashString(rawName, StandardCharsets.UTF_8).asBytes(); return BaseEncoding.base32().omitPadding().encode(bytes); }
/** * Initiate a new instance of BDXL lookup functionality. * * @param prefix Value attached in front of calculated hash. * @param hostname Hostname used as base for lookup. * @param digestAlgorithm Algorithm used for generation of hostname. */ public BdxlLocator(String prefix, String hostname, String digestAlgorithm) { this(prefix, hostname, digestAlgorithm, BaseEncoding.base32()); }
/** * Generates a secret string. Used typically as a key for password resets, for account validation. * * @return the generated key; */ private String generateSecret() { byte[] buffer = new byte[32]; new SecureRandom().nextBytes(buffer); return BaseEncoding.base32().omitPadding().lowerCase().encode(buffer); }
/** * Generate a new string of a default length (5) with characters from Base32 encoding. * * @return New string with Base32 characters of a given length. */ private String generateBase32Token() { byte[] randomBytes = keyGenerator.generateRandomBytes(BASE32_KEY_LENGTH); return BaseEncoding.base32().omitPadding().encode(randomBytes).substring(0, BASE32_KEY_LENGTH); }
private static String randomTag() { byte[] bytes = new byte[8]; ThreadLocalRandom.current().nextBytes(bytes); return BaseEncoding.base32().omitPadding().encode(bytes); }
private static String toId(String type, UUID uuid) { Writer idWriter = new StringWriter(); try (OutputStream buildStream = BaseEncoding.base32().omitPadding().encodingStream(idWriter)) { buildStream.write(Longs.toByteArray(uuid.getMostSignificantBits())); buildStream.write(Longs.toByteArray(uuid.getLeastSignificantBits())); buildStream.write(type.getBytes(Charsets.UTF_8)); } catch (IOException e) { throw Throwables.propagate(e); // Won't happen, StringWriter won't throw IOException } return idWriter.toString(); }
public void testBase32Offset() { testEncodesWithOffset(base32(), "foobar", 0, 6, "MZXW6YTBOI======"); testEncodesWithOffset(base32(), "foobar", 1, 5, "N5XWEYLS"); testEncodesWithOffset(base32(), "foobar", 2, 3, "N5RGC==="); testEncodesWithOffset(base32(), "foobar", 3, 1, "MI======"); testEncodesWithOffset(base32(), "foobar", 4, 0, ""); }
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~~~~~~"); }