*/
    boolean disconnect(boolean hard, boolean inuse) throws IOException;

    /**
     * Ensures the transport is connected to the remote server.
     *
     * @return whether the transport was connected
     * @throws SmbException if an SMB error occurs
     * @throws IOException if an I/O error occurs
     */
    boolean ensureConnected() throws IOException;

    /**

        authenticator = new TestSsoAuthenticator();
    }

    // Mock LoginCredentialResolver for testing
    private static class TestLoginCredentialResolver extends FessLoginAssist.LoginCredentialResolver {
        private boolean resolveCalled = false;
        private Class<?> lastCredentialType;
        private Function<?, ?> lastFunction;

        public TestLoginCredentialResolver() {
            super(null); // Pass null since we're mocking

        }
        return this.wrappedHandler;
    }

    @Override
    public SidResolver getSIDResolver() {
        return this.delegate.getSIDResolver();
    }

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

    @Override
    public CIFSContext withCredentials(final Credentials creds) {

    @Override
    public boolean hasCapability(int cap) throws SmbException {
        return delegate.hasCapability(cap);
    }

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

    @Override
    public boolean disconnect(boolean hard, boolean inuse) throws IOException {
        synchronized (connectionLock) {

  override fun enqueue(responseCallback: Callback): Unit = error("unexpected")

  override fun cancel(): Unit = error("unexpected")

  override fun isExecuted(): Boolean = error("unexpected")

  override fun isCanceled(): Boolean = error("unexpected")

  override fun timeout(): Timeout = error("unexpected")

  override fun clone(): Call = error("unexpected")

        private final Artifact artifact;
        private final long pomHash;
        private final boolean resolveManagedVersions;
        private final List<ArtifactRepository> repositories = new ArrayList<>();
        private final int hashCode;

        public CacheKey(
                Artifact artifact,
                boolean resolveManagedVersions,
                ArtifactRepository localRepository,

    private final TimeoutTarget timeoutTarget;

    private final long timeoutMillis;

    private final boolean permanent;

    private long startTime;

    private int status = ACTIVE;

    TimeoutTask(final TimeoutTarget timeoutTarget, final int timeout, final boolean permanent) {
        this.timeoutTarget = timeoutTarget;
        this.timeoutMillis = timeout * 1000L;
        this.permanent = permanent;

  private val writeTimeoutMillis: Int,
  private val socketConnectTimeoutMillis: Int,
  private val socketReadTimeoutMillis: Int,
  private val pingIntervalMillis: Int,
  private val retryOnConnectionFailure: Boolean,
  private val fastFallback: Boolean,
  override val address: Address,
  private val routeDatabase: RouteDatabase,
  private val connectionUser: ConnectionUser,
) : RoutePlanner {
  private var routeSelection: RouteSelector.Selection? = null

    private long expiration;
    private int rflags;

    private boolean resolveHashes;

    private DfsReferralDataImpl next;
    private Map<String, DfsReferralDataInternal> map;
    private String key;
    private String domain;

    private boolean intermediate;

    /**
     * Constructs a new DfsReferralDataImpl instance
     */
    public DfsReferralDataImpl() {

     *            the sessionBinding to set
     */
    public void setSessionBinding(final boolean sessionBinding) {
        this.sessionBinding = sessionBinding;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#chain(jcifs.internal.smb2.ServerMessageBlock2)
     */
    @Override
    public boolean chain(final ServerMessageBlock2 n) {
        n.setSessionId(Smb2Constants.UNSPECIFIED_SESSIONID);