}

        byte[] key = null;
        byte[] keyCopy = null;

        try {
            // Get the key and create a defensive copy for SecretKeySpec
            key = encrypt ? getEncryptionKey() : getDecryptionKey();
            keyCopy = Arrays.copyOf(key, key.length);

            // Validate key length matches expected cipher requirements
            if (keyCopy.length != keyLength) {

   * the current capacity.
   */
  void resizeEntries(int newCapacity) {
    this.entries = Arrays.copyOf(requireEntries(), newCapacity);
    this.keys = Arrays.copyOf(requireKeys(), newCapacity);
    this.values = Arrays.copyOf(requireValues(), newCapacity);
  }

  @CanIgnoreReturnValue
  private int resizeTable(int oldMask, int newCapacity, int targetHash, int targetEntryIndex) {

/** Returns an immutable copy of this. */
@Suppress("UNCHECKED_CAST")
internal fun <T> List<T>.toImmutableList(): List<T> =
  when {
    this.isEmpty() -> emptyList()
    this.size == 1 -> Collections.singletonList(this[0])
    // Collection.toArray returns Object[] (covariant).
    // It is faster than creating real T[] via reflection (Arrays.copyOf).

   *     array}, plus {@code element} occupying the last position.
   */
  public static <T extends @Nullable Object> T[] concat(T[] array, @ParametricNullness T element) {
    T[] result = Arrays.copyOf(array, array.length + 1);
    result[array.length] = element;
    return result;
  }

  /**
   * Returns an array containing all of the elements in the specified collection; the runtime type

    for (int bytes = 0; bytes < totalBytes; bytes++) {
      byte[] bb = new byte[bytes];
      hashCode.writeBytesTo(bb, 0, bb.length);

      assertTrue(Arrays.equals(Arrays.copyOf(hashBytes, bytes), bb));
    }
  }

  private static class ExpectedHashCode {
    final byte[] bytes;
    final int asInt;
    final Long asLong; // null means that asLong should throw an exception

    // would cause one to be evicted.
    return new CacheBuilderFactory()
        .withKeyStrengths(ImmutableSet.of(Strength.STRONG, Strength.WEAK))
        .withValueStrengths(ImmutableSet.copyOf(Strength.values()))
        .withConcurrencyLevels(ImmutableSet.of(1, 4, 16, 64))
        .withMaximumSizes(ImmutableSet.of(400, 1000))
        .withInitialCapacities(ImmutableSet.of(0, 1, 10, 100, 1000))

    NamedObject(String name) {
      this.name = Preconditions.checkNotNull(name);
    }

    @CanIgnoreReturnValue
    NamedObject addPeers(String... names) {
      peerNames.addAll(ImmutableList.copyOf(names));
      return this;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof NamedObject) {
        NamedObject that = (NamedObject) obj;

    return new ImmutableRangeMap<>(ImmutableList.of(range), ImmutableList.of(value));
  }

  @SuppressWarnings("unchecked")
  public static <K extends Comparable<?>, V> ImmutableRangeMap<K, V> copyOf(
      RangeMap<K, ? extends V> rangeMap) {
    if (rangeMap instanceof ImmutableRangeMap) {
      return (ImmutableRangeMap<K, V>) rangeMap;
    }
    Map<Range<K>, ? extends V> map = rangeMap.asMapOfRanges();

        final int seq = SMBUtil.readInt4(mic, 12);
        mac.update(mic, 12, 4); // sequence
        final byte[] dgst = mac.digest(data); // data
        byte[] trunc = Arrays.copyOf(dgst, 8);

        if (log.isDebugEnabled()) {
            log.debug("Digest " + Hexdump.toHexString(dgst));
            log.debug("Truncated " + Hexdump.toHexString(trunc));
        }

    return concat(ImmutableList.copyOf(sources));
  }

  /**
   * Returns a view of the given byte array as a {@link ByteSource}. To view only a specific range
   * in the array, use {@code ByteSource.wrap(b).slice(offset, length)}.
   *
   * <p>Note that the given byte array may be passed directly to methods on, for example, {@code
   * OutputStream} (when {@code copyTo(OutputStream)} is called on the resulting {@code