}
    }
    return null;
  }

  private static <T> T createEmptyArray(Class<T> arrayType) {
    // getComponentType() is non-null because we call createEmptyArray only with an array type.
    return arrayType.cast(Array.newInstance(requireNonNull(arrayType.getComponentType()), 0));
  }

  // Internal implementations of some classes, with public default constructor that get() needs.
  private static final class Dummies {

        assertNotNull(buffer, "getBuffer should never return null");
        assertSame(expectedBuffer, buffer, "Should return configured buffer");
    }

    @Test
    @DisplayName("releaseBuffer should accept byte arrays gracefully")
    void testReleaseBufferContract() {
        // Given
        byte[] buffer = new byte[1024];
        doNothing().when(mockBufferCache).releaseBuffer(buffer);

        // When & Then

      throw new ArrayIndexOutOfBoundsException("Required array size too large: " + longSize);
    }

    char[] array = new char[size];
    string.getChars(0, len, array, 0);
    int n;
    for (n = len; n < size - n; n <<= 1) {
      System.arraycopy(array, 0, array, n, n);
    }
    System.arraycopy(array, 0, array, n, size - n);
    return new String(array);
  }

  /**

      if (object instanceof ConcatenatedHashFunction) {
        ConcatenatedHashFunction other = (ConcatenatedHashFunction) object;
        return Arrays.equals(functions, other.functions);
      }
      return false;
    }

    @Override
    public int hashCode() {
      return Arrays.hashCode(functions);
    }
  }

  /**
   * Linear CongruentialGenerator to use for consistent hashing. See

  }

  private static <X extends Exception> X newWithCause(Class<X> exceptionClass, Throwable cause) {
    // getConstructors() guarantees this as long as we don't modify the array.
    @SuppressWarnings({"unchecked", "rawtypes"})
    List<Constructor<X>> constructors = (List) Arrays.asList(exceptionClass.getConstructors());
    for (Constructor<X> constructor : preferringStringsThenThrowables(constructors)) {

import static com.google.common.collect.Iterables.getOnlyElement;
import static com.google.common.collect.Iterables.unmodifiableIterable;
import static com.google.common.reflect.Reflection.newProxy;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtIncompatible;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;

        }
        return id;
    }

    /**
     * Parses the given query string and returns an array of keywords.
     *
     * @param q the query string to be parsed
     * @param field the field to be used for keyword extraction
     * @return an array of keywords extracted from the query string, or an empty array if the number of keywords exceeds the maximum allowed or if any keyword exceeds the maximum length
     */

    long b = (v ^ a) * mul;
    b ^= b >>> 47;
    b *= mul;
    return b;
  }

  /**
   * Computes intermediate hash of 32 bytes of byte array from the given offset. Results are
   * returned in the output array because when we last measured, this was 12% faster than allocating
   * new arrays every time.
   */
  private static void weakHashLength32WithSeeds(
      byte[] bytes, int offset, long seedA, long seedB, long[] output) {

import static junit.framework.Assert.assertTrue;

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.function.BiPredicate;
import java.util.stream.Collector;
import org.jspecify.annotations.NullMarked;

            // When
            byte[] result = Strings.getBytes(null, StandardCharsets.UTF_8);

            // Then
            assertNotNull(result, "Should return non-null array");
            assertEquals(0, result.length, "Should return empty array for null string");
        }

        @Test
        @DisplayName("getBytes should encode string with specified charset")
        void testGetBytesWithCharset() {
            // When