features;
/**
- * Create a new {@link Hashids} builder.
+ * Constructs a new instance without a salt, no minimum hash length, the {@link #DEFAULT_ALPHABET default alphabet} and no enabled
+ * {@link HashidsFeature features}.
*/
public Builder() {
- this.salt = "";
+ this.salt = new char[0];
this.alphabet = DEFAULT_ALPHABET;
- this.separators = DEFAULT_SEPARATORS;
- this.minHashLength = 0;
- }
-
- private Builder(String salt, String alphabet, String separators, int minHashLength) {
- this.salt = salt;
- this.alphabet = alphabet;
- this.separators = separators;
- this.minHashLength = minHashLength;
+ this.minLength = 0;
+ this.features = EnumSet.noneOf(HashidsFeature.class);
}
/**
- * Sets the salt string.
+ * Sets the salt to be used as entropy.
+ *
+ * By default the salt is empty.
*
- * @param salt The string to use as salt
- * @return The builder instance with the specified salt
+ * @param salt the salt to be used as entropy
+ * @return a new builder instance with the given salt
*/
- public Builder salt(String salt) {
- return new Builder(salt, alphabet, separators, minHashLength);
+ public Builder salt(final String salt) {
+ this.salt = salt.toCharArray();
+ return this;
}
/**
- * Sets the custom alphabet string.
+ * Sets the minimum hash length.
*
- * @param alphabet The string to use as custom alphabet
- * @return The builder instance with the specified custom alphabet
+ *
The default value is {@code 0}.
+ *
+ * @param minLength the minimum hash length
+ * @return a new builder instance with the given minimum hash length
*/
- public Builder alphabet(String alphabet) {
- return new Builder(salt, alphabet, separators, minHashLength);
+ public Builder minLength(final int minLength) {
+ this.minLength = minLength;
+ return this;
}
/**
- * Sets the custom separators string.
+ * Sets the alphabet to be used for the hash generation.
+ *
+ *
The default value is the {@link #DEFAULT_ALPHABET default alphabet}.
*
- * @param separators The string to use as custom alphabet
- * @return The builder instance with the specified custom separators
+ * @param alphabet the alphabet to be used for the hash generation
+ * @return a new builder instance with the given alphabet
*/
- public Builder separators(String separators) {
- return new Builder(salt, alphabet, separators, minHashLength);
+ public Builder alphabet(final String alphabet) {
+ this.alphabet = alphabet.toCharArray();
+ return this;
}
/**
- * Sets the minimum hash length.
+ * Enables the given instance {@link HashidsFeature features}.
*
- * @param minHashLength The minimum length of the hash
- * @return The builder instance with the minimum hash length
+ *
By default no features are enabled.
+ *
+ * @param features the features to be enabled for this instance
+ * @return a new builder instance with the enabled features
+ * @since 0.4.0
*/
- public Builder minHashLength(int minHashLength) {
- return new Builder(salt, alphabet, separators, minHashLength);
+ public Builder features(final HashidsFeature... features) {
+ this.features.addAll(Arrays.asList(features));
+ return this;
}
/**
- * Builds the {@link Hashids}.
+ * Builds a new configured {@link Hashids} instance.
*
- * @return The {@link Hashids} instance
+ * @return a new configured instance
*/
public Hashids build() {
- return new Hashids(salt, minHashLength, alphabet, separators);
+ return new Hashids(salt, minLength, alphabet, features);
}
}
/**
- * Encode number(s).
+ * Encodes the given positive numbers based on this instance configuration.
+ *
+ *
The given numbers size must not be larger than the {@link #MAX_INTEROP_NUMBER_SIZE maximum interoperability size} unless the
+ * {@link HashidsFeature#NO_MAX_INTEROP_NUMBER_SIZE NO_MAX_INTEROP_NUMBER_SIZE} feature is enabled. Please
+ * note that this will break the interoperability with the origin algorithm implementation!
*
- * @param numbers the number(s) to encode
- * @return the Hashid instance with the number(s) and the encoded string
+ * @param numbers the positive numbers to be encoded
+ * @return the resultant hash of the encoding of the numbers, empty otherwise
+ * @throws IllegalArgumentException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the total length of
+ * numbers is zero, any numbers size is invalid or larger than the {@link #MAX_INTEROP_NUMBER_SIZE maximum interoperability size}
+ * @throws NullPointerException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the given numbers are {@code null}
*/
- public Hashid encode(long... numbers) {
- if (numbers.length == 0) {
- return Hashid.EMPTY;
+ public String encode(final long... numbers) {
+ if (numbers == null) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new NullPointerException("numbers must not be null!");
+ }
+ return "";
}
- return doEncode(numbers);
- }
- /**
- * Encode number(s) to string.
- *
- * @param numbers the number(s) to encode
- * @return the encoded string
- */
- public String encodeToString(long... numbers) {
if (numbers.length == 0) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new IllegalArgumentException("length of numbers must be greater than or equal to one!");
+ }
return "";
}
- return encode(numbers).toString();
+
+ for (long number : numbers) {
+ if (number < 0) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new IllegalArgumentException("number must not be less than zero: " + number);
+ }
+ return "";
+ }
+
+ if (number > MAX_INTEROP_NUMBER_SIZE && !features.contains(HashidsFeature.NO_MAX_INTEROP_NUMBER_SIZE)) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new IllegalArgumentException("number must not exceed the maximum number size: " + number + " > " + MAX_INTEROP_NUMBER_SIZE);
+ }
+ return "";
+ }
+ }
+
+ final char[] currentAlphabet = Arrays.copyOf(alphabet, alphabet.length);
+
+ // Determine the lottery number
+ final long lotteryId = LongStream.range(0, numbers.length)
+ .reduce(0, (state, idx) -> state + numbers[(int) idx] % (idx + LOTTERY_MOD));
+ final char lottery = currentAlphabet[(int) (lotteryId % currentAlphabet.length)];
+
+ // Encode each number
+ final StringBuilder global = new StringBuilder();
+ IntStream.range(0, numbers.length)
+ .forEach(idx -> {
+ deriveNewAlphabet(currentAlphabet, salt, lottery);
+ final int initialLength = global.length();
+ transform(numbers[idx], currentAlphabet, global, initialLength);
+ // Append the separator
+ if (idx + 1 < numbers.length) {
+ long n = numbers[idx] % (global.charAt(initialLength) + idx);
+ global.append(separators[(int) (n % separators.length)]);
+ }
+ });
+
+ // Prepend the lottery
+ global.insert(0, lottery);
+
+ // Add the guards if there is any space left
+ if (minLength > global.length()) {
+ int guardIdx = (int) ((lotteryId + lottery) % guards.length);
+ global.insert(0, guards[guardIdx]);
+ if (minLength > global.length()) {
+ guardIdx = (int) ((lotteryId + global.charAt(2)) % guards.length);
+ global.append(guards[guardIdx]);
+ }
+ }
+
+ // Add the necessary padding
+ int paddingLeft = minLength - global.length();
+ while (paddingLeft > 0) {
+ shuffle(currentAlphabet, Arrays.copyOf(currentAlphabet, currentAlphabet.length));
+
+ final int alphabetHalfSize = currentAlphabet.length / 2;
+ final int initialSize = global.length();
+ if (paddingLeft > currentAlphabet.length) {
+ int offset = alphabetHalfSize + (currentAlphabet.length % 2 == 0 ? 0 : 1);
+
+ global.insert(0, currentAlphabet, alphabetHalfSize, offset);
+ global.insert(offset + initialSize, currentAlphabet, 0, alphabetHalfSize);
+
+ paddingLeft -= currentAlphabet.length;
+ } else {
+ // Calculate the excess
+ final int excess = currentAlphabet.length + global.length() - minLength;
+ final int secondHalfStartOffset = alphabetHalfSize + Math.floorDiv(excess, 2);
+ final int secondHalfLength = currentAlphabet.length - secondHalfStartOffset;
+ final int firstHalfLength = paddingLeft - secondHalfLength;
+
+ global.insert(0, currentAlphabet, secondHalfStartOffset, secondHalfLength);
+ global.insert(secondHalfLength + initialSize, currentAlphabet, 0, firstHalfLength);
+
+ paddingLeft = 0;
+ }
+ }
+
+ return global.toString();
}
/**
- * Encode number(s) to string.
+ * Encodes the given numbers in hexadecimal format based on this instance configuration.
*
- * @param numbers the number(s) to encode
- * @return the encoded string
+ *
The given hexadecimal numbers must not be prefixed ({@code 0x} or {@code 0X}) unless the
+ * {@link HashidsFeature#ALLOW_HEXADECIMAL_NUMBER_PREFIX ALLOW_HEXADECIMAL_NUMBER_PREFIX} feature is enabled. Please
+ * note that this will break the interoperability with the origin algorithm implementation!
+ *
+ * @param hexNumbers the numbers in hexadecimal format to be encoded
+ * @return the resultant hash of the encoding of the hexadecimal numbers, empty otherwise
+ * @throws IllegalArgumentException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and any of the numbers is invalid
+ * @throws NullPointerException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the given numbers are {@code null}
*/
- public String encodeToString(int... numbers) {
- if (numbers.length == 0) {
+ public String encodeHex(final String hexNumbers) {
+ if (hexNumbers == null) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new NullPointerException("hexNumbers must not be null!");
+ }
+ return "";
+ }
+
+ final String hex;
+ if (hexNumbers.startsWith("0x") || hexNumbers.startsWith("0X")) {
+ if (features.contains(HashidsFeature.ALLOW_HEXADECIMAL_NUMBER_PREFIX)) {
+ hex = hexNumbers.substring(2);
+ } else {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new IllegalArgumentException("numbers must not contain a hexadecimal prefix: " + hexNumbers.substring(0, 2));
+ }
+ return "";
+ }
+ } else {
+ hex = hexNumbers;
+ }
+
+ if (!HEX_FORMAT_PATTERN.matcher(hex).matches()) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new IllegalArgumentException("hexNumbers must be a valid hexadecimal number!");
+ }
return "";
}
- long[] longs = new long[numbers.length];
- for (int idx = 0; idx < numbers.length; idx++) {
- longs[idx] = numbers[idx];
+ // Resolve the associated long value and encode it
+ LongStream values = LongStream.empty();
+ final Matcher matcher = HEX_VALUES_PATTERN.matcher(hex);
+ while (matcher.find()) {
+ final long value = new BigInteger("1" + matcher.group(), 16).longValue();
+ values = LongStream.concat(values, LongStream.of(value));
}
- return doEncode(longs).toString();
+
+ return encode(values.toArray());
}
/**
- * Encode an hexadecimal string to string.
+ * Decodes the given hash into its numeric representation based on this instance configuration.
*
- * @param hex the hexadecimal string to encode
- * @return the encoded string
+ * @param hash the hash to be decoded
+ * @return an array of long values with each numeric number present in the hash, empty otherwise
+ * @throws IllegalArgumentException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the hash is invalid
+ * @throws NullPointerException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the given hash is {@code null}
*/
- public String encodeHex(String hex) {
- if (!PATTERN_ENCODE_HEX.matcher(hex).matches()) {
- throw new IllegalArgumentException(String.format("%s is not a hex string", hex));
+ public long[] decode(final String hash) {
+ if (hash == null) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new NullPointerException("hash must not be null!");
+ }
+ return new long[0];
}
- Matcher matcher = Pattern.compile("[\\w\\W]{1,12}").matcher(hex);
- List matched = new ArrayList<>();
- while (matcher.find()) {
- matched.add(Long.parseLong("1" + matcher.group(), 16));
+
+ // Validate that the hash only consists of valid characters
+ final Set validInputChars = new HashSet<>(alphabet.length + guards.length + separators.length);
+ Stream.of(alphabet, guards, separators)
+ .forEach(chars -> IntStream.range(0, chars.length)
+ .mapToObj(idx -> chars[idx])
+ .forEach(validInputChars::add));
+ if (!IntStream.range(0, hash.length()).allMatch(idx -> validInputChars.contains(hash.charAt(idx)))) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new IllegalArgumentException("invalid hash: " + hash);
+ }
+ return new long[0];
}
- return doEncode(toArray(matched)).toString();
+
+ // Create a set of the guards and count the total amount
+ final Set guardsSet = IntStream.range(0, guards.length)
+ .mapToObj(idx -> guards[idx])
+ .collect(toSet());
+ final int[] guardsIdx = IntStream.range(0, hash.length())
+ .filter(idx -> guardsSet.contains(hash.charAt(idx)))
+ .toArray();
+
+ // Calculate the start- and end index based on the guards count
+ final int startIdx;
+ final int endIdx;
+ if (guardsIdx.length > 0) {
+ startIdx = guardsIdx[0] + 1;
+ endIdx = guardsIdx.length > 1 ? guardsIdx[1] : hash.length();
+ } else {
+ startIdx = 0;
+ endIdx = hash.length();
+ }
+
+ LongStream decoded = LongStream.empty();
+ if (hash.length() > 0) {
+ final char lottery = hash.charAt(startIdx);
+
+ // Create the initial accumulation string
+ final int length = hash.length() - guardsIdx.length - 1;
+ StringBuilder block = new StringBuilder(length);
+
+ // Create the base salt
+ final char[] decodeSalt = new char[alphabet.length];
+ decodeSalt[0] = lottery;
+ final int saltLength = salt.length >= alphabet.length ? alphabet.length - 1 : salt.length;
+ System.arraycopy(salt, 0, decodeSalt, 1, saltLength);
+ final int saltLeft = alphabet.length - saltLength - 1;
+
+ final char[] currentAlphabet = Arrays.copyOf(alphabet, alphabet.length);
+
+ for (int i = startIdx + 1; i < endIdx; i++) {
+ if (!separatorsSet.contains(hash.charAt(i))) {
+ block.append(hash.charAt(i));
+ if (i < endIdx - 1) {
+ continue;
+ }
+ }
+
+ if (block.length() > 0) {
+ // Create the salt
+ if (saltLeft > 0) {
+ System.arraycopy(currentAlphabet, 0, decodeSalt, alphabet.length - saltLeft, saltLeft);
+ }
+
+ // Prepend the decoded value and create a new block
+ shuffle(currentAlphabet, decodeSalt);
+ final long number = transform(block.toString().toCharArray(), currentAlphabet);
+ decoded = LongStream.concat(decoded, LongStream.of(number));
+ block = new StringBuilder(length);
+ }
+ }
+ }
+
+ final long[] decodedValue = decoded.toArray();
+ if (!Objects.equals(hash, encode(decodedValue))) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new IllegalArgumentException("invalid hash: " + hash);
+ }
+ return new long[0];
+ }
+
+ return decodedValue;
}
/**
- * Decode an encoded string.
+ * Decodes the given hash into its hexadecimal representation based on this instance configuration.
*
- * @param hash the encoded string
- * @return the Hashid instance with the decoded hash and decoded number(s)
+ * @param hash the hash to be decoded
+ * @return the hexadecimal representation of the hash values with each numeric number present in the hash, empty otherwise
+ * @throws NullPointerException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the given hash is {@code null}
*/
- public Hashid decode(String hash) {
- if (isEmpty(hash)) {
- return Hashid.EMPTY;
+ public String decodeHex(final String hash) {
+ if (hash == null) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new NullPointerException("hash must not be null!");
+ }
+ return "";
}
- return doDecode(hash, alphabet);
+
+ final StringBuilder sb = new StringBuilder();
+ Arrays.stream(decode(hash))
+ .mapToObj(Long::toHexString)
+ .forEach(hex -> sb.append(hex, 1, hex.length()));
+ return sb.toString();
}
/**
- * Decode an encoded string to long numbers.
+ * Decodes the given valid hash into its single numeric representation based on this instance configuration.
*
- * @param hash the encoded string
- * @return the decoded long numbers
+ * Simplifies the use-case where the amount of resulting numbers is known before to handle the return value as single value instead of an array.
+ * The given hash must resolve into a one number only, otherwise see the {@link #decode(String) decode} method.
+ *
+ * @param hash the valid hash to be decoded
+ * @return the decoded number if the given hash is valid, empty otherwise
+ * @throws IllegalArgumentException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the hash is invalid
+ * @throws NullPointerException if the {@link HashidsFeature#EXCEPTION_HANDLING EXCEPTION_HANDLING} feature is enabled and the given hash is {@code null}
+ * @since 0.4.0
*/
- public long[] decodeLongNumbers(String hash) {
- if (isEmpty(hash)) {
- return new long[0];
+ public Optional decodeOne(final String hash) {
+ if (hash == null) {
+ if (features.contains(HashidsFeature.EXCEPTION_HANDLING)) {
+ throw new NullPointerException("hash must not be null!");
+ }
+ return Optional.empty();
}
- return doDecode(hash, alphabet).numbers();
+
+ long[] decoded = decode(hash);
+ return decoded.length == 1 ? Optional.of(decoded[0]) : Optional.empty();
}
/**
- * Decode an encoded string to integer numbers.
+ * Returns the version of the public API.
*
- * @param hash the encoded string
- * @return the decoded integer numbers
- * @throws IllegalArgumentException if the decoded number is out of the integer minimal- or maximal range
+ * @return the version of the public API
+ * @see Arctic Versioning Specification
+ * @see Semantic Versioning Specification
+ * @since 0.2.0
*/
- public int[] decodeIntegerNumbers(String hash) {
- if (isEmpty(hash)) {
- return new int[0];
- }
- long[] numbers = doDecode(hash, alphabet).numbers();
- int[] ints = new int[numbers.length];
- for (int idx = 0; idx < numbers.length; idx++) {
- long number = numbers[idx];
- if (number < Integer.MIN_VALUE || number > Integer.MAX_VALUE) {
- throw new IllegalArgumentException("Number out of range");
- }
- ints[idx] = (int) number;
- }
- return ints;
+ public static String getVersion() {
+ return VERSION;
}
/**
- * Decode an string to hexadecimal numbers.
+ * Returns the version of the original algorithm implementation hashids
+ * .js with which the public API is interoperable.
*
- * @param hash the encoded string
- * @return the decoded hexadecimal numbers string
+ * @return the version of the original algorithm implementation with which the public API is interoperable
+ * @see Hashids Compatibility
+ * @since 0.4.0
*/
- public String decodeHex(String hash) {
- StringBuilder sb = new StringBuilder();
- long[] numbers = decodeLongNumbers(hash);
- for (long number : numbers) {
- sb.append(Long.toHexString(number).substring(1));
- }
- return sb.toString();
+ public static String getInteropVersion() {
+ return VERSION_INTEROP;
}
- private Hashid doEncode(long... numbers) {
- int numberHashInt = 0;
- for (int idx = 0; idx < numbers.length; idx++) {
- if (numbers[idx] < 0 || numbers[idx] > MAX_NUMBER_VALUE) {
- throw new IllegalArgumentException("Number out of range");
- }
- numberHashInt += numbers[idx] % (idx + 100);
- }
- String decodeAlphabet = alphabet;
- final char lottery = decodeAlphabet.charAt(numberHashInt % decodeAlphabet.length());
- StringBuilder result = new StringBuilder(String.valueOf(lottery));
-
- String buffer;
- int sepsIdx, guardIdx;
- for (int idx = 0; idx < numbers.length; idx++) {
- long num = numbers[idx];
- buffer = lottery + salt + decodeAlphabet;
-
- decodeAlphabet = consistentShuffle(decodeAlphabet, buffer.substring(0, decodeAlphabet.length()));
- final String last = hash(num, decodeAlphabet);
- result.append(last);
-
- if (idx + 1 < numbers.length) {
- num %= ((int) last.charAt(0) + idx);
- sepsIdx = (int) (num % separators.length());
- result.append(separators.charAt(sepsIdx));
- }
- }
-
- if (result.length() < minHashLength) {
- guardIdx = (numberHashInt + (int) (result.charAt(0))) % guards.length();
- char guard = guards.charAt(guardIdx);
- result.insert(0, guard);
-
- if (result.length() < minHashLength) {
- guardIdx = (numberHashInt + (int) (result.charAt(2))) % guards.length();
- guard = guards.charAt(guardIdx);
- result.append(guard);
- }
+ @Override
+ public boolean equals(final Object otherObject) {
+ if (null == otherObject) {
+ return false;
}
-
- final int halfLen = decodeAlphabet.length() / 2;
- while (result.length() < minHashLength) {
- decodeAlphabet = consistentShuffle(decodeAlphabet, decodeAlphabet);
- result.insert(0, decodeAlphabet.substring(halfLen)).append(decodeAlphabet.substring(0, halfLen));
- final int excess = result.length() - minHashLength;
- if (excess > 0) {
- int startPos = excess / 2;
- result.replace(0, result.length(), result.substring(startPos, startPos + minHashLength));
- }
+ if (this.getClass() != otherObject.getClass()) {
+ return false;
}
- return new Hashid(numbers, result.toString());
+ final Hashids otherHashids = (Hashids) otherObject;
+ return Arrays.equals(salt, otherHashids.salt)
+ && Objects.equals(minLength, otherHashids.minLength)
+ && Arrays.equals(alphabet, otherHashids.alphabet)
+ && Objects.equals(features, otherHashids.features);
}
- private Hashid doDecode(String hash, String alphabet) {
- final List result = new ArrayList<>();
- int idx = 0;
- String[] hashArray = hash.replaceAll("[" + guards + "]", " ").split(" ");
- if (hashArray.length == 3 || hashArray.length == 2) {
- idx = 1;
- }
- String hashBreakdown = hashArray[idx];
-
- if (!hashBreakdown.isEmpty()) {
- final char lottery = hashBreakdown.charAt(0);
- hashBreakdown = hashBreakdown.substring(1);
- hashBreakdown = hashBreakdown.replaceAll("[" + separators + "]", " ");
- hashArray = hashBreakdown.split(" ");
-
- String buffer;
- for (String subHash : hashArray) {
- buffer = lottery + salt + alphabet;
- alphabet = consistentShuffle(alphabet, buffer.substring(0, alphabet.length()));
- result.add(unhash(subHash, alphabet));
- }
- }
- long[] resultArray = toArray(result);
- return new Hashid(resultArray, hash);
+ @Override
+ public String toString() {
+ return "Hashids{"
+ + "salt=" + Arrays.toString(salt)
+ + ", minLength=" + minLength
+ + ", alphabet=" + Arrays.toString(alphabet)
+ + ", features=" + features
+ + '}';
}
- private static String consistentShuffle(String alphabet, String salt) {
- if (salt.length() <= 0) {
- return alphabet;
- }
- final char[] saltChars = salt.toCharArray();
- int ascVal, j;
- char [] tmpArr = alphabet.toCharArray();
- for (int idx = tmpArr.length - 1, v = 0, p = 0; idx > 0; idx--, v++) {
- v %= salt.length();
- ascVal = (int) saltChars[v];
- p += ascVal;
- j = (ascVal + v + p) % idx;
+ /**
+ * Derives a new alphabet using the given salt and lottery character.
+ *
+ * @param alphabet the current alphabet
+ * @param salt the salt to be used as entropy
+ * @param lottery the lottery character
+ * @return a new derived alphabet
+ * @since 0.4.0
+ */
+ private char[] deriveNewAlphabet(final char[] alphabet, final char[] salt, final char lottery) {
+ final char[] newSalt = new char[alphabet.length];
+ newSalt[0] = lottery;
+ int spaceLeft = newSalt.length - 1;
+ int offset = 1;
- char tmp = tmpArr[j];
- tmpArr[j] = tmpArr[idx];
- tmpArr[idx] = tmp;
+ if (salt.length > 0 && spaceLeft > 0) {
+ int length = salt.length > spaceLeft ? spaceLeft : salt.length;
+ System.arraycopy(salt, 0, newSalt, offset, length);
+ spaceLeft -= length;
+ offset += length;
+ }
+ if (spaceLeft > 0) {
+ System.arraycopy(alphabet, 0, newSalt, offset, spaceLeft);
}
- return new String(tmpArr);
+
+ return shuffle(alphabet, newSalt);
}
- private static String hash(long input, String alphabet) {
- StringBuilder hash = new StringBuilder();
- final int alphabetLen = alphabet.length();
- final char[] alphabetChars = alphabet.toCharArray();
- do {
- hash.insert(0, alphabetChars[(int) (input % alphabetLen)]);
- input /= alphabetLen;
- }
- while (input > 0);
- return hash.toString();
+ /**
+ * Filters the given alphabet after the separators.
+ *
+ * @param separators the separators to be filtered
+ * @param alphabet the alphabet to be filtered
+ * @return the filtered alphabet
+ * @since 0.4.0
+ */
+ private char[] filterSeparators(final char[] separators, final char[] alphabet) {
+ final Set valid = IntStream.range(0, alphabet.length)
+ .mapToObj(idx -> alphabet[idx])
+ .collect(toSet());
+
+ return IntStream.range(0, separators.length)
+ .mapToObj(idx -> (separators[idx]))
+ .filter(valid::contains)
+ .map(c -> Character.toString(c))
+ .collect(joining())
+ .toCharArray();
}
- private static Long unhash(String input, String alphabet) {
- long number = 0;
- long pos;
- final char[] inputChars = input.toCharArray();
- for (int idx = 0; idx < input.length(); idx++) {
- pos = alphabet.indexOf(inputChars[idx]);
- number += pos * Math.pow(alphabet.length(), input.length() - idx - 1);
- }
- return number;
+ /**
+ * Shuffles the alphabet with the given salt.
+ *
+ * @param alphabet the alphabet to be shuffled
+ * @param salt the salt with which the alphabet is shuffled
+ * @return the shuffled alphabet
+ */
+ private char[] shuffle(final char[] alphabet, final char[] salt) {
+ for (int idx = alphabet.length - 1, mod = 0, idxChar = 0, idxMatch, num; salt.length > 0 && idx > 0; idx--, mod++) {
+ mod %= salt.length;
+ idxChar += num = salt[mod];
+ idxMatch = (num + mod + idxChar) % idx;
+ final char tmp = alphabet[idxMatch];
+ alphabet[idxMatch] = alphabet[idx];
+ alphabet[idx] = tmp;
+ }
+ return alphabet;
}
- private long[] toArray(List longs) {
- final long[] result = new long[longs.size()];
- int idx = 0;
- for (Long aLong : longs) {
- result[idx++] = aLong;
- }
- return result;
+ /**
+ * Transforms the hash into the encoded hash state using the given alphabet.
+ *
+ * @param number the number to be transformed into the encoded hash state
+ * @param alphabet the alphabet to be used for the transformation
+ * @param sb the string builder to prepend the transformed number
+ * @param start the start index for the given alphabet
+ * @return the given string builder with the prepended transformed number
+ */
+ private StringBuilder transform(final long number, final char[] alphabet, final StringBuilder sb, final int start) {
+ long input = number;
+ do {
+ // Prepend the matched character and trim the input
+ sb.insert(start, alphabet[(int) (input % alphabet.length)]);
+ input = input / alphabet.length;
+ } while (input > 0);
+
+ return sb;
}
/**
- * Check if a string is {@code null} or empty.
+ * Transforms the hash into the decoded number state using the given alphabet.
*
- * @param value The string to check
- * @return {@code true} if the string is {@code null} or empty, {@code false} otherwise
+ * @param hash the hash to be transformed into the decoded number state
+ * @param alphabet the alphabet to be used for the transformation
+ * @return the transformed hash in the decoded number state
*/
- private boolean isEmpty(String value) {
- return value == null || value.length() == 0;
+ private long transform(final char[] hash, final char[] alphabet) {
+ long number = 0;
+
+ final Map alphabetMapping = IntStream.range(0, alphabet.length)
+ .mapToObj(idx -> new Object[]{alphabet[idx], idx})
+ .collect(groupingBy(arr -> (Character) arr[0], mapping(arr -> (Integer) arr[1], reducing(null, (a, b) -> a == null ? b : a))));
+
+ for (int idx = 0; idx < hash.length; ++idx) {
+ number += alphabetMapping.get(hash[idx]) * (long) Math.pow(alphabet.length, hash.length - idx - 1);
+ }
+
+ return number;
}
/**
- * Returns the ArcVer / SemVer version of the public API.
+ * Validates and filters the given alphabet.
*
- * @return the ArcVer/SemVer version string
- * @see ArcVer
- * @see SemVer
- * @since 0.2.0
+ * @param alphabet The alphabet to be validated and filtered
+ * @param separators the separators to be filtered
+ * @return the filtered alphabet
+ * @throws IllegalArgumentException if the given alphabet does not contain the {@link #MIN_ALPHABET_LENGTH minimum length of unique characters} or contains
+ * spaces.
+ * @since 0.4.0
*/
- public static String getVersion() {
- return VERSION;
+ private char[] validateAndFilterAlphabet(final char[] alphabet, final char[] separators) {
+ if (alphabet.length < MIN_ALPHABET_LENGTH) {
+ throw new IllegalArgumentException("alphabet must contain at least " + MIN_ALPHABET_LENGTH + " unique characters: " + alphabet.length);
+ }
+
+ final Set validated = new LinkedHashSet<>(alphabet.length);
+ final Set invalid = IntStream.range(0, separators.length)
+ .mapToObj(idx -> separators[idx])
+ .collect(toSet());
+
+ // Add the validated characters
+ IntStream.range(0, alphabet.length)
+ .forEach(idx -> {
+ if (alphabet[idx] == ' ') {
+ throw new IllegalArgumentException("alphabet must not contain spaces: index " + idx);
+ }
+ final Character c = alphabet[idx];
+ if (!invalid.contains(c)) {
+ validated.add(c);
+ }
+ });
+
+ // Create a new alphabet from the validated characters
+ final char[] uniqueAlphabet = new char[validated.size()];
+ int idx = 0;
+ for (char c : validated) {
+ uniqueAlphabet[idx++] = c;
+ }
+ return uniqueAlphabet;
}
}
diff --git a/src/main/java/com/arcticicestudio/icecore/hashids/HashidsFeature.java b/src/main/java/com/arcticicestudio/icecore/hashids/HashidsFeature.java
new file mode 100644
index 0000000..1777e51
--- /dev/null
+++ b/src/main/java/com/arcticicestudio/icecore/hashids/HashidsFeature.java
@@ -0,0 +1,43 @@
+package com.arcticicestudio.icecore.hashids;
+
+import java.util.EnumSet;
+
+/**
+ * Enumeration that defines optional features for the {@link Hashids.Builder}.
+ *
+ * Please note that almost every feature will break the interoperability with the origin algorithm implementation if enabled!
+ *
+ * @author Arctic Ice Studio <development@arcticicestudio.com>
+ * @since 0.4.0
+ */
+public enum HashidsFeature {
+ /**
+ * Enables support for the {@code 0x} or {@code 0X} hexadecimal format prefixes of parameter values passed to the
+ * {@link Hashids#encodeHex(String) encodeHex(String)}and {@link Hashids#decodeHex(String) decodeHex(String)} methods.
+ *
+ *
Please note that this will break the interoperability with the origin algorithm implementation!
+ *
+ * @see Hexadecimal - Written representation
+ */
+ ALLOW_HEXADECIMAL_NUMBER_PREFIX,
+
+ /**
+ * Enables the handling of exceptions instead of returning empty values when invalid parameters are passed to any public API method.
+ *
+ *
Please note that this will break the interoperability with the origin algorithm implementation!
+ */
+ EXCEPTION_HANDLING,
+
+ /**
+ * Disables the {@link Hashids#MAX_INTEROP_NUMBER_SIZE maximum number size limit} which ensures the interoperability with the origin algorithm implementation
+ * hashids.js and allows the usage of the {@link Long#MAX_VALUE Java Long maxiumum value}.
+ *
+ *
Please note that this will break the interoperability with the origin algorithm implementation!
+ */
+ NO_MAX_INTEROP_NUMBER_SIZE;
+
+ /**
+ * Enables all features.
+ */
+ public static final EnumSet ALL = EnumSet.allOf(HashidsFeature.class);
+}
diff --git a/src/main/java/com/arcticicestudio/icecore/hashids/package-info.java b/src/main/java/com/arcticicestudio/icecore/hashids/package-info.java
index 01edaea..51f5a41 100644
--- a/src/main/java/com/arcticicestudio/icecore/hashids/package-info.java
+++ b/src/main/java/com/arcticicestudio/icecore/hashids/package-info.java
@@ -1,23 +1,7 @@
-/*
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-title Package Info +
-project icecore-hashids +
-repository https://github.com/arcticicestudio/icecore-hashids +
-author Arctic Ice Studio +
-email development@arcticicestudio.com +
-copyright Copyright (C) 2017 +
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-*/
/**
- * Represents the public API of the
- * "IceCore Hashids" library.
- *
- * The main entry point of the package is the {@link com.arcticicestudio.icecore.hashids.Hashids} class to to generate
- * short, unique, non-sequential and decodable hashids from positive unsigned (long) integer numbers.
- *
+ * Provides the {@link com.arcticicestudio.icecore.hashids.Hashids IceCore Hashids} public API.
*
* @author Arctic Ice Studio <development@arcticicestudio.com>
- * @see Hashids
- * @version 0.3.0
+ * @version 0.4.0
*/
package com.arcticicestudio.icecore.hashids;
diff --git a/src/main/resources/arcticicestudio-styleguide-java-checkstyle.xml b/src/main/resources/arcticicestudio-styleguide-java-checkstyle.xml
new file mode 100644
index 0000000..793bb1c
--- /dev/null
+++ b/src/main/resources/arcticicestudio-styleguide-java-checkstyle.xml
@@ -0,0 +1,223 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/test/java/com/arcticicestudio/icecore/hashids/AbstractHashidsTest.java b/src/test/java/com/arcticicestudio/icecore/hashids/AbstractHashidsTest.java
new file mode 100644
index 0000000..31e5de2
--- /dev/null
+++ b/src/test/java/com/arcticicestudio/icecore/hashids/AbstractHashidsTest.java
@@ -0,0 +1,105 @@
+package com.arcticicestudio.icecore.hashids;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+
+/**
+ * Sets up the reference implementation script and provides it as {@link HashidsJs} representation class.
+ *
+ * @author Arctic Ice Studio <development@arcticicestudio.com>
+ * @see hashids.js
+ * @version 0.4.0
+ */
+abstract class AbstractHashidsTest {
+
+ final Hashids algorithm;
+ final HashidsJs jsAlgorithm;
+ final long[] input;
+
+ AbstractHashidsTest(final Supplier algorithm, final Supplier jsAlgorithm, final long[] input) {
+ this.algorithm = algorithm.get();
+ this.jsAlgorithm = jsAlgorithm.get();
+ this.input = input;
+ }
+
+ static HashidsJs getHashidsJs() {
+ return getHashidsJs("");
+ }
+
+ static HashidsJs getHashidsJs(final String salt) {
+ return getHashidsJs(salt, 0);
+ }
+
+ static HashidsJs getHashidsJs(final String salt, final int minLength) {
+ return getHashidsJs(salt, minLength, "");
+ }
+
+ static HashidsJs getHashidsJs(final String salt, final int minLength, final String alphabet) {
+ try {
+ final ScriptEngine nashorn = new ScriptEngineManager().getEngineByName("nashorn");
+ try (FileInputStream hashidsScript = new FileInputStream(new File("node_modules/hashids/dist/hashids.js"))) {
+ nashorn.eval(new InputStreamReader(hashidsScript));
+ }
+
+ // Create the instantiation script with the constructor parameters
+ final StringBuilder script = new StringBuilder("var hashids = new Hashids(");
+
+ if (salt != null && salt.length() > 0) {
+ script.append("'").append(salt).append("',");
+ } else {
+ script.append("undefined,");
+ }
+ script.append(minLength).append(",");
+ if (alphabet != null && alphabet.length() > 0) {
+ script.append("'").append(alphabet).append("'");
+ } else {
+ script.append("undefined");
+ }
+ script.append(");");
+
+ // Evaluate the script and return the algorithm bridge
+ nashorn.eval(script.toString());
+ return new HashidsJs(nashorn);
+ } catch (final Exception e) {
+ throw new RuntimeException("unable to initialize hashids.js algorithm", e);
+ }
+ }
+
+ /**
+ * Represents the reference implementation.
+ */
+ static final class HashidsJs {
+
+ private final ScriptEngine engine;
+
+ private HashidsJs(final ScriptEngine engine) {
+ this.engine = engine;
+ }
+
+ String encode(long[] numbers) {
+ final String params = LongStream.of(numbers)
+ .mapToObj(String::valueOf)
+ .collect(Collectors.joining(","));
+ return eval("hashids.encode(" + params + ");");
+ }
+
+ long[] decode(String hash) {
+ return eval("hashids.decode('" + hash + "');");
+ }
+
+ @SuppressWarnings("unchecked")
+ private T eval(final String script) {
+ try {
+ return (T) engine.eval(script);
+ } catch (final Exception e) {
+ throw new AssertionError("unexpected exception during hashid.js algorithm execution evaluation", e);
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/arcticicestudio/icecore/hashids/HashidTest.java b/src/test/java/com/arcticicestudio/icecore/hashids/HashidTest.java
deleted file mode 100644
index 911d633..0000000
--- a/src/test/java/com/arcticicestudio/icecore/hashids/HashidTest.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-title Hashid Unit Tests +
-project icecore-hashids +
-repository https://github.com/arcticicestudio/icecore-hashids +
-author Arctic Ice Studio +
-email development@arcticicestudio.com +
-copyright Copyright (C) 2017 +
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-*/
-package com.arcticicestudio.icecore.hashids;
-
-
-import org.junit.Test;
-
-import static junit.framework.TestCase.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Unit tests for {@link Hashid} implementation.
- *
- * @author Arctic Ice Studio <development@arcticicestudio.com>
- * @since 0.3.0
- */
-public class HashidTest {
-
- @Test
- public void testEqualsSymmetric() {
- Hashid h1 = new Hashid(new long[] {2, 17, 92}, "MjhWikW");
- Hashid h2 = new Hashid(new long[] {2, 17, 92}, "MjhWikW");
-
- assertTrue(h1.equals(h2) && h2.equals(h1));
- assertTrue(h1.hashCode() == h2.hashCode());
- assertTrue(h1.equals(h1));
- assertFalse(h1.equals(null));
-
- Long unequalClassObject = 12L;
- assertFalse(h1.equals(unequalClassObject));
- }
-}
diff --git a/src/test/java/com/arcticicestudio/icecore/hashids/HashidsTest.java b/src/test/java/com/arcticicestudio/icecore/hashids/HashidsTest.java
index 39cee20..5e49793 100644
--- a/src/test/java/com/arcticicestudio/icecore/hashids/HashidsTest.java
+++ b/src/test/java/com/arcticicestudio/icecore/hashids/HashidsTest.java
@@ -1,262 +1,423 @@
-/*
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-title Hashids Public API Test +
-project icecore-hashids +
-repository https://github.com/arcticicestudio/icecore-hashids +
-author Arctic Ice Studio +
-email development@arcticicestudio.com +
-copyright Copyright (C) 2017 +
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-*/
package com.arcticicestudio.icecore.hashids;
-import org.junit.Test;
+import static com.arcticicestudio.icecore.hashids.HashidsFeature.ALLOW_HEXADECIMAL_NUMBER_PREFIX;
+import static com.arcticicestudio.icecore.hashids.HashidsFeature.EXCEPTION_HANDLING;
+import static com.arcticicestudio.icecore.hashids.HashidsFeature.NO_MAX_INTEROP_NUMBER_SIZE;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.emptyString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.not;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
+import java.util.Optional;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
/**
- * Tests the IceCore Hashids
- * public API class {@link Hashids}.
+ * Units tests for the IceCore Hashids public API.
*
* @author Arctic Ice Studio <development@arcticicestudio.com>
- * @see IceCore Hashids
- * @see Hashids
* @since 0.1.0
*/
public class HashidsTest {
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
@Test
- public void oneNumber() {
- Hashids hashids = new Hashids("salt");
- long number = 12_345L;
- String expected = "X4j1";
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(number));
+ public void defaultInstanceConfigurationEquality() {
+ final Hashids hashidsBuilder = new Hashids.Builder().build();
+ final Hashids hashids = new Hashids();
+ assertThat(hashidsBuilder, equalTo(hashids));
+ assertThat(hashidsBuilder.toString(), equalTo(hashids.toString()));
+ }
- assertEquals(hashids.encodeToString(number), expected);
- assertEquals(decoded.length, 1);
- assertEquals(decoded[0], number);
+ @Test
+ public void invalidAlphabetLength() {
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("alphabet must contain at least 16 unique characters: 6");
+ final Hashids hashids = new Hashids.Builder()
+ .alphabet("abc123")
+ .build();
}
@Test
- public void oneLargeNumber() {
- Hashids hashids = new Hashids("salt");
- long number = 9_007_199_254_740_991L;
- String expected = "wQpRRqRX24R";
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(number));
+ public void alphabetWithSpaces() {
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("alphabet must not contain spaces: index 1");
+ final Hashids hashids = new Hashids.Builder()
+ .salt("salt")
+ .alphabet("a bcdefg1234567890")
+ .build();
+ }
- assertEquals(hashids.encodeToString(number), expected);
- assertEquals(decoded.length, 1);
- assertEquals(decoded[0], number);
+ @Test
+ public void alphabetWithSymbols() {
+ Hashids hashids = new Hashids.Builder()
+ .alphabet("`~!@#$%^&*()-_=+|';:/?.>,<{[}]")
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("]]''?"));
}
@Test
- public void oneLargeIntegerNumber() {
- Hashids hashids = new Hashids("salt");
- int number = 2147483647;
- String expected = "wqVYY1X";
- int[] decoded = hashids.decodeIntegerNumbers(hashids.encodeToString(number));
+ public void transcode() {
+ Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encode(123456L), equalTo("xkNDJ"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("x7SQJh8kQ"));
+ assertThat(hashids.decode("xkNDJ"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("x7SQJh8kQ"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("xkNDJ"), equalTo(Optional.of(123456L)));
+ }
- assertEquals(hashids.encodeToString(number), expected);
- assertEquals(decoded.length, 1);
- assertEquals(decoded[0], number);
+ @Test
+ public void transcodeWithSalt() {
+ Hashids hashids = new Hashids.Builder()
+ .salt("salt")
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("7E1dX"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("7NfvoFvAJ"));
+ assertThat(hashids.decode("7E1dX"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("7NfvoFvAJ"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("7E1dX"), equalTo(Optional.of(123456L)));
}
- @Test(expected = IllegalArgumentException.class)
- public void oneLargeNumberNotSupported() throws Exception {
- long number = 9007199254740993L;
- Hashids a = new Hashids("salt");
- a.encode(number);
+ @Test
+ public void transcodeWithMinLength() {
+ Hashids hashids = new Hashids.Builder()
+ .minLength(16)
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("VoJX7axkNDJeyv4E"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("vDLax7SQJh8kQe6p"));
+ assertThat(hashids.decode("VoJX7axkNDJeyv4E"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("vDLax7SQJh8kQe6p"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("VoJX7axkNDJeyv4E"), equalTo(Optional.of(123456L)));
}
@Test
- public void oneNumberWithCustomMinimumHashLength() {
- Hashids hashids = new Hashids("salt", 8);
- long number = 12_345L;
- String expected = "xkX4j1kZ";
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(number));
+ public void transcodeWithCustomAlphabet() {
+ Hashids hashids = new Hashids.Builder()
+ .alphabet("abcdefghij1234560")
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("e60655"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("e43i3j2hg6e4"));
+ assertThat(hashids.decode("e60655"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("e43i3j2hg6e4"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("e60655"), equalTo(Optional.of(123456L)));
+
+ Hashids hashidsSymbols = new Hashids.Builder()
+ .alphabet("!#$%&'()*+,-./:;<=>?@[]^_`{|}~")
+ .build();
+ assertThat(hashidsSymbols.encode(123456L), equalTo("~_--:"));
+ assertThat(hashidsSymbols.encode(11L, 222L, 3333L), equalTo("<~$-{$:;="));
+ assertThat(hashidsSymbols.decode("~_--:"), equalTo(new long[] {123456L}));
+ assertThat(hashidsSymbols.decode("<~$-{$:;="), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashidsSymbols.decodeOne("~_--:"), equalTo(Optional.of(123456L)));
+ }
- assertEquals(hashids.encodeToString(number), expected);
- assertEquals(decoded.length, 1);
- assertEquals(decoded[0], number);
+ @Test
+ public void transcodeWithSaltAndMinLength() {
+ Hashids hashids = new Hashids.Builder()
+ .salt("salt")
+ .minLength(16)
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("lgaRz37E1dXkB1XL"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("Wnj37NfvoFvAJmze"));
+ assertThat(hashids.decode("lgaRz37E1dXkB1XL"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("Wnj37NfvoFvAJmze"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("lgaRz37E1dXkB1XL"), equalTo(Optional.of(123456L)));
}
@Test
- public void oneNumberWithoutSeparators() {
- Hashids hashids = new Hashids("salt", 0, Hashids.DEFAULT_ALPHABET, null);
- long number = 12_345L;
- String hash = hashids.encodeToString(number);
- long[] decoded = hashids.decodeLongNumbers(hash);
+ public void transcodeWithSaltAndCustomAlphabet() {
+ Hashids hashids = new Hashids.Builder()
+ .salt("salt")
+ .alphabet("abcdefghij1234560")
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("534300"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("5eahg15cbea1"));
+ assertThat(hashids.decode("534300"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("5eahg15cbea1"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("534300"), equalTo(Optional.of(123456L)));
+ }
- assertEquals(1, decoded.length);
- assertEquals(number, decoded[0]);
+ @Test
+ public void transcodeWithMinLengthAndCustomAlphabet() {
+ Hashids hashids = new Hashids.Builder()
+ .minLength(16)
+ .alphabet("abcdefghij1234560")
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("6125ebe60655adg0"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("e1be43i3j2hg6e4a"));
+ assertThat(hashids.decode("6125ebe60655adg0"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("e1be43i3j2hg6e4a"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("6125ebe60655adg0"), equalTo(Optional.of(123456L)));
}
@Test
- public void oneNumberWithCustomSeparators() {
- Hashids hashids = new Hashids("salt", 0, Hashids.DEFAULT_ALPHABET, "abcdefgABCDEFG1234567");
- long number = 12_345L;
- String hash = hashids.encodeToString(number);
- long[] decoded = hashids.decodeLongNumbers(hash);
+ public void transcodeWithSaltAndMinLengthAndCustomAlphabet() {
+ Hashids hashids = new Hashids.Builder()
+ .salt("salt")
+ .minLength(16)
+ .alphabet("abcdefghij1234560")
+ .build();
+ assertThat(hashids.encode(123456L), equalTo("61a0425343002gd3"));
+ assertThat(hashids.encode(11L, 222L, 3333L), equalTo("4d25eahg15cbea12"));
+ assertThat(hashids.decode("61a0425343002gd3"), equalTo(new long[] {123456L}));
+ assertThat(hashids.decode("4d25eahg15cbea12"), equalTo(new long[] {11L, 222L, 3333L}));
+ assertThat(hashids.decodeOne("61a0425343002gd3"), equalTo(Optional.of(123456L)));
+ }
- assertEquals(1, decoded.length);
- assertEquals(number, decoded[0]);
+ @Test
+ public void transcodeMaximumNumberSize() {
+ Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encode(Hashids.MAX_INTEROP_NUMBER_SIZE), equalTo("lEW77X7g527"));
+ assertThat(hashids.decode("lEW77X7g527"), equalTo(new long[] {Hashids.MAX_INTEROP_NUMBER_SIZE}));
+ assertThat(hashids.decodeOne("lEW77X7g527"), equalTo(Optional.of(Hashids.MAX_INTEROP_NUMBER_SIZE)));
}
@Test
- public void oneNumberWithLargeCustomMinimumHashLength() {
- Hashids hashids = new Hashids("salt", 1000);
- long number = 12_345;
- String expected = "lPaNoKpAjg2O9bdQ5K6l9Yvj0o7MWXwZPNyZ90jxQp7WYlA5gJ4LvwEMGnwDNBZjpxQY692dXoPOMyrVrgXDGE0BnaeZdM" +
- "YO1WxRlevqJK0BloZNbYG29dP1paDDw7gpRqBzjy5OedVZlEJnNjPQ4LXZye5REY0qA2wW1pOnJNjvMbLKg6rexwWDVyl74ZW74pVdEYQBa6zv" +
- "15eDbwlVqpzoDZ14AwlxbGL0RyE9P250JQ4egxYbwaoz17vXZENyrgxzn6V2pW5eA9vMPRdBoa7w5Vo9GMge1nPqQYJxlEZVyrxYKONAepM0lw" +
- "L42g7PdgK6V0xvdQlao1ANOG92LpYONBLEyYvqeZwnDA6WMaGb7jaQOVlPerdbJ7B1LzDyY59b4AJOeo6l9RpgGWVnzZqjNVDpraMYz2bQxdKv" +
- "y5PEwe7OP7WZDzeQANv9o6ga0jG2dDYj4xlKLZpa5qBbzMyGvrNp9nl4bLoy7E2dPB6AGYqzxkX4j1kZWaevwVKNR01OrMX5DgjJQAdPXJ9W16" +
- "OwQeR2go07VEnb1MqKxJ4YLr5XEVlwpnRyBqOlZG9Rg1AnN4o6XLBJ0jWP2yrvYX7QMB0a5LdxKwED1g0KMRpWnXv26oZx4GEqAwNdVg9PR25z" +
- "rJQjxKoXl104pzZeqEb7J5Pyw4BXWjRMnrD5RqWnoa1EGzX6JvDQbjBZ9NB6Av2bjd4LRy0WOXzrKDp0DlXKJZL7YNjOwQqbE1a4GpMLnj6RKy" +
- "PDrWVB9lOGdqAQenj5aYBM7KWdNr6JXOgv2M9XNL0oAxJ2RqrGOngPjKyq2oPpEzdA5XORGQZa91Y0BlNxz96Bba7oVDnMgdrJvGKaMYKo9bvQ" +
- "6r04xXL1GP2AWOWR7x46rMLgjXyQnVAEw5zL76Aboq49vK2pQz5jNJywPlGg1KAV0aLWzJ5bRevE74qBPoy6Xzbqre1RnKa2NdVODOVnBaDERz" +
- "AgJGx41qe2LrpdWGE4QbxLJez6";
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(number));
+ public void transcodeNullInput() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encode((long[]) null), emptyString());
+ assertThat(hashids.decode(null), equalTo(new long[0]));
+ assertThat(hashids.decodeOne(null), equalTo(Optional.empty()));
+ }
- assertEquals(expected, hashids.encodeToString(number));
- assertEquals(1, decoded.length);
- assertEquals(number, decoded[0]);
+ @Test
+ public void transcodeHex() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encodeHex("75bcd15"), equalTo("j2g9K4y"));
+ assertThat(hashids.decodeHex("j2g9K4y"), equalTo("75bcd15"));
}
@Test
- public void oneNumberWithCustomUpperCaseAndNumbersAlphabet() {
- Hashids hashids = new Hashids("salt", "ABCDEFGHIJKLMNPQRSTUVWXYZ123456789");
- long number = 12_345L;
- String expected = "KQL1R";
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(number));
+ public void transcodeHexPrefixedInput() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encodeHex("0x75bcd15"), emptyString());
+ assertThat(hashids.encodeHex("0X75bcd15"), emptyString());
+ assertThat(hashids.decodeHex("0x75bcd15"), emptyString());
+ assertThat(hashids.decodeHex("0X75bcd15"), emptyString());
+ }
+
+ @Test
+ public void transcodeHexWithAllowedHexadecimalNumberPrefix() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(ALLOW_HEXADECIMAL_NUMBER_PREFIX)
+ .build();
+ final String hex = hashids.encodeHex("75bcd15");
+ final String hexPrefixLowercase = hashids.encodeHex("0x75bcd15");
+ final String hexPrefixUppercase = hashids.encodeHex("0X75bcd15");
+ assertThat(hex, equalTo("j2g9K4y"));
+ assertThat(hex, equalTo(hexPrefixLowercase));
+ assertThat(hex, equalTo(hexPrefixUppercase));
+ assertThat(hashids.decodeHex(hex), equalTo("75bcd15"));
+ }
- assertEquals(expected, hashids.encodeToString(number));
- assertEquals(decoded.length, 1);
- assertEquals(decoded[0], number);
+ @Test
+ public void transcodeHexNullInput() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encodeHex(null), emptyString());
+ assertThat(hashids.decodeHex(null), emptyString());
}
@Test
- public void oneNumberWithCustomLowerCaseAndNumbersAlphabet() {
- Hashids hashids = new Hashids("salt", "abcdefghijklmnpqrstuvwxyz123456789");
- long number = 12_345L;
- String expected = "kzkvx";
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(number));
+ public void encodeMaximumNumberSizeExceeded() {
+ Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encode(Hashids.MAX_INTEROP_NUMBER_SIZE + 1L), emptyString());
+ }
- assertEquals(expected, hashids.encodeToString(number));
- assertEquals(1, decoded.length);
- assertEquals(number, decoded[0]);
+ @Test
+ public void encodeMaximumNumberSizeExceededWithExceptionHandling() {
+ Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("number must not exceed the maximum number size: 9007199254740992 > 9007199254740991");
+ hashids.encode(Hashids.MAX_INTEROP_NUMBER_SIZE + 1L);
}
@Test
- public void severalNumbers() {
- Hashids hashids = new Hashids("salt");
- long[] numbers = {683L, 94_108L, 123L, 5L};
- String expected = "1eMToyKzsRAfO";
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(numbers));
+ public void encodeWithNoMaximumNumberSizeLimit() {
+ Hashids hashids = new Hashids.Builder()
+ .features(NO_MAX_INTEROP_NUMBER_SIZE)
+ .build();
+ assertThat(hashids.encode(Hashids.MAX_INTEROP_NUMBER_SIZE + 1L), not(emptyString()));
+ }
- assertEquals(hashids.encodeToString(numbers), expected);
- assertEquals(decoded.length, numbers.length);
- assertArrayEquals(decoded, numbers);
+ @Test
+ public void encodeNegativeInput() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encode(-123456L), emptyString());
+ assertThat(hashids.encode(-10L, -222L, -3333L), emptyString());
}
@Test
- public void severalNumbersRandomness() {
- Hashids hashids = new Hashids("salt");
- long[] numbers = {5L, 5L, 5L, 5L};
- String expected = "YBF7FKFz";
- long[] decoded = hashids.decodeLongNumbers(expected);
+ public void encodeNegativeInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("number must not be less than zero: -1");
+ hashids.encode(-1L);
+ }
- assertEquals(expected, hashids.encodeToString(numbers));
- assertEquals(numbers.length, decoded.length);
- assertArrayEquals(numbers, decoded);
+ @Test
+ public void encodeNullInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(NullPointerException.class);
+ thrown.expectMessage("numbers must not be null!");
+ hashids.encode((long[]) null);
}
@Test
- public void severalIncrementingNumbersRandomness() {
- Hashids hashids = new Hashids("salt");
- long[] numbers = {1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L};
- String expected = "rjiJulUECaFAS1TBhzcX";
- long[] decoded = hashids.decodeLongNumbers(expected);
+ public void decodeNullInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(NullPointerException.class);
+ thrown.expectMessage("hash must not be null!");
+ hashids.decode(null);
+ }
- assertEquals(expected, hashids.encodeToString(numbers));
- assertEquals(numbers.length, decoded.length);
- assertArrayEquals(numbers, decoded);
+ @Test
+ public void decodeOneNullInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(NullPointerException.class);
+ thrown.expectMessage("hash must not be null!");
+ hashids.decodeOne(null);
}
@Test
- public void invalidSaltCollision() {
- Hashids hashidsA = new Hashids("salt and pepper", 4);
- Hashids hashidsB = new Hashids("salt", 4);
- long number = 123L;
- String token = hashidsA.encodeToString(number);
+ public void encodeNoInput() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encode(), emptyString());
+ }
- long[] decodedWrongSalt = hashidsB.decodeLongNumbers(token);
- long[] decodedCorrectSalt = hashidsA.decodeLongNumbers(token);
- assertThat(decodedWrongSalt, not(equalTo(decodedCorrectSalt)));
+ @Test
+ public void encodeNoInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("length of numbers must be greater than or equal to one!");
+ hashids.encode();
}
@Test
- public void hexString() {
- Hashids hashids = new Hashids("salt");
- String hex = "75bcd15";
- String hash = hashids.encodeHex(hex);
- String returnedHex = hashids.decodeHex(hash);
+ public void encodeHexInvalidHexadecimalFormat() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.encodeHex("z"), emptyString());
+ }
- assertNotNull(hash);
- assertNotEquals(0, hash.length());
- assertEquals(hex, returnedHex);
+ @Test
+ public void encodeHexInvalidHexadecimalFormatWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("hexNumbers must be a valid hexadecimal number!");
+ hashids.encodeHex("z");
}
@Test
- public void hexStringWithCustomMinimumHashLength() {
- Hashids hashids = new Hashids("salt", 8);
- String hex = "75bcd15";
- String hash = hashids.encodeHex(hex);
- String returnedHex = hashids.decodeHex(hash);
+ public void encodeHexLowercasePrefixedInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("numbers must not contain a hexadecimal prefix: 0x");
+ hashids.encodeHex("0x75bcd15");
+ }
- assertNotNull(hash);
- assertNotEquals(0, hash.length());
- assertEquals(hex, returnedHex);
- assertEquals(8, hash.length());
+ @Test
+ public void encodeHexUppercasePrefixedInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("numbers must not contain a hexadecimal prefix: 0X");
+ hashids.encodeHex("0X75bcd15");
}
@Test
- public void longHexString() {
- Hashids hashids = new Hashids("salt");
- String hex = "f000000000000000000000000000000000000000000000000000000000000000000000000000000000000f";
- String hash = hashids.encodeHex(hex);
- String returnedHex = hashids.decodeHex(hash);
+ public void encodeHexNullInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(NullPointerException.class);
+ thrown.expectMessage("hexNumbers must not be null!");
+ hashids.encodeHex(null);
+ }
- assertNotNull(hash);
- assertNotEquals(0, hash.length());
- assertEquals(hex, returnedHex);
+ @Test
+ public void decodeHexNullInputWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(NullPointerException.class);
+ thrown.expectMessage("hash must not be null!");
+ hashids.decodeHex(null);
}
- @Test(expected = IllegalArgumentException.class)
- public void negativeNumber() {
- Hashids hashids = new Hashids("salt");
- long number = -1L;
- hashids.encodeToString(number);
+ @Test
+ public void decodeInvalidHash() {
+ final Hashids hashids = new Hashids.Builder().build();
+ assertThat(hashids.decode("yogurt"), equalTo(new long[0]));
+ assertThat(hashids.decode("()"), equalTo(new long[0]));
+ assertThat(hashids.decode("[]"), equalTo(new long[0]));
+ assertThat(hashids.decodeOne("yogurt"), equalTo(Optional.empty()));
+ assertThat(hashids.decodeOne("()"), equalTo(Optional.empty()));
+ assertThat(hashids.decodeOne("[]"), equalTo(Optional.empty()));
}
@Test
- public void hashidsBuilder() {
- Hashids hashids = new Hashids.Builder()
+ public void decodeInvalidSalt() {
+ final Hashids hashidsSalt = new Hashids.Builder()
.salt("salt")
- .minHashLength(16)
- .alphabet(Hashids.DEFAULT_ALPHABET)
- .separators(Hashids.DEFAULT_SEPARATORS)
.build();
- long number = 12_345L;
- long[] decoded = hashids.decodeLongNumbers(hashids.encodeToString(number));
+ final Hashids hashidsPepper = new Hashids.Builder()
+ .salt("pepper")
+ .build();
+ String salt = hashidsSalt.encode(123456L);
+ String pepper = hashidsPepper.encode(123456L);
+ assertThat(salt, not(equalTo(pepper)));
+ assertThat(hashidsSalt.decode(pepper), equalTo(new long[0]));
+ assertThat(hashidsSalt.decodeOne(pepper), equalTo(Optional.empty()));
+ assertThat(hashidsPepper.decode(salt), equalTo(new long[0]));
+ assertThat(hashidsPepper.decodeOne(salt), equalTo(Optional.empty()));
+ }
- assertEquals(1, decoded.length);
- assertEquals(number, decoded[0]);
+ @Test
+ public void decodeInvalidHashWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("invalid hash: yogurt");
+ hashids.decode("yogurt");
+ }
+
+ @Test
+ public void decodeOneInvalidHashWithExceptionHandling() {
+ final Hashids hashids = new Hashids.Builder()
+ .features(EXCEPTION_HANDLING)
+ .build();
+ thrown.expect(IllegalArgumentException.class);
+ thrown.expectMessage("invalid hash: yogurt");
+ hashids.decodeOne("yogurt");
+ }
+
+ @Test
+ public void validVersion() {
+ assertThat(Hashids.getVersion(), equalTo("0.4.0"));
+ }
+
+ @Test
+ public void validInteropVersion() {
+ assertThat(Hashids.getInteropVersion(), equalTo("1.0.0"));
}
}
diff --git a/src/test/java/com/arcticicestudio/icecore/hashids/InteropHashidsTest.java b/src/test/java/com/arcticicestudio/icecore/hashids/InteropHashidsTest.java
new file mode 100644
index 0000000..6334bd8
--- /dev/null
+++ b/src/test/java/com/arcticicestudio/icecore/hashids/InteropHashidsTest.java
@@ -0,0 +1,121 @@
+package com.arcticicestudio.icecore.hashids;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/**
+ * Interoperability tests for the {@link Hashids} algorithm and the reference implementation represented by the {@link HashidsJs} class.
+ *
+ * @author Arctic Ice Studio <development@arcticicestudio.com>
+ * @see hashids.js
+ * @version 0.4.0
+ */
+@RunWith(Parameterized.class)
+public class InteropHashidsTest extends AbstractHashidsTest {
+
+ /**
+ * Generates test data with incremented numbers from 1 to 32.
+ *
+ * @return the generated test data
+ */
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection data() {
+
+ // generate a 1-to-32 sized arrays
+ final List input = new ArrayList<>();
+ for (long i = 0; i < 32; i++) {
+ if (input.isEmpty()) {
+ input.add(new long[]{i});
+ } else {
+ final long[] prev = input.get(input.size() - 1);
+ final long[] curr = Arrays.copyOf(prev, prev.length + 1);
+ curr[prev.length] = i;
+ input.add(curr);
+ }
+ }
+
+ // generate a supplier for all algorithm combinations
+ final List[]> algorithms = new ArrayList<>();
+ algorithms.add(new Supplier[]{
+ () -> "NoSalt|NoMinLength|NoAlphabet",
+ Hashids::new,
+ AbstractHashidsTest::getHashidsJs
+ });
+
+ algorithms.add(new Supplier[]{
+ () -> "Salt|NoMinLength|NoAlphabet",
+ () -> new Hashids.Builder().salt("salt and pepper").build(),
+ () -> getHashidsJs("salt and pepper")
+ });
+
+ algorithms.add(new Supplier[]{
+ () -> "NoSalt|NoMinLength|Alphabet",
+ () -> new Hashids.Builder().alphabet("abcdef1234567890").build(),
+ () -> getHashidsJs("", 0, "abcdef1234567890")
+ });
+
+ algorithms.add(new Supplier[]{
+ () -> "NoSalt|MinLength|NoAlphabet",
+ () -> new Hashids.Builder().minLength(32).build(),
+ () -> getHashidsJs("", 32)
+ });
+
+ algorithms.add(new Supplier[]{
+ () -> "Salt|NoMinLength|Alphabet",
+ () -> new Hashids.Builder().salt("salt and pepper").alphabet("abcdef1234567890").build(),
+ () -> getHashidsJs("salt and pepper", 0, "abcdef1234567890")
+ });
+
+ algorithms.add(new Supplier[]{
+ () -> "NoSalt|MinLength|Alphabet",
+ () -> new Hashids.Builder().minLength(32).alphabet("abcdef1234567890").build(),
+ () -> getHashidsJs("", 32, "abcdef1234567890")
+ });
+
+ algorithms.add(new Supplier[]{
+ () -> "Salt|MinLength|NoAlphabet",
+ () -> new Hashids.Builder().salt("salt and pepper").minLength(32).build(),
+ () -> getHashidsJs("salt and pepper", 32)
+ });
+
+ algorithms.add(new Supplier[]{
+ () -> "Salt|MinLength|Alphabet",
+ () -> new Hashids.Builder().salt("salt and pepper").minLength(32).alphabet("abcdef1234567890").build(),
+ () -> getHashidsJs("salt and pepper", 32, "abcdef1234567890")
+ });
+
+ // generate the input for each hash algorithm
+ return algorithms.stream()
+ .flatMap(algorithm -> input.stream().map(numbers -> new Object[]{
+ // name
+ String.format("algorithm(%s) with input(%s)", algorithm[0].get(), Arrays.toString(numbers)),
+ // algorithm, jsAlgorithm, input
+ algorithm[1], algorithm[2], numbers
+ }))
+ .collect(Collectors.toList());
+ }
+
+ @SuppressWarnings("unused")
+ public InteropHashidsTest(final String name, final Supplier hashids, final Supplier hashidsJs, final long[] input) {
+ super(hashids, hashidsJs, input);
+ }
+
+ @Test
+ public void runInteropTests() {
+ final String encoded = algorithm.encode(input);
+ assertThat("encoding mismatch", encoded, equalTo(jsAlgorithm.encode(input)));
+ final long[] original = algorithm.decode(encoded);
+ assertThat(original, equalTo(input));
+ }
+}
Gradle
-```java
-compile(group: 'com.arcticicestudio', name: 'icecore-hashids', version: '0.3.0')
-```
-
-
