// count == 0
    segment.setTableEntryForTesting(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));

    // count == 0
    segment.setTableEntryForTesting(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

            this.repositories.addAll(remoteRepositories);

            int hash = 17;
            hash = hash * 31 + artifactHashCode(artifact);
            hash = hash * 31 + (resolveManagedVersions ? 1 : 2);
            hash = hash * 31 + repositoriesHashCode(repositories);
            this.hashCode = hash;
        }

        @Override
        public int hashCode() {
            return hashCode;

    hash = shiftMix(hash) * mul;
    hash = shiftMix(hash);
    return hash;
  }

      return new byte[] {
        (byte) hash,
        (byte) (hash >> 8),
        (byte) (hash >> 16),
        (byte) (hash >> 24),
        (byte) (hash >> 32),
        (byte) (hash >> 40),
        (byte) (hash >> 48),
        (byte) (hash >> 56)
      };
    }

    @Override
    public int asInt() {
      return (int) hash;
    }

    @Override
    public long asLong() {

import (
	"bytes"
	"context"
	"errors"
	"hash"
	"io"
	"sync"

	xhttp "github.com/minio/minio/internal/http"
	"github.com/minio/minio/internal/ioutil"
	"github.com/minio/minio/internal/ringbuffer"
)

// Calculates bitrot in chunks and writes the hash into the stream.
type streamingBitrotWriter struct {
	iow          io.WriteCloser
	closeWithErr func(err error)
	h            hash.Hash
	shardSize    int64

				if err != nil {
					err = msgp.WrapError(err, "Algorithm")
					return
				}
				z.Algorithm = BitrotAlgorithm(zb0002)
			}
		case "Hash":
			z.Hash, err = dc.ReadBytes(z.Hash)
			if err != nil {
				err = msgp.WrapError(err, "Hash")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

    return (bits + 31) & ~31;
  }

  /**
   * Returns a hash function which computes its hash code by concatenating the hash codes of the
   * underlying hash functions together. This can be useful if you need to generate hash codes of a
   * specific length.
   *
   * <p>For example, if you need 1024-bit hash codes, you could join two {@link Hashing#sha512} hash

    }

    /**
     * Gets the selected hash algorithm.
     *
     * @return the hash algorithm
     */
    public int getSelectedHashAlgorithm() {
        return selectedHashAlgorithm;
    }

    /**
     * Calculates hash according to SMB 3.1.1 preauth integrity specification.
     *
     * @param previousHash the previous hash in the chain
     * @param messageData the message data to hash