* through. So, we override the correctedDo* methods, after which the do* methods should never
     * be reached.
     */

    @Override
    protected A doForward(B b) {
      throw new AssertionError();
    }

    @Override
    protected B doBackward(A a) {
      throw new AssertionError();
    }

    @Override
    @Nullable A correctedDoForward(@Nullable B b) {

   * {@link #successors(Object)}.
   */
  @Override
  public Set<EndpointPair<N>> edges() {
    return new AbstractSet<EndpointPair<N>>() {
      @Override
      public UnmodifiableIterator<EndpointPair<N>> iterator() {
        return EndpointPairIterator.of(AbstractBaseGraph.this);
      }

      @Override
      public int size() {
        return Ints.saturatedCast(edgeCount());
      }

        @Override
        public void setCreateTime(Long createTime) {
        }

        @Override
        public void setLastModified(Long lastModified) {
        }

        @Override
        public void setDepth(Integer depth) {
        }

        @Override
        public void setParentUrl(String parentUrl) {
        }

        @Override
        public void setUrl(String url) {
        }

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

  @Override
  public void shutdown() {
    delegate().shutdown();
  }

  @Override
  @CanIgnoreReturnValue
  public List<Runnable> shutdownNow() {
    return delegate().shutdownNow();
  }

  @Override
  public void execute(Runnable command) {
    delegate().execute(command);
  }

  @Override

        @Override
        public java.util.Enumeration<String> getAttributeNames() {
            return null;
        }

        @Override
        public String getContextPath() {
            return "";
        }

        @Override
        public jakarta.servlet.ServletContext getContext(String uripath) {
            return null;
        }

        @Override
        public int getMajorVersion() {

        .build(),
    )
    val asyncRequestBody: RequestBody =
      object : RequestBody() {
        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("Hello request!")
          sink.close()
        }

        override fun isDuplex(): Boolean = true
      }
    val request =
      request()
        .post(asyncRequestBody)

        }

        @Override
        public String getUNCPath() {
            return null;
        }

        @Override
        public String getURLPath() {
            return null;
        }

        @Override
        public String getShare() {
            return null;
        }

        @Override
        public String getServerWithDfs() {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public abstract class AbstractListIndexOfTester<E> extends AbstractListTester<E> {
  /** Override to call {@code indexOf()} or {@code lastIndexOf()}. */
  protected abstract int find(@Nullable Object o);

  /** Override to return "indexOf" or "lastIndexOf()" for use in failure messages. */
  protected abstract String getMethodName();

  @CollectionSize.Require(absent = ZERO)

        this.timeoutSpecified = true;
        this.timeout = timeout;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt8(this.timeout, dst, dstIndex);
        dstIndex += 8;

     *
     * <p>The default implementation does nothing. Subclasses should override this method
     * if they need to perform cleanup operations.</p>
     *
     * @throws InvokerException if an error occurs while closing the {@link Invoker}
     */
    @Override
    default void close() throws InvokerException {}