*/
    CIFSContext withDefaultCredentials ();


    /**
     * @return a child context using anonymous credentials
     */
    CIFSContext withAnonymousCredentials ();


    /**
     * 
     * @return a child context using guest credentials
     */
    CIFSContext withGuestCrendentials ();


    /**
     * 

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


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

    private byte[] unicodeHash;
    private boolean hashesExternal = false;
    private CIFSContext context;


    /**
     * 
     */
    private NtlmPasswordAuthentication () {}


    /**
     * Construct anonymous credentials
     * 
     * @param tc
     */
    public NtlmPasswordAuthentication ( CIFSContext tc ) {
        this(tc, "", "", "");
    }


    /**

/**
 * @author mbechler
 *
 */
public class CIFSContextWrapper implements CIFSContext {

    private final CIFSContext delegate;
    private Handler wrappedHandler;


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


    /**

    }


    protected CIFSContext lowTimeout ( CIFSContext ctx ) {
        return withConfig(ctx, new DelegatingConfiguration(ctx.getConfig()) {

            @Override
            public int getSoTimeout () {
                return 100;
            }

        });

    }


    protected CIFSContext fastIdle ( CIFSContext ctx ) {

    }


    protected CIFSContext withTestNTLMCredentials ( CIFSContext ctx ) {
        return ctx.withCredentials(new NtlmPasswordAuthenticator(getTestUserDomain(), getTestUser(), getTestUserPassword()));
    }


    protected CIFSContext withTestGuestCredentials () {
        return getContext().withGuestCrendentials();
    }


    protected CIFSContext withAnonymousCredentials () {

 */
package jcifs.internal;


import jcifs.CIFSContext;
import jcifs.DialectVersion;
import jcifs.util.transport.Response;


/**
 * @author mbechler
 *
 */
public interface SmbNegotiationResponse extends CommonServerMessageBlock, Response {

    /**
     * 
     * @param cifsContext
     * @param singingEnforced
     * @param request

    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#getConfig()
     */
    @Override
    public Configuration getConfig () {
        return this.config;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#getDfs()
     */
    @Override
    public DfsResolver getDfs () {
        return this.dfs;
    }

        }
    }


    @Test
    public void testAuthErrorNoConnLeak () throws Exception {
        CIFSContext cifsContext = getNewContext().withCredentials(new NtlmPasswordAuthenticator("wrong", "wrong", "wrong"));
        try ( SmbFile f = new SmbFile("smb://" + getTestServer() + "/IPC$/test", cifsContext); ) {
            f.connect();
            assertFalse(true);
        }
        catch ( SmbAuthException e ) {

     * @param port
     * @param exclusive
     * @param forceSigning
     * @return a connected transport
     * @throws UnknownHostException
     * @throws IOException
     */
    SmbTransport getSmbTransport ( CIFSContext tf, String name, int port, boolean exclusive, boolean forceSigning )
            throws UnknownHostException, IOException;


    /**
     * Get transport connection
     * 
     * @param tc