*
     * @param delegate
     *            context to delegate non-override methods to
     *
     */
    public CIFSContextWrapper(final CIFSContext delegate) {
        this.delegate = delegate;
    }

    /**
     * {@inheritDoc}
     *
     * @throws CIFSException if the URL is malformed or there is an error creating the SMB resource
     *
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override

        // Assert
        verify(delegate, times(1)).remove();
    }

    @Test
    @DisplayName("Edge: empty delegate yields no elements")
    void emptyDelegate_hasNoNext() {
        // Arrange - no parent setup needed since no URLs are created
        when(delegate.hasNext()).thenReturn(false);

        NetServerFileEntryAdapterIterator itr = new NetServerFileEntryAdapterIterator(parent, delegate, null);

        // Assert

 * @author Chris Nokleberg
 */
@J2ktIncompatible
@GwtIncompatible
abstract class WrappingExecutorService implements ExecutorService {
  private final ExecutorService delegate;

  protected WrappingExecutorService(ExecutorService delegate) {
    this.delegate = checkNotNull(delegate);
  }

  /**
   * Wraps a {@code Callable} for submission to the underlying executor. This method is also applied

        // Then
        assertTrue(smb2Only, "Should delegate SMB2 only negotiation");
        assertFalse(secureNegotiate, "Should delegate secure negotiate requirement");
        assertTrue(ntlmTargetName, "Should delegate NTLM target name setting");
        assertFalse(port139Failover, "Should delegate port 139 failover setting");
        assertTrue(dfsStrictView, "Should delegate DFS strict view setting");

     * @param delegate
     *            delegate to pass all non-overridden method calls to
     *
     */
    public DelegatingConfiguration(final Configuration delegate) {
        this.delegate = delegate;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#getRandom()
     */
    @Override
    public SecureRandom getRandom() {
        return this.delegate.getRandom();
    }

    /**

            assertFalse(result);
            verify(delegate, never()).accept(any());
        }

        @Test
        void resourceFilterWrapper_accept_trueDelegatesToFilter() throws Exception {
            // Arrange
            SmbFileFilter delegate = mock(SmbFileFilter.class);
            Object wrapper = newPrivateInner("ResourceFilterWrapper", new Class<?>[] { SmbFileFilter.class }, delegate);

    private final ProgressListener progressListener;
    private final RequestBody delegate;

    public ProgressRequestBody(RequestBody delegate, ProgressListener progressListener) {
      this.delegate = delegate;
      this.progressListener = progressListener;
    }

    @Override
    public MediaType contentType() {
      return delegate.contentType();
    }

    @Override

    private final Deque<E> delegate = new LinkedList<>();
    private final Object mutex = new Object[0]; // something Serializable

    @Override
    public boolean offer(E o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.offer(o);
    }

    @Override
    public @Nullable E poll() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.poll();
    }

    @Override

  if (this is QueueDispatcher) return this.delegate

  val delegate = this
  return object : mockwebserver3.Dispatcher() {
    override fun dispatch(request: mockwebserver3.RecordedRequest): mockwebserver3.MockResponse = delegate.dispatch(request.unwrap()).wrap()

    override fun peek(): mockwebserver3.MockResponse = delegate.peek().wrap()

    override fun close() {
      delegate.shutdown()
    }
  }
}

      return ImmutableSet.<E>of(first);
    }

    Set<E> delegate = Sets.newLinkedHashSet();
    delegate.add(checkNotNull(first));
    do {
      delegate.add(checkNotNull(elements.next()));
    } while (elements.hasNext());

    return unsafeDelegate(delegate);
  }

  // Factory methods that skips the null checks on elements, only used when