}
  }

  @Test
  fun malformedBase64() {
    val builder = CertificatePinner.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.add("example.com", "sha1/DmxUShsZuNiqPQsX2Oi9uv2sCnw*")
    }
  }

  /** Multiple certificates generated from the same keypair have the same pin.  */
  @Test
  fun sameKeypairSamePin() {
    val heldCertificateA2 =
      HeldCertificate

   * minimum hashtable size, whichever is greater.
   */
  static int tableSize(int expectedSize) {
    // We use entries next == 0 to indicate UNSET, so actual capacity is 1 less than requested.
    return max(MIN_HASH_TABLE_SIZE, Hashing.closedTableSize(expectedSize + 1, 1.0));
  }

  /** Creates and returns a properly-sized array with the given number of buckets. */

     *
     * @see jcifs.BufferCache#releaseBuffer(byte[])
     */
    @Override
    public void releaseBuffer(final byte[] buf) {
        if (buf == null) {
            return;
        }
        // better safe than sorry: prevent leaks if there is some out of bound access
        Arrays.fill(buf, (byte) 0);
        synchronized (this.cache) {
            if (this.freeBuffers < this.cache.length) {

   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code
   * throws} clause: Java forces us to handle an arbitrary {@link Throwable} from that method,
   * rather than just the {@link RuntimeException} or {@link Error} that should be possible. (And in
   * fact the static type of {@link Throwable} is occasionally justified even for a method with no

        }
    }

    @Test
    void testConstructorWithLongKey() throws NoSuchAlgorithmException {
        // Test constructor with a key longer than BLOCK_LENGTH (64 bytes)
        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {
            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
            HMACT64 hmac = new HMACT64(LONG_TEST_KEY);

   * @since 15.0
   */
  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *
   * @param timeout the maximum time to wait
   * @param unit the time unit of the timeout argument
   * @throws TimeoutException if the service has not reached the given state within the deadline

 */
package jcifs.smb;

import jcifs.CIFSException;

/**
 * Exception thrown when an SMB protocol downgrade attack is detected.
 * Indicates that the negotiated protocol version is lower than expected or required.
 *
 * @author mbechler
 *
 */
public class SMBProtocolDowngradeException extends CIFSException {

    /**
     * Serial version UID for serialization compatibility.
     */

  @IgnoreJRERequirement
  static long toNanosSaturated(Duration duration) {
    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for
    // durations longer than approximately +/- 292 years).
    try {
      return duration.toNanos();
    } catch (ArithmeticException tooBig) {
      return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE;
    }
  }

    that empty artifact over the "real" listenablefuture-1.0 -- avoiding a
    conflict with the copy of ListenableFuture in guava itself. If users are
    using an older version of Guava or a build system other than Gradle, they
    may see class conflicts. If so, they can solve them by manually excluding
    the listenablefuture artifact or manually forcing their build systems to
    use 9999.0-....
  </description>
  <build>

 * the <i>count</i> of that element (the terms "frequency" and "multiplicity" are equivalent, but
 * not used in this API). Since the count of an element is represented as an {@code int}, a multiset
 * may never contain more than {@link Integer#MAX_VALUE} occurrences of any one element.
 *
 * <p>{@code Multiset} refines the specifications of several methods from {@code Collection}. It