private static long countBySkipping(InputStream in) throws IOException {
    long count = 0;
    long skipped;
    while ((skipped = skipUpTo(in, Integer.MAX_VALUE)) > 0) {
      count += skipped;
    }
    return count;
  }

  /**
   * Copies the contents of this byte source to the given {@code OutputStream}. Does not close
   * {@code output}.
   *

  }

  public void testTryFind() {
    Iterable<String> list = newArrayList("cool", "pants");
    assertThat(tryFind(list, equalTo("cool"))).hasValue("cool");
    assertThat(tryFind(list, equalTo("pants"))).hasValue("pants");
    assertThat(tryFind(list, Predicates.alwaysTrue())).hasValue("cool");
    assertThat(tryFind(list, Predicates.alwaysFalse())).isAbsent();
    assertCanIterateAgain(list);
  }

    }

    @Test
    @DisplayName("Test with maximum values")
    void testWithMaximumValues() {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", 0xFFFF, 65535, Integer.MAX_VALUE);

        byte[] buffer = new byte[256];
        int written = trans2FindFirst2.writeParametersWireFormat(buffer, 0);

        // Verify search attributes are still masked

      return count(element);
    }
    int index = element.ordinal();
    int oldCount = counts[index];
    long newCount = (long) oldCount + occurrences;
    checkArgument(newCount <= Integer.MAX_VALUE, "too many occurrences: %s", newCount);
    counts[index] = (int) newCount;
    if (oldCount == 0) {
      distinctElements++;
    }
    size += occurrences;
    return oldCount;
  }

  public static final class ImmutableLongArrayHeadSubListAsListGenerator
      extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {
      Long[] suffix = {Long.MIN_VALUE, Long.MAX_VALUE};
      Long[] all = concat(elements, suffix);
      return makeArray(all).subArray(0, elements.length).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite

      @SuppressWarnings("unchecked")
      K castKey = (K) key;
      @SuppressWarnings("unchecked") // similar to the above
      V castValue = (V) value;

      alertListenerIfPresent(castKey, castValue, RemovalCause.EXPLICIT);
      remove(key);
      return true;
    }
    return false;
  }

  @Override
  public boolean replace(K key, V oldValue, V newValue) {

    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> builder.addAll(nCopies(Integer.MAX_VALUE - 50, "a")));
    assertThat(expected)
        .hasMessageThat()
        .contains("cannot store more than Integer.MAX_VALUE elements");
  }

        if (rows == Integer.MIN_VALUE) {
            return scrollDown(Integer.MAX_VALUE);
        }
        return rows > 0 ? appendEscapeSequence('S', rows) : rows < 0 ? scrollDown(-rows) : this;
    }

    public Ansi scrollDown(final int rows) {
        if (rows == Integer.MIN_VALUE) {
            return scrollUp(Integer.MAX_VALUE);
        }

    static final int DEFAULT_INITIAL_CAPACITY = 4;

    static int expandedCapacity(int oldCapacity, int minCapacity) {
      if (minCapacity < 0) {
        throw new IllegalArgumentException("cannot store more than Integer.MAX_VALUE elements");
      } else if (minCapacity <= oldCapacity) {
        return oldCapacity;
      }
      // careful of overflow!
      int newCapacity = oldCapacity + (oldCapacity >> 1) + 1;

  }

  // cloned from ImmutableCollection
  private static int expandedCapacity(int oldCapacity, int minCapacity) {
    if (minCapacity < 0) {
      throw new IllegalArgumentException("cannot store more than Integer.MAX_VALUE elements");
    } else if (minCapacity <= oldCapacity) {
      return oldCapacity;
    }
    // careful of overflow!
    int newCapacity = oldCapacity + (oldCapacity >> 1) + 1;
    if (newCapacity < minCapacity) {