@Test
    void testWithDefaultCredentials() {
        // Test withDefaultCredentials() method
        CIFSContext mockNewContext = mock(CIFSContext.class);
        when(mockDelegate.withDefaultCredentials()).thenReturn(mockNewContext);
        assertEquals(mockNewContext, cifsContextWrapper.withDefaultCredentials());
        verify(mockDelegate).withDefaultCredentials();
    }

    @Test
    void testWithAnonymousCredentials() {

        // Given
        CIFSContext newContext = mock(CIFSContext.class);
        when(mockContext.withDefaultCredentials()).thenReturn(newContext);

        // When
        CIFSContext context = mockContext.withDefaultCredentials();

        // Then
        assertEquals(newContext, context);
        verify(mockContext).withDefaultCredentials();
    }

    @Test
    @DisplayName("Should get context with anonymous credentials")

    public CIFSContext withCredentials(final Credentials creds) {
        return wrap(this.delegate.withCredentials(creds));
    }

    @Override
    public CIFSContext withDefaultCredentials() {
        return wrap(this.delegate.withDefaultCredentials());
    }

    @Override
    public CIFSContext withAnonymousCredentials() {
        return wrap(this.delegate.withAnonymousCredentials());
    }

    @Override

        return withCredentials(new NtlmPasswordAuthenticator());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#withDefaultCredentials()
     */
    @Override
    public CIFSContext withDefaultCredentials() {
        return withCredentials(getDefaultCredentials());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#withGuestCrendentials()

 *
 * Usually you will want to create one context per client configuration and then
 * multiple sub-contexts using different credentials (if necessary).
 *
 * {@link #withDefaultCredentials()}, {@link #withAnonymousCredentials()}, {@link #withCredentials(Credentials)}
 * allow to create such sub-contexts.
 *
 *
 * Implementors of this interface should extend {@link jcifs.context.BaseContext} or

        assertTrue(wrappedContext.getCredentials().isAnonymous());
    }

    @Test
    void testWithDefaultCredentials() {
        CIFSContext wrappedContext = context.withDefaultCredentials();

        assertNotNull(wrappedContext);
        assertTrue(wrappedContext instanceof CIFSContextCredentialWrapper);
        // Verify that the new context uses the default credentials provided to the test context

                          Skipping DC interrogation.""");
            } else {
                try (SmbSessionInternal ssn = trans.getSmbSession(tf.withDefaultCredentials()).unwrap(SmbSessionInternal.class)) {
                    ssn.treeConnectLogon();
                }
            }
            return new NtlmChallenge(trans.getServerEncryptionKey(), dc);

                        /*
                         * preauthentication
                         */
                        try (SmbSessionImpl smbSession = trans.getSmbSession(getContext().withDefaultCredentials());
                                SmbTreeImpl t = smbSession.getSmbTree(getContext().getConfig().getLogonShare(), null)) {
                            t.treeConnect(null, null);
                        }