// referral.
            synchronized (trans) {
                try {
                    // ensure connected
                    trans.ensureConnected();
                    refServerName = trans.getRemoteHostName();
                } catch (final IOException e) {
                    log.warn("Failed to connect to domain controller", e);
                }

 */
package jcifs.internal.smb2.multichannel;

/**
 * SMB3 Multi-Channel connection states
 */
public enum ChannelState {
    /**
     * Channel is not connected
     */
    DISCONNECTED(0),

    /**
     * Connection establishment in progress
     */
    CONNECTING(1),

    /**
     * Authentication in progress
     */
    AUTHENTICATING(2),

mvn deploy
```

## Architecture

### Core Components

- **`org.codelibs.curl.Curl`**: Static entry point providing factory methods for all HTTP methods (GET, POST, PUT, DELETE, HEAD, OPTIONS, CONNECT, TRACE)
- **`org.codelibs.curl.CurlRequest`**: Fluent request builder supporting parameters, headers, body content, SSL config, proxies, timeouts, and caching

import com.nimbusds.jwt.JWTParser;
import com.nimbusds.oauth2.sdk.AuthorizationCode;
import com.nimbusds.openid.connect.sdk.AuthenticationErrorResponse;
import com.nimbusds.openid.connect.sdk.AuthenticationResponse;
import com.nimbusds.openid.connect.sdk.AuthenticationResponseParser;
import com.nimbusds.openid.connect.sdk.AuthenticationSuccessResponse;

import jakarta.annotation.PostConstruct;
import jakarta.servlet.http.HttpServletRequest;

    /**
     * Returns the FesenClient instance, connecting if not already connected.
     * @return The FesenClient instance.
     */
    protected FesenClient getClient() {
        if (!fesenClient.connected()) {
            synchronized (fesenClient) {
                if (!fesenClient.connected()) {
                    fesenClient.connect();
                }
            }
        }
        return fesenClient;

        }
    }

    /**
     * Connect the transport
     *
     * @throws SmbException
     */
    @Override
    public boolean ensureConnected() throws SmbException {
        try {
            return super.connect(this.transportContext.getConfig().getResponseTimeout());
        } catch (final TransportException te) {
            throw new SmbException("Failed to connect: " + this.address, te);
        }

        this.securityProvider = securityProvider;
    }

    /**
     * Gets the server hostname or address currently connected to
     * @return the server connected to
     */
    public abstract String getServer();

    /**
     * Gets the server hostname resolved through DFS (Distributed File System)
     * @return the server resolved by DFS

    }

    @Test
    @DisplayName("isDisconnected / isFailed reflect socket and state")
    void connectionStateChecks() throws Exception {
        // Arrange: simulate connected state and open socket
        setField(transport, "state", 3); // connected
        Socket s = mock(Socket.class);
        when(s.isClosed()).thenReturn(false);
        setField(transport, "socket", s);

        // Act & Assert

    @Nested
    class WhenHandlingConnections {

        @Test
        void testConnect() throws IOException {
            // Arrange
            doNothing().when(smbFile).connect();

            // Act
            smbFile.connect();

            // Assert - should not throw exception
        }

        @Test
        void testClose() {
            // Act
            smbFile.close();

        // Exception path
        when(treeConnection.hasCapability(999)).thenThrow(new SmbException("Not connected"));
        SmbException ex = assertThrows(SmbException.class, () -> handle.hasCapability(999));
        assertTrue(ex.getMessage().contains("Not connected"));
    }

    @Test
    @DisplayName("getTreeId delegates")
    void getTreeIdDelegates() {