* using a secondary hash (Marsaglia XorShift) to try to find a
   * free slot.
   *
   * The table size is capped because, when there are more threads
   * than CPUs, supposing that each thread were bound to a CPU,
   * there would exist a perfect hash function mapping threads to
   * slots that eliminates collisions. When we reach capacity, we

  E copyEntry(E original, E newNext) {
    int hash = original.getHash();
    return segmentFor(hash).copyEntry(original, newNext);
  }

  int hash(Object key) {
    int h = keyEquivalence.hash(key);
    return rehash(h);
  }

  void reclaimValue(WeakValueReference<K, V, E> valueReference) {
    E entry = valueReference.getEntry();
    int hash = entry.getHash();

            dstIndex += this.blob.length;
        } else {
            System.arraycopy(this.lmHash, 0, dst, dstIndex, this.lmHash.length);
            dstIndex += this.lmHash.length;
            System.arraycopy(this.ntHash, 0, dst, dstIndex, this.ntHash.length);
            dstIndex += this.ntHash.length;

            dstIndex += writeString(this.accountName, dst, dstIndex);

        assertEquals("guest", accountName);
        assertEquals("DOM", primaryDomain);

        byte[] lm = (byte[]) getField(obj, "lmHash");
        byte[] nt = (byte[]) getField(obj, "ntHash");
        assertArrayEquals(new byte[0], lm);
        assertArrayEquals(new byte[0], nt);
    }

    @Test
    void unsupportedCredentialType() {

            dstIndex += blob.length;
        } else {
            System.arraycopy(lmHash, 0, dst, dstIndex, lmHash.length);
            dstIndex += lmHash.length;
            System.arraycopy(ntHash, 0, dst, dstIndex, ntHash.length);
            dstIndex += ntHash.length;

            dstIndex += writeString(accountName, dst, dstIndex);

	hash := hashPath(path)
	if d.Cache == nil {
		d.Cache = make(map[string]dataUsageEntry, 100)
	}
	d.Cache[hash.Key()] = e
	if parent != "" {
		phash := hashPath(parent)
		p := d.Cache[phash.Key()]
		p.addChild(hash)
		d.Cache[phash.Key()] = p
	}
}

// replaceHashed add or replaces an entry to the cache based on its hash.

    size--;
    modCount++;
  }

  /** Removes the entry at the specified index, given the hash of its key. */
  void removeEntryKeyHashKnown(int entry, int keyHash) {
    removeEntry(entry, keyHash, Hashing.smearedHash(values[entry]));
  }

  /** Removes the entry at the specified index, given the hash of its value. */
  void removeEntryValueHashKnown(int entry, int valueHash) {

    assertNull(segment.get(key, hash));

    // count == 0
    table.set(index, entry);
    assertNull(segment.get(key, hash));
    assertFalse(segment.containsKey(key, hash));
    assertFalse(segment.containsValue(value));

    // count == 1
    segment.count++;
    assertSame(value, segment.get(key, hash));
    assertTrue(segment.containsKey(key, hash));
    assertTrue(segment.containsValue(value));

        // Verify hash is not null
        byte[] hash = transport.getPreauthIntegrityHash();
        assertNotNull(hash);

        // Verify hash is a copy, not the original
        byte[] hash2 = transport.getPreauthIntegrityHash();
        assertNotSame(hash, hash2);
        assertArrayEquals(hash, hash2);
    }

    /**
     * Test that pre-auth hash is reset on error
     */
    @Test

import org.bouncycastle.util.encoders.Hex;

/**
 * Authenticator directly specifing the user's NT hash
 *
 * @author mbechler
 *
 */
public class NtlmNtHashAuthenticator extends NtlmPasswordAuthenticator {

    private static final long serialVersionUID = 4328214169536360351L;
    /** The NT hash for authentication */
    private final byte[] ntHash;

    /**
     * Create username/password credentials with specified domain
     *