// Test maximum unsigned 16-bit value (65535)
        SMBUtil.writeInt2(0xFFFF, buffer, 0);
        TransPeekNamedPipeResponse response2 = new TransPeekNamedPipeResponse(mockConfig);
        response2.readParametersWireFormat(buffer, 0, 6);
        assertEquals(0xFFFF, response2.getAvailable());
    }

    @Test
    @DisplayName("Test large buffer handling")

        try {
            System.arraycopy(this.sbuf, 0, buffer, 0, 4 + SMB1_HEADER_LENGTH);
            final int size = Encdec.dec_uint16be(buffer, 2) & 0xFFFF;
            if (size < SMB1_HEADER_LENGTH + 1 || 4 + size > Math.min(0xFFFF, getContext().getConfig().getMaximumBufferSize())) {
                throw new IOException("Invalid payload size: " + size);
            }

                    } else if (this.largeReadX) {
                        // Optimize large read requests
                        request.setMaxCount(r & 0xFFFF);
                        request.setOpenTimeout(r >> 16 & 0xFFFF);
                    }

                    th.send(request, response, RequestParam.NO_RETRY);
                    n = response.getDataLength();

        // Set maximum values
        int testCapabilities = 0xFFFFFFFF;
        byte[] testGuid = new byte[16];
        Arrays.fill(testGuid, (byte) 0xFF);
        int testSecurityMode = 0xFFFF;
        int testDialect = 0xFFFF;

        // Write to buffer
        SMBUtil.writeInt4(testCapabilities, buffer, bufferIndex);
        System.arraycopy(testGuid, 0, buffer, bufferIndex + 4, 16);

    }

    SmbFileInputStream(final SmbFile file, final int openFlags) throws SmbException, MalformedURLException, UnknownHostException {
        this.file = file;
        this.openFlags = openFlags & 0xFFFF;
        this.access = openFlags >>> 16 & 0xFFFF;
        if (file.type != SmbFile.TYPE_NAMED_PIPE) {
            file.open(openFlags, access, SmbFile.ATTR_NORMAL, 0);
            this.openFlags &= ~(SmbFile.O_CREAT | SmbFile.O_TRUNC);
        } else {

    public String getName() {
        return netName;
    }

    @Override
    public int getType() {
        /* 0x80000000 means hidden but SmbFile.isHidden() checks for $ at end
         */
        switch (type & 0xFFFF) {
        case 1:
            return SmbFile.TYPE_PRINTER;
        case 3:
            return SmbFile.TYPE_NAMED_PIPE;
        }
        return SmbFile.TYPE_SHARE;
    }

    @Override

        assertTrue(len >= 2);
        // writeInt2 writes in little-endian format (LSB first)
        int written = (buffer[0] & 0xFF) | ((buffer[1] & 0xFF) << 8);
        int expected = level & 0xFFFF;
        assertEquals(expected, written);
    }

    // Helper method to extract string from buffer
    private String extractStringFromBuffer(byte[] buffer, int offset, int maxLen) {
        int end = offset;

        return 0;
    }

    @Override
    public int getType() {
        /*
         * 0x80000000 means hidden but SmbFile.isHidden() checks for $ at end
         */
        switch (this.type & 0xFFFF) {
        case 1:
            return SmbConstants.TYPE_PRINTER;
        case 3:
            return SmbConstants.TYPE_NAMED_PIPE;
        }
        return SmbConstants.TYPE_SHARE;
    }

    @Override

     *
     * @param server the server name to enumerate DFS roots from
     */
    public MsrpcDfsRootEnum(final String server) {
        super(server, 200, 0xFFFF, new netdfs.DfsEnumStruct(), new NdrLong(0));
        this.info.level = this.level;
        this.info.e = new netdfs.DfsEnumArray200();
        this.ptype = 0;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

        void testToStringMaxValues() {
            // Arrange
            rpc.uuid_t rpcUuid = new rpc.uuid_t();
            rpcUuid.time_low = 0xFFFFFFFF;
            rpcUuid.time_mid = (short) 0xFFFF;
            rpcUuid.time_hi_and_version = (short) 0xFFFF;
            rpcUuid.clock_seq_hi_and_reserved = (byte) 0xFF;
            rpcUuid.clock_seq_low = (byte) 0xFF;