// Test with SHA512
        OneWayCryptographer sha512 = OneWayCryptographer.createSha512Cryptographer();
        FessSecurityResourceProvider provider = new FessSecurityResourceProvider(invertibleCryptographer, sha512);

        assertNotNull(provider);
        assertEquals(invertibleCryptographer, provider.providePrimaryInvertibleCryptographer());
        assertEquals(sha512, provider.providePrimaryOneWayCryptographer());

    assertThat(sha512().newHasher().hash().toString()).isEqualTo(init);

    String asciiHash =
        "65d4ba90de6e2733e2364c8baf514b557d18fdda9c8227c68c2e7a7190d8888b4919f84ce412be8fa548298d36fe1f762b38c562bb147e04835e3a52f251ae34";
    assertThat(Files.hash(asciiFile, sha512()).toString()).isEqualTo(asciiHash);

    String i18nHash =

   * specific length.
   *
   * <p>For example, if you need 1024-bit hash codes, you could join two {@link Hashing#sha512} hash
   * functions together: {@code Hashing.concatenating(Hashing.sha512(), Hashing.sha512())}.
   *
   * @since 19.0
   */
  public static HashFunction concatenating(
      HashFunction first, HashFunction second, HashFunction... rest) {

        }

        final OneWayCryptographer oneWay;
        final String digestAlgorithm = fessConfig.getAppDigestAlgorithm();
        if ("sha512".equalsIgnoreCase(digestAlgorithm)) {
            oneWay = OneWayCryptographer.createSha512Cryptographer();
        } else if ("md5".equalsIgnoreCase(digestAlgorithm)) {

        "sha256/a",
      )
    }
  }

  @Test
  fun testBadAlgorithm() {
    assertFailsWith<IllegalArgumentException> {
      CertificatePinner.Pin(
        "example.co.uk",
        "sha512/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
      )
    }
  }

  @Test
  fun testBadHost() {
    assertFailsWith<IllegalArgumentException> {
      CertificatePinner.Pin(
        "example.*",

 * limitations under the License.
 */

package com.google.common.io;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.hash.Hashing.sha512;
import static com.google.common.io.TestOption.AVAILABLE_ALWAYS_ZERO;
import static com.google.common.io.TestOption.CLOSE_THROWS;
import static com.google.common.io.TestOption.OPEN_THROWS;

 * limitations under the License.
 */

package com.google.common.io;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.hash.Hashing.sha512;
import static com.google.common.io.TestOption.AVAILABLE_ALWAYS_ZERO;
import static com.google.common.io.TestOption.CLOSE_THROWS;
import static com.google.common.io.TestOption.OPEN_THROWS;

 *       The result is that, for example, when choosing a bucket in a hash table of size 2^8,
 *       <i>any</i> eight bits could be consistently used.
 *   <li><b>cryptographic:</b> certain hash functions such as {@link Hashing#sha512} are designed to
 *       make it as infeasible as possible to reverse-engineer the input that produced a given hash
 *       code, or even to discover <i>any</i> two distinct inputs that yield the same result. These

  }

  public void testSha512() {
    HashTestUtils.checkAvalanche(Hashing.sha512(), 100, 0.4);
    HashTestUtils.checkNo2BitCharacteristics(Hashing.sha512());
    HashTestUtils.checkNoFunnels(Hashing.sha512());
    HashTestUtils.assertInvariants(Hashing.sha512());
    assertThat(Hashing.sha512().toString()).isEqualTo("Hashing.sha512()");
  }

  public void testCrc32() {
    HashTestUtils.assertInvariants(Hashing.crc32());