super(delegate);
    this.delegate = delegate;
  }

  @Override
  public final ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
    return delegate.schedule(wrapTask(command), delay, unit);
  }

  @Override
  public final <V extends @Nullable Object> ScheduledFuture<V> schedule(
      Callable<V> task, long delay, TimeUnit unit) {

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  public <T> T newProxy(
      T target, Class<T> interfaceType, long timeoutDuration, TimeUnit timeoutUnit) {
    checkNotNull(target);
    checkNotNull(interfaceType);
    checkNotNull(timeoutUnit);
    return target; // ha ha
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  @ParametricNullness

    }

    @Override
    public String getGroupId() {
        return metadata.getGroupId();
    }

    @Override
    public String getArtifactId() {
        return metadata.getArtifactId();
    }

    @Override
    public String getVersion() {
        return metadata.getVersion();
    }

    @Override
    public Nature getNature() {

    @Override
    public boolean equals(Object vo) {
        if (!(vo instanceof MetadataGraphVertex)) {
            return false;
        }
        return compareTo((MetadataGraphVertex) vo) == 0;
    }

    // ---------------------------------------------------------------------

    @Override
    public int hashCode() {
        if (md == null) {

    super(allowsNullKeys, allowsNullValues, supportsPut, supportsRemove, supportsClear);
  }

  @Override
  protected abstract SortedMap<K, V> makeEmptyMap() throws UnsupportedOperationException;

  @Override
  protected abstract SortedMap<K, V> makePopulatedMap() throws UnsupportedOperationException;

  @Override
  protected SortedMap<K, V> makeEitherMap() {
    try {
      return makePopulatedMap();

  int size; // logarithmic triangular

  @Param boolean mutable;

  @Param InputOrder inputOrder;

  enum InputOrder {
    SORTED {
      @Override
      void arrange(List<Integer> list) {
        sort(list);
      }
    },
    ALMOST_SORTED {
      @Override
      void arrange(List<Integer> list) {
        sort(list);
        if (list.size() > 1) {
          int i = (list.size() - 1) / 2;

public class OpenJdk6MapTests extends TestsForMapsInJavaUtil {
  public static Test suite() {
    return new OpenJdk6MapTests().allTests();
  }

  @Override
  protected Collection<Method> suppressForTreeMapNatural() {
    return asList(
        getPutNullKeyUnsupportedMethod(),
        getPutAllNullKeyUnsupportedMethod(),
        getCreateWithNullKeyUnsupportedMethod(),

import org.opensearch.client.Client;
import org.opensearch.common.unit.TimeValue;
import org.opensearch.index.query.QueryBuilder;

public class SuggestIndexWriter implements SuggestWriter {
    @Override
    public SuggestWriterResult write(final Client client, final SuggestSettings settings, final String index, final SuggestItem[] items,
            final boolean update) {

     * @see jcifs.internal.smb1.ServerMessageBlock#getResponse()
     */
    @Override
    public final SmbComNTCreateAndXResponse getResponse () {
        return (SmbComNTCreateAndXResponse) super.getResponse();
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.Request#initResponse(jcifs.CIFSContext)
     */
    @Override
    public SmbComNTCreateAndXResponse initResponse ( CIFSContext tc ) {

internal class UnreadableResponseBody(
  private val mediaType: MediaType?,
  private val contentLength: Long,
) : ResponseBody(), Source {
  override fun contentType() = mediaType

  override fun contentLength() = contentLength

  override fun source() = buffer()

  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long {
    throw IllegalStateException(
      """