* @see jcifs.internal.smb2.ServerMessageBlock2Response#prepare(jcifs.internal.CommonServerMessageBlockRequest)
     */
    @Override
    public void prepare(final CommonServerMessageBlockRequest next) {
        if (isReceived() && next instanceof RequestWithFileId) {
            ((RequestWithFileId) next).setFileId(this.fileId);
        }
        super.prepare(next);
    }

    /**
     * Get the oplock level granted by the server

        @Override
        public Long getExpiration() {
            return this.expiration;
        }

        // Additional Response interface methods
        @Override
        public boolean isReceived() {
            return this.received;
        }

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

        @Override

        return getConfig().equals(tc.getConfig());
    }

    @Override
    public boolean isValid(final CIFSContext tc, final SmbNegotiationRequest req) {
        if (!isReceived() || getStatus() != 0) {
            return false;
        }

        if (req.isSigningEnforced() && !isSigningEnabled()) {
            log.debug("Signing is enforced but server does not allow it");

        @Test
        @DisplayName("Should track received state")
        void testReceivedState() {
            assertFalse(echoResponse.isReceived());

            echoResponse.received();

            assertTrue(echoResponse.isReceived());
        }

        @Test
        @DisplayName("Should track error state")
        void testErrorState() {
            assertFalse(echoResponse.isError());

        void testReset() {
            // Set initial state
            response.received();
            assertTrue(response.isReceived());

            // Reset
            response.reset();

            assertFalse(response.isReceived());
        }

        @Test
        @DisplayName("Should handle received notification")
        void testReceived() throws InterruptedException {

    void watch_smb2_success_returnsList_andClosesTree() throws Exception {
        List<FileNotifyInformation> info = new ArrayList<>();
        NotifyResponse resp = mock(NotifyResponse.class);
        when(resp.isReceived()).thenReturn(true);
        when(resp.getErrorCode()).thenReturn(0);
        when(resp.getNotifyInformation()).thenReturn(info);
        setupSmb2(resp, new byte[16]);

        @Test
        @DisplayName("Test received state")
        void testReceivedState() {
            assertFalse(testBlock.isReceived());

            testBlock.received();
            assertTrue(testBlock.isReceived());

            testBlock.clearReceived();
            assertFalse(testBlock.isReceived());
        }

        @Test
        @DisplayName("Test exception state")
        void testExceptionState() {

     */
    public final void setUseUnicode(final boolean useUnicode) {
        this.useUnicode = useUnicode;
    }

    /**
     * @return the received
     */
    @Override
    public final boolean isReceived() {
        return this.received;
    }

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

    /**
     * {@inheritDoc}
     *

        makeKey(request);
        response.isReceived = false;
        try {
            response_map.put(request, response);
            doSend(request);
            response.expiration = System.currentTimeMillis() + timeout;
            while (!response.isReceived) {
                wait(timeout);
                timeout = response.expiration - System.currentTimeMillis();

        try {
            createResp = th.send(create);
        } catch (final SmbException e) {
            final Smb2CreateResponse cr = create.getResponse();
            if (cr != null && cr.isReceived() && cr.getStatus() == NtStatus.NT_STATUS_SUCCESS) {
                try {
                    th.send(new Smb2CloseRequest(th.getConfig(), cr.getFileId()));
                } catch (final SmbException e2) {