*
     * @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

            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

        // 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");

  fun idleConnectionCount(): Int = delegate.idleConnectionCount()

  /** Returns total number of connections in the pool. */
  fun connectionCount(): Int = delegate.connectionCount()

  internal val connectionListener: ConnectionListener
    get() = delegate.connectionListener

  /** Close and remove all idle connections in the pool. */
  fun evictAll() {
    delegate.evictAll()
  }

        ******@****.***()
      }

      override val sink =
        RequestBodySink(
          delegate = codec.socket.sink,
          contentLength = -1L,
          isSocket = true,
        )
      override val source =
        ResponseBodySource(
          delegate = codec.socket.source,
          contentLength = -1L,
          isSocket = true,
        )
    }
  }

        iterator.close();

        verify(delegate).close();
    }

    @Test
    @DisplayName("Close propagates exception")
    void closeException() throws CIFSException {
        when(delegate.hasNext()).thenReturn(false);
        doThrow(new CIFSException("Close failed")).when(delegate).close();

        TestIterator iterator = new TestIterator(null);

     * @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();
    }

    /**

   *
   * <p>If {@code delegate} is an instance created by an earlier call to {@code memoize}, it is
   * returned directly.
   */
  public static <T extends @Nullable Object> Supplier<T> memoize(Supplier<T> delegate) {
    if (delegate instanceof NonSerializableMemoizingSupplier
        || delegate instanceof MemoizingSupplier) {
      return delegate;
    }
    return delegate instanceof Serializable