SocketOutputStream(final OutputStream out) {
        super(out);
    }

    @Override
    public synchronized void write(final byte[] b, int off, final int len) throws IOException {
        if (len > 0xFFFF) {
            throw new IOException("write too large: " + len);
        }
        if (off < 4) {
            throw new IOException("NetBIOS socket output buffer requires 4 bytes available before off");
        }

        pipeData = data;
        pipeDataOff = off;
        pipeDataLen = len;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_TRANSACT_NAMED_PIPE;
        maxParameterCount = 0;
        maxDataCount = 0xFFFF;
        maxSetupCount = (byte) 0x00;
        setupCount = 2;
        name = "\\PIPE\\";
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = subCommand;

        // Verify DFS name is set to server name
        assertEquals(TEST_SERVER, dfsRootEnum.dfs_name);

        // Verify preferred max length is set to maximum
        assertEquals(0xFFFF, dfsRootEnum.prefmaxlen);

        // Verify totalentries is initialized
        assertNotNull(dfsRootEnum.totalentries);
    }

    @Test

            bufferIndex += 14;
            e.type = readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            int off = readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            off = (off & 0xFFFF) - converter;
            off = start + off;
            e.remark = readString(buffer, off, 128, false);

            if (LogStream.level >= 4) {
                log.println(e);
            }
        }

        // 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);
            }

   * element content or {@link #xmlAttributeEscaper} in attribute values.
   *
   * <p>This escaper substitutes {@code 0xFFFD} for non-whitespace control characters and the
   * character values {@code 0xFFFE} and {@code 0xFFFF} which are not permitted in XML. For more
   * detail see section <a href="http://www.w3.org/TR/2008/REC-xml-20081126/#charsets">2.2</a> of
   * the XML specification.
   *

        assertEquals(30000, SmbConstants.DEFAULT_RESPONSE_TIMEOUT);
        assertEquals(35000, SmbConstants.DEFAULT_SO_TIMEOUT);
        assertEquals(0xFFFF, SmbConstants.DEFAULT_RCV_BUF_SIZE);
        assertEquals(0xFFFF, SmbConstants.DEFAULT_SND_BUF_SIZE);
        assertEquals(1024, SmbConstants.DEFAULT_NOTIFY_BUF_SIZE);
        assertEquals(250, SmbConstants.DEFAULT_SSN_LIMIT);

    // we can get away with i++ because the whole point of this method is to return false if we find
    // a code point that doesn't fit in a char.
    for (int i = 0; i < string.length(); i++) {
      if (string.codePointAt(i) > 0xffff) {
        return false;
      }
    }
    return true;
  }

  @SuppressWarnings("deprecation")
  public void testSimpleStringUtf8() {
    assertEquals(

        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;