for (int toRemove = 0; toRemove < 10; toRemove++) {
          assertEquals(
              contents.contains(toRemove) && EVEN.apply(toRemove),
              filter(createUnfiltered(contents), EVEN).remove(toRemove));
        }
      }
    }

    public void testContains() {
      for (List<Integer> contents : SAMPLE_INPUTS) {
        for (int i = 0; i < 10; i++) {
          assertEquals(

    protected String scrollForSearch = "1m";

    protected int sizeForDelete = 100;

    protected String scrollForDelete = "1m";

    protected int sizeForUpdate = 100;

    protected String scrollForUpdate = "1m";

    protected int maxConfigSyncStatusRetry = 10;

    protected int maxEsStatusRetry = 60;

    protected String clusterName = "fesen";

   * @param hc the hash code holder
   * @param wasUncontended false if CAS failed before call
   */
  final void retryUpdate(long x, @CheckForNull int[] hc, boolean wasUncontended) {
    int h;
    if (hc == null) {
      threadHashCode.set(hc = new int[1]); // Initialize randomly
      int r = rng.nextInt(); // Avoid zero to allow xorShift rehash
      h = hc[0] = (r == 0) ? 1 : r;
    } else h = hc[0];

 */

package jcifs.dcerpc.ndr;


@SuppressWarnings ( "javadoc" )
public class NdrLong extends NdrObject {

    public int value;


    public NdrLong ( int value ) {
        this.value = value;
    }


    @Override
    public void encode ( NdrBuffer dst ) throws NdrException {
        dst.enc_ndr_long(this.value);
    }

 */

package jcifs.dcerpc.ndr;


@SuppressWarnings ( "javadoc" )
public class NdrSmall extends NdrObject {

    public int value;


    public NdrSmall ( int value ) {
        this.value = value & 0xFF;
    }


    @Override
    public void encode ( NdrBuffer dst ) throws NdrException {
        dst.enc_ndr_small(this.value);
    }

	// The maximum number of entries to return
	count int
	// Follow directory symlink
	followDirSymlink bool
}

// Return all the entries at the directory dirPath.
func readDir(dirPath string) (entries []string, err error) {
	return readDirWithOpts(dirPath, readDirOpts{count: -1})
}

// Return up to count entries at the directory dirPath.
func readDirN(dirPath string, count int) (entries []string, err error) {

 */
@GwtCompatible
public class BaseComparable implements Comparable<BaseComparable>, Serializable {
  private final String s;

  public BaseComparable(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;

  static void clear(Buffer b) {
    b.clear();
  }

  static void flip(Buffer b) {
    b.flip();
  }

  static void limit(Buffer b, int limit) {
    b.limit(limit);
  }

  static void mark(Buffer b) {
    b.mark();
  }

  static void position(Buffer b, int position) {
    b.position(position);
  }

  static void reset(Buffer b) {
    b.reset();
  }

  private Java8Compatibility() {}

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

    static final int INVERSE_COMPUTE_FOR_WORD_OF_ALL_1S = 0xeee3ddcd;

    static int computeForWord(int word) {
      return STRIDE_TABLE[3][word & 0xFF]
          ^ STRIDE_TABLE[2][(word >>> 8) & 0xFF]
          ^ STRIDE_TABLE[1][(word >>> 16) & 0xFF]
          ^ STRIDE_TABLE[0][word >>> 24];
    }

    static int combine(int csum, int crc) {
      csum ^= crc;