* where this collection's elements start.
   */
  int internalArrayStart() {
    throw new UnsupportedOperationException();
  }

  /**
   * If this collection is backed by an array of its elements in insertion order, returns the offset
   * where this collection's elements end.
   */
  int internalArrayEnd() {
    throw new UnsupportedOperationException();
  }

  @Override

     */
    public static int copy(final byte[] in, final Writer out) {
        assertArgumentNotNull("in", in);
        assertArgumentNotNull("out", out);

        final Reader is = new InputStreamReader(new ByteArrayInputStream(in));
        return copyInternal(is, wrap(out));
    }

    /**
     * Copies from a byte array to a writer using the specified encoding.
     * <p>

     */
    protected final Object inLock = new Object();
    /**
     * Lock object for synchronizing output operations
     */
    protected final Object outLock = new Object();

    /**
     * Map for tracking pending responses by their key
     */
    protected final Map<Long, Response> response_map = new ConcurrentHashMap<>(10);
    private final AtomicLong usageCount = new AtomicLong(1);

    /**

            .sorted(comparing(ChangelogEntry.Deprecation::getTitle))
            .collect(groupingBy(ChangelogEntry.Deprecation::getArea, TreeMap::new, Collectors.toList()));

        final Map<String, Object> bindings = new HashMap<>();
        bindings.put("breakingChangesByNotabilityByArea", breakingChangesByNotabilityByArea);
        bindings.put("deprecationsByArea", deprecationsByArea);

        List<String> recessiveActiveProfiles = recessive.getActiveProfiles();

        if (recessiveActiveProfiles != null) {
            if (dominantActiveProfiles == null) {
                dominantActiveProfiles = new ArrayList<>();
                dominant.setActiveProfiles(dominantActiveProfiles);
            }

            for (String profileId : recessiveActiveProfiles) {
                if (!dominantActiveProfiles.contains(profileId)) {

    this.loadFactor = loadFactor;

    this.keys = new @Nullable Object[expectedSize];
    this.values = new int[expectedSize];

    this.entries = newEntries(expectedSize);
    this.threshold = Math.max(1, (int) (buckets * loadFactor));
  }

  private static int[] newTable(int size) {
    int[] array = new int[size];
    Arrays.fill(array, UNSET);
    return array;
  }

        return asJson(new ApiConfigResponse().setting(dataConfigService.getDataConfig(id).map(this::createEditBody).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id));
            return null;
        })).status(Status.OK).result());
    }

    /**
     * Creates a new data config setting.
     *

        byte[] outputBuffer = new byte[testData.length + 100];
        int writtenBytes =
                compressionService.decompress(compressed, 0, compressed.length, outputBuffer, 50, CompressionService.COMPRESSION_LZ77);

        assertEquals(testData.length, writtenBytes);

        byte[] extracted = new byte[testData.length];

        List<TaskProvider<Test>> windowsTestTasks = new ArrayList<>();
        Map<ElasticsearchDistributionType, List<TaskProvider<Test>>> linuxTestTasks = new HashMap<>();
        Map<String, List<TaskProvider<Test>>> upgradeTestTasks = new HashMap<>();
        Map<String, TaskProvider<?>> depsTasks = new HashMap<>();

        for (ElasticsearchDistribution distribution : testDistributions) {

 */
@NullUnmarked
public class ForwardingListMultimapTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            ListMultimap.class,
            new Function<ListMultimap, ListMultimap<?, ?>>() {
              @Override
              public ListMultimap<?, ?> apply(ListMultimap delegate) {