throw new SmbException("not used in tests");
        }

        @Override
        public Subject getSubject() {
            return null; // not relevant for renew() behavior
        }

        @Override
        public void refresh() throws CIFSException {
            // no-op for tests
        }

        @Override
        public boolean isGuest() {
            return false; // not guest for test purposes

                new NoOpValueAndCloserConsumer<>(), finishToValueAndCloserExecutor));
  }

  @Override
  <T> T getFinalValue(ClosingFuture<T> closingFuture) throws ExecutionException {
    return finishToValueAndCloser(closingFuture).get();
  }

  @Override
  void assertFinallyFailsWithException(ClosingFuture<?> closingFuture) {
    assertThatFutureFailsWithException(closingFuture.statusFuture());

      this.length = length;
    }

    @Override
    public int size() {
      return length;
    }

    @Override
    @Nullable Object @Nullable [] internalArray() {
      return ImmutableList.this.internalArray();
    }

    @Override
    int internalArrayStart() {
      return ImmutableList.this.internalArrayStart() + offset;
    }

    @Override
    int internalArrayEnd() {

) : X509ExtendedTrustManager() {
  override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers

  override fun checkServerTrusted(
    chain: Array<out X509Certificate>,
    authType: String,
    socket: Socket,
  ) {
    if (socket.peerName() !in insecureHosts) {
      delegate.checkServerTrusted(chain, authType, socket)
    }
  }

  override fun checkServerTrusted(

        dstIndex += 4;

        return dstIndex - start;
    }

    @Override
    int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {

    this.delegate = checkNotNull(delegate);
  }

  @Override
  public void addListener(Runnable listener, Executor executor) {
    delegate.addListener(listener, executor);
  }

  @Override
  public boolean cancel(boolean mayInterruptIfRunning) {
    return delegate.cancel(mayInterruptIfRunning);
  }

  @Override
  public boolean isCancelled() {
    return delegate.isCancelled();
  }

    }

    @Override
    public int getMinorVersion() {
        return minorVersion != null ? minorVersion : 0;
    }

    @Override
    public int getIncrementalVersion() {
        return incrementalVersion != null ? incrementalVersion : 0;
    }

    @Override
    public int getBuildNumber() {
        return buildNumber != null ? buildNumber : 0;
    }

    @Override
    public String getQualifier() {

            public InputStream getInputStream() {
                return inputStream;
            }

            @Override
            public Reader getReader() {
                return reader;
            }

            @Override
            public Transformer getTransformer() {
                return transformer;
            }

            @Override
            public boolean isStrict() {

   */
  protected AbstractListMultimap(Map<K, Collection<V>> map) {
    super(map);
  }

  @Override
  abstract List<V> createCollection();

  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  @Override
  List<V> createUnmodifiableEmptyCollection() {
    return emptyList();
  }

  @Override
  <E extends @Nullable Object> Collection<E> unmodifiableCollectionSubclass(

 * without changing its state, so the tester needs a steady supply of fresh Iterators.
 *
 * <p>If your iterator supports modification through {@code remove()}, you may wish to override the
 * verify() method, which is called after each sequence and is guaranteed to be called
 * using the latest values obtained from {@link IteratorTester#newTargetIterator()}.
 *