*/
    @Override
    public CIFSContext withCredentials(final Credentials creds) {
        return new CIFSContextCredentialWrapper(this, creds);
    }

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

    /**

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

        // When
        CIFSContext context = mockContext.withCredentials(creds);

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

    @Test
    @DisplayName("Should renew credentials")

    @Test
    void testWithCredentials() {
        // Test withCredentials(Credentials creds) method
        Credentials mockCredentials = mock(Credentials.class);
        CIFSContext mockNewContext = mock(CIFSContext.class);
        when(mockDelegate.withCredentials(mockCredentials)).thenReturn(mockNewContext);
        assertEquals(mockNewContext, cifsContextWrapper.withCredentials(mockCredentials));

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

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

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

 * 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
 * {@link jcifs.context.CIFSContextWrapper} to get forward compatibility.

        }
    }

    @Test
    void testWithCredentials() {
        Credentials newCreds = mock(Credentials.class);
        CIFSContext wrappedContext = context.withCredentials(newCreds);

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

CIFSContext context = new BaseContext(new jcifs.config.PropertyConfiguration());
NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("domain", "username", "password");
CIFSContext authContext = context.withCredentials(auth);

// Use authenticated context
try (SmbFile file = new SmbFile("smb://server/share/", authContext)) {
    for (SmbFile f : file.listFiles()) {
        System.out.println(f.getName());
    }
}
```

        }
        try {
            if (smbAuthentication == null) {
                file = new SmbFile(filePath, cifsContext);
            } else {
                file = new SmbFile(filePath, cifsContext.withCredentials(getAuthenticator(smbAuthentication)));
            }
        } catch (final MalformedURLException e) {
            logger.warn("Could not parse url: {}", filePath, e);
        }

        try {
            NtlmPasswordAuthentication auth = new NtlmPasswordAuthentication(SingletonContext.getInstance(), WORKGROUP, USERNAME, PASSWORD);
            context = SingletonContext.getInstance().withCredentials(auth);
        } catch (Exception e) {
            log.warn("Failed to create authenticated context, trying guest access", e);
            context = SingletonContext.getInstance();
        }

     */
    @Deprecated
    public SmbFile(final URL url) throws MalformedURLException {
        this(url, SingletonContext.getInstance()
                .withCredentials(new NtlmPasswordAuthentication(SingletonContext.getInstance(), url.getUserInfo())));
    }

    /**
     * Constructs an SmbFile representing a resource on an SMB network such