@SuppressWarnings ( "javadoc" )
public class NdrShort extends NdrObject {

    public int value;


    public NdrShort ( int value ) {
        this.value = value & 0xFF;
    }


    @Override
    public void encode ( NdrBuffer dst ) throws NdrException {
        dst.enc_ndr_short(this.value);
    }


    @Override
    public void decode ( NdrBuffer src ) throws NdrException {
        this.value = src.dec_ndr_short();
    }

     */
    int decode ( byte[] buffer, int bufferIndex ) throws SMBProtocolDecodingException;


    /**
     * @param dst
     * @param dstIndex
     * @return message length
     */
    int encode ( byte[] dst, int dstIndex );


    /**
     * @param digest
     */
    void setDigest ( SMBSigningDigest digest );


    /**
     * @return the signing digest
     */

    private static final String ESCAPED_QUOTE = "\"\"";

    private KuromojiCSVUtil() {
    } // no instance!!!

    /**
     * Parse CSV line
     *
     * @param line
     *            line containing csv-encoded data
     * @return Array of values
     */
    public static String[] parse(final String line) {
        boolean insideQuote = false;
        final ArrayList<String> result = new ArrayList<>();

  },
  {
    "input": "نامه‌ای",
    "output": "xn--mgba3gch31f060k"
  },
  {
    "comment": "U+FFFD",
    "input": "\uFFFD.com",
    "output": null
  },
  {
    "comment": "U+FFFD character encoded in Punycode",
    "input": "xn--zn7c.com",
    "output": null
  },
  {
    "comment": "Label longer than 63 code points",
    "input": "x01234567890123456789012345678901234567890123456789012345678901x",

    fun body(body: MockResponseBody) =
      apply {
        setHeader("Content-Length", body.contentLength)
        this.body = body
      }

    /** Sets the response body to the UTF-8 encoded bytes of [body]. */
    fun body(body: String): Builder = body(Buffer().writeUtf8(body))

    fun streamHandler(streamHandler: StreamHandler) =
      apply {
        this.streamHandler = streamHandler
      }

        dstIndex += 4;
        System.arraycopy(this.fileId, 0, dst, dstIndex, 16);
        dstIndex += 16;

        for ( Smb2Lock l : this.locks ) {
            dstIndex += l.encode(dst, dstIndex);
        }
        return dstIndex - start;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */

     * @return <code>application/x-www-form-urlencoded</code>でエンコード文字列
     */
    public static String encode(final String s, final String enc) {
        assertArgumentNotEmpty("s", s);
        assertArgumentNotEmpty("enc", enc);

        try {
            return URLEncoder.encode(s, enc);
        } catch (final UnsupportedEncodingException e) {
            throw new IORuntimeException(e);
        }
    }

     * all but the first smb of the chaain do not have a header
     * and therefore we do not want to writeHeaderWireFormat. We
     * just recursivly call writeAndXWireFormat.
     */ 

    int encode( byte[] dst, int dstIndex ) {
        int start = headerStart = dstIndex;

        dstIndex += writeHeaderWireFormat( dst, dstIndex );
        dstIndex += writeAndXWireFormat( dst, dstIndex );

   * assertNull(getEffectiveTldPlusOne("mymacbook"));
   * ```
   *
   * @param domain A canonicalized domain. An International Domain Name (IDN) should be punycode
   *     encoded.
   */
  fun getEffectiveTldPlusOne(domain: String): String? {
    // We use UTF-8 in the list so we need to convert to Unicode.
    val unicodeDomain = IDN.toUnicode(domain)
    val domainLabels = splitDomain(unicodeDomain)

   * double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the
   * length-in-digits of an encoded integer.
   */
  @Throws(IOException::class)
  private fun writeOrCountBytes(
    sink: BufferedSink?,
    countBytes: Boolean,
  ): Long {
    var sink = sink