hash = hash * 31 + Objects.hashCode(dependency.getGroupId());
            hash = hash * 31 + Objects.hashCode(dependency.getArtifactId());
            hash = hash * 31 + Objects.hashCode(dependency.getVersion());
            hash = hash * 31 + Objects.hashCode(dependency.getType());
            hash = hash * 31 + Objects.hashCode(dependency.getClassifier());

        String hash = "01010101010101010101010101010101";
        String value = "$H4sIAAAAAAAA_zMwNMALAXC7sg0gAAAA";
        assertEquals(value, documentHelper.encodeSimilarDocHash(hash));
        hash = "00101010010010100100101010001010";
        value = "$H4sIAAAAAAAA_zMwMARDCELQQApMAgAi5-3LIAAAAA";
        assertEquals(value, documentHelper.encodeSimilarDocHash(hash));

      key[i] = (byte) i;
      int seed = 256 - i;
      byte[] hash = hashFunction.hash(Arrays.copyOf(key, i), seed);
      System.arraycopy(hash, 0, hashes, i * hashBytes, hash.length);
    }

    // Then hash the result array
    byte[] result = hashFunction.hash(hashes, 0);

    // interpreted in little-endian order.
    int verification = Integer.reverseBytes(Ints.fromByteArray(result));

    if (expected != verification) {

 * limitations under the License.
 */

package com.google.common.hash;

import static com.google.common.hash.Hashing.murmur3_32;
import static com.google.common.hash.Hashing.murmur3_32_fixed;

import com.google.common.base.Charsets;
import com.google.common.hash.HashTestUtils.HashFn;
import java.nio.charset.Charset;
import java.util.Random;
import junit.framework.TestCase;

   * input.
   */
  @VisibleForTesting(
      )
  static final double HASH_FLOODING_FPP = 0.001;

  /**
   * Maximum allowed length of a hash table bucket before falling back to a j.u.LinkedHashSet based
   * implementation. Experimentally determined.
   */
  private static final int MAX_HASH_BUCKET_LENGTH = 9;

   * input.
   */
  @VisibleForTesting(
      )
  static final double HASH_FLOODING_FPP = 0.001;

  /**
   * Maximum allowed length of a hash table bucket before falling back to a j.u.LinkedHashMap-based
   * implementation. Experimentally determined.
   */
  private static final int MAX_HASH_BUCKET_LENGTH = 9;

   *       y}, if {@code equivalent(x, y)}, then {@code hash(x) == hash(y)}. It is <i>not</i>
   *       necessary that the hash be distributable across <i>inequivalence</i>. If {@code
   *       equivalence(x, y)} is false, {@code hash(x) == hash(y)} may still be true.
   *   <li>{@code hash(null)} is {@code 0}.
   * </ul>
   */
  public final int hash(@CheckForNull T t) {
    if (t == null) {
      return 0;
    }

   *       y}, if {@code equivalent(x, y)}, then {@code hash(x) == hash(y)}. It is <i>not</i>
   *       necessary that the hash be distributable across <i>inequivalence</i>. If {@code
   *       equivalence(x, y)} is false, {@code hash(x) == hash(y)} may still be true.
   *   <li>{@code hash(null)} is {@code 0}.
   * </ul>
   */
  public final int hash(@CheckForNull T t) {
    if (t == null) {
      return 0;
    }

                    }
                }
                hash = buf.toString();
            } else {
                hash = StringUtil.EMPTY;
            }
        } else {
            hash = StringUtil.EMPTY;
        }

        if (!isFileSystemPath(targetUrl)) {
            return HtmlResponse.fromRedirectPathAsIs(DocumentUtil.encodeUrl(targetUrl + hash));
        }
        if (!fessConfig.isSearchFileProxyEnabled()) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.hash;

import com.google.common.collect.ImmutableList;
import com.google.common.hash.HashTestUtils.RandomHasherAction;
import java.io.ByteArrayOutputStream;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.List;
import java.util.Random;