assertFalse(mockResponse.isReceived());

        // Simulate received status
        when(mockResponse.isReceived()).thenReturn(true);
        assertTrue(mockResponse.isReceived());

        // Verify the method was called
        verify(mockResponse, times(2)).isReceived();
    }

    @Test
    void testReceived() {
        // Call the method

    /**
     * The expiration time for this response in milliseconds.
     */
    public long expiration;
    /**
     * Flag indicating whether this response has been received.
     */
    public boolean isReceived;

 */
public interface Response extends Message {

    /**
     * Checks if the response has been received.
     *
     * @return whether the response is received
     */
    boolean isReceived();

    /**
     * Set received status
     */
    void received();

    /**
     * Unset received status
     */
    void clearReceived();

    /**

    }

    @Test
    @DisplayName("Test Response interface methods - isReceived")
    void testIsReceived() {
        // Given
        when(response.isReceived()).thenReturn(true);

        // When
        boolean received = response.isReceived();

        // Then
        assertTrue(received);
        verify(response).isReceived();
    }

    @Test

    public final void clearReceived() {
        this.received = false;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#isReceived()
     */
    @Override
    public final boolean isReceived() {
        return this.received;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#isError()
     */
    @Override

     * @see jcifs.internal.smb2.ServerMessageBlock2Response#prepare(jcifs.internal.CommonServerMessageBlockRequest)
     */
    @Override
    public void prepare(final CommonServerMessageBlockRequest next) {
        if (isReceived()) {
            ((ServerMessageBlock2) next).setTreeId(getTreeId());
        }
        super.prepare(next);
    }

    /**
     * Returns the type of the connected share (disk, pipe, or print).
     *

     * @see jcifs.internal.smb2.ServerMessageBlock2Response#prepare(jcifs.internal.CommonServerMessageBlockRequest)
     */
    @Override
    public void prepare(final CommonServerMessageBlockRequest next) {
        if (isReceived()) {
            next.setSessionId(getSessionId());
        }
        super.prepare(next);
    }

    /**
     * {@inheritDoc}
     *

                chainedResponse = treeConnect(request, response);
            }
            if (request == null || chainedResponse != null && chainedResponse.isReceived()) {
                return chainedResponse;
            }

            // fall trough if the tree connection is already established
            // and send it as a separate request instead

            this.errorCode = 0;
            this.exception = null;
        }

        // Methods from jcifs.util.transport.Response interface
        @Override
        public boolean isReceived() {
            return received;
        }

        @Override
        public void received() {
            this.received = true;
        }

        @Override

        // Test that response inherits state tracking from ServerMessageBlock2Response

        // Initially not received
        Method isReceivedMethod = ServerMessageBlock2Response.class.getDeclaredMethod("isReceived");
        isReceivedMethod.setAccessible(true);
        assertFalse((boolean) isReceivedMethod.invoke(response));

        // Test reset method
        response.reset();