when(peek.getReadDataAvailable()).thenReturn(7);
        when(ioResp.getOutputData()).thenReturn(peek);

        when(tree.send(any(Smb2IoctlRequest.class), eq(RequestParam.NO_RETRY))).thenReturn(ioResp);

        // Act
        int available = stream.available();

        // Assert
        assertEquals(7, available, "Should return available bytes reported by server");

        when(tree.send(eq(request), eq(RequestParam.NO_TIMEOUT), eq(RequestParam.NO_RETRY))).thenReturn(response);

        // Act
        CommonServerMessageBlockResponse out = tree.send(request, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);

        // Assert
        assertSame(response, out);
        verify(tree).send(request, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);
    }

    @Test

                values, "values() order should match declaration order");
    }

    // Happy path: valueOf resolves each constant name; toString equals name; ordinal is stable
    @ParameterizedTest
    @ValueSource(strings = { "NONE", "NO_TIMEOUT", "NO_RETRY", "RETAIN_PAYLOAD" })

                    cnt = resp.getCount();
                } else {
                    final SmbComWriteAndX request =
                            new SmbComWriteAndX(th.getConfig(), fh.getFid(), this.fp, len - w - off, b, off, w, null);
                    th.send(request, this.write_andx_resp, RequestParam.NO_RETRY);
                    cnt = this.write_andx_resp.getCount();

                .thenReturn(resp);

        CommonServerMessageBlockResponse out = handle.send(req, RequestParam.NO_RETRY);
        assertSame(resp, out);

        verify(treeConnection, times(1)).send(eq(resourceLoc), eq((CommonServerMessageBlockRequest) req), isNull(),
                any(RequestParam[].class));
    }

        h.close(777L);

        // Verify SMB2 close path
        verify(tree, times(1)).send(isA(Smb2CloseRequest.class), eq(RequestParam.NO_RETRY));
        // Tree is always released in finally
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("close(long) sends SMB1 close request and releases tree when SMB1")

                req.setInputData(new ByteEncodable(buf, off, length));
                req.setMaxOutputResponse(maxRecvSize);
                final Smb2IoctlResponse resp = th.send(req, RequestParam.NO_RETRY);
                return resp.getOutputLength();
            }
            if (this.transact) {
                final TransTransactNamedPipe req = new TransTransactNamedPipe(th.getConfig(), fh.getFid(), buf, off, length);

        public static final RetryPolicy AGGRESSIVE = new RetryPolicy(5, 500, 60000, 1.5, true);
        public static final RetryPolicy CONSERVATIVE = new RetryPolicy(2, 2000, 10000, 3.0, true);
        public static final RetryPolicy NO_RETRY = new RetryPolicy(1, 0, 0, 1.0, false);

        public RetryPolicy(int maxAttempts, long initialDelayMs, long maxDelayMs, double backoffMultiplier, boolean exponentialBackoff) {
            this.maxAttempts = maxAttempts;

                req.setMaxOutputResponse(16);
                req.setFlags(Smb2IoctlRequest.SMB2_O_IOCTL_IS_FSCTL);
                final Smb2IoctlResponse resp = th.send(req, RequestParam.NO_RETRY);
                return ((SrvPipePeekResponse) resp.getOutputData()).getReadDataAvailable();
            }
            final TransPeekNamedPipe req = new TransPeekNamedPipe(th.getConfig(), this.handle.getUncPath(), fd.getFid());

                        try {
                            final Smb2ReadResponse resp = th.send(request, RequestParam.NO_RETRY);
                            n = resp.getDataLength();
                        } catch (final SmbException e) {
                            if (e.getNtStatus() == 0xC0000011) { // NT_STATUS_END_OF_FILE