@Override
  void setCountCheckReturnValue(E element, int count) {
    assertTrue(
        "setCount() with the correct expected present count should return true",
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private boolean setCount(E element, int count) {

            IndexWriter w = new IndexWriter(
                directory,
                new IndexWriterConfig().setOpenMode(OpenMode.CREATE).setRAMBufferSizeMB(indexingBufferMb)
            )
        ) {
            for (int i = 1; i <= 1_000_000; i++) {
                w.addDocument(List.of(new SortedNumericDocValuesField("n", i)));
            }
            w.commit();
        }
        reader = DirectoryReader.open(directory);
    }

  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];
    array[nullKeyLocation] = mapEntry(null, oldEntry.getValue());
    return array;
  }

  /**

      checkNotNull(mutex);
      this.delegate = delegate;
      this.mutex = mutex;
    }

    @Override
    protected Map<K, V> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return super.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return super.isEmpty();
    }

        });
    }

    /**
     * Generates test data with repeating patterns for good compression.
     */
    private byte[] generateTestData(int size) {
        byte[] data = new byte[size];

        // Create data with repeating patterns
        for (int i = 0; i < size; i++) {
            if (i % 100 < 50) {
                data[i] = (byte) 'A';
            } else if (i % 100 < 75) {

}

// TransitionDays is a type alias to unmarshal Days in Transition
type TransitionDays int

// UnmarshalXML parses number of days from Transition and validates if
// >= 0
func (tDays *TransitionDays) UnmarshalXML(d *xml.Decoder, startElement xml.StartElement) error {
	var days int
	err := d.DecodeElement(&days, &startElement)
	if err != nil {
		return err
	}

	if days < 0 {

pkg net, method (*IPConn) ReadMsgIP([]uint8, []uint8) (int, int, int, *IPAddr, error)
pkg net, method (*IPConn) WriteMsgIP([]uint8, []uint8, *IPAddr) (int, int, error)
pkg net, method (*UDPConn) ReadMsgUDP([]uint8, []uint8) (int, int, int, *UDPAddr, error)
pkg net, method (*UDPConn) WriteMsgUDP([]uint8, []uint8, *UDPAddr) (int, int, error)
pkg net, method (*UnixConn) CloseRead() error

  public boolean hasPrevious() {
    return delegate().hasPrevious();
  }

  @Override
  public int nextIndex() {
    return delegate().nextIndex();
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public E previous() {
    return delegate().previous();
  }

  @Override
  public int previousIndex() {
    return delegate().previousIndex();
  }

  @Override

     * @throws IOException if an I/O error occurs during handle creation
     */
    public SamrAliasHandle(final DcerpcHandle handle, final SamrDomainHandle domainHandle, final int access, final int rid)
            throws IOException {
        this.handle = handle;
        final MsrpcSamrOpenAlias rpc = new MsrpcSamrOpenAlias(domainHandle, access, rid, this);
        handle.sendrecv(rpc);

        assertArgumentNotNull("jarFile", jarFile);
        assertArgumentNotNull("prefix", prefix);
        assertArgumentNotNull("handler", handler);

        final int startPos = prefix.length();
        for (final JarEntry entry : iterable(jarFile.entries())) {
            final String entryName = entry.getName().replace('\\', '/');