// Act & Assert
        assertFalse(transport.isDisconnected());
        assertFalse(transport.isFailed());

        // Close socket -> both should be true
        when(s.isClosed()).thenReturn(true);
        assertTrue(transport.isDisconnected());
        assertTrue(transport.isFailed());
    }

    @Test
    @DisplayName("capability query delegates to negotiation state")

        when(transport.isFailed()).thenReturn(false);
        assertTrue(session.isConnected());
        assertFalse(session.isFailed());

        when(transport.isDisconnected()).thenReturn(true);
        when(transport.isFailed()).thenReturn(true);
        assertFalse(session.isConnected());
        assertTrue(session.isFailed());
    }

    @Test

                    && (tc.getConfig().getSessionLimit() == 0 || conn.getNumSessions() < tc.getConfig().getSessionLimit())) {
                try {
                    if (conn.isFailed() || connectedOnly && conn.isDisconnected()) {
                        continue;
                    }

                    if (forceSigning && !conn.isSigningEnforced()) {

            for (int state : failedStates) {
                transport.setState(state);
                assertTrue(transport.isFailed(), "State " + state + " should be failed");
            }

            for (int state : nonFailedStates) {
                transport.setState(state);
                assertFalse(transport.isFailed(), "State " + state + " should not be failed");
            }
        }
    }

    @Nested

                    try (SmbSessionImpl session = t.getSession()) {
                        targetDomain = session.getTargetDomain();
                        if (!session.isFailed()) {
                            try (SmbTransportImpl trans = session.getTransport();
                                    SmbTreeImpl ct = connectTree(loc, host, t.getShare(), trans, t, null)) {

        return !this.transport.isDisconnected() && this.connectionState.get() == 2;
    }

    /**
     * @return whether the session has been lost
     */
    public boolean isFailed() {
        return this.transport.isFailed();
    }

    /**
     * @return whether encryption is enabled for this session
     */
    public boolean isEncryptionEnabled() {
        return this.encryptionContext != null;

                            for (int i = 0; i < docList.size(); i++) {
                                final BulkItemResponse resp = items[i];
                                if (resp.isFailed() && resp.getFailure() != null) {
                                    final Map<String, Object> req = docList.get(i);
                                    final Failure failure = resp.getFailure();

    }

    /**
     * Checks if the transport is in a failed state.
     *
     * @return whether the transport is marked failed
     */
    public boolean isFailed() {
        return this.state == 5 || this.state == 6;
    }

    /**
     * Send a request message and recieve response
     *
     * @param <T> the response type

        final Socket s = this.socket;
        return super.isDisconnected() || s == null || s.isClosed();
    }

    @Override
    public boolean isFailed() {
        final Socket s = this.socket;
        return super.isFailed() || s == null || s.isClosed();
    }

    @Override
    public boolean hasCapability(final int cap) throws SmbException {