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

    @Test
    void testWithGuestCrendentials() {

        CIFSContext newContext = mock(CIFSContext.class);
        when(mockContext.withAnonymousCredentials()).thenReturn(newContext);

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

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

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

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

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

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

    @Override

        return new CIFSContextCredentialWrapper(this, creds);
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#withAnonymousCredentials()
     */
    @Override
    public CIFSContext withAnonymousCredentials() {
        return withCredentials(new NtlmPasswordAuthenticator());
    }

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

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

        assertEquals(newCreds, wrappedContext.getCredentials());
    }

    @Test
    void testWithAnonymousCredentials() {
        CIFSContext wrappedContext = context.withAnonymousCredentials();

        assertNotNull(wrappedContext);
        assertTrue(wrappedContext instanceof CIFSContextCredentialWrapper);
        // Verify that the new context uses NtlmPasswordAuthenticator (anonymous)

                if (trans != null) {
                    // get domain referral
                    initial = trans.getDfsReferrals(tf.withAnonymousCredentials(), "", trans.getRemoteHostName(), authDomain, 0);
                }
                if (initial != null) {
                    final DfsReferralDataInternal start = initial.unwrap(DfsReferralDataInternal.class);

                // refresh anonymous session or fallback to anonymous from guest login
                try (SmbSessionInternal s =
                        trans.getSmbSession(this.ctx.withAnonymousCredentials(), treesess.getTargetHost(), treesess.getTargetDomain())
                                .unwrap(SmbSessionInternal.class);
                        SmbTreeImpl tr = s.getSmbTree(share, null).unwrap(SmbTreeImpl.class)) {