E(p21, challenge, p24);
        return p24;
    }

    /**
     * Generate the Unicode MD4 hash for the password associated with these credentials.
     *
     * @param password the password to hash
     * @param challenge the server challenge bytes
     * @return the Unicode MD4 hash response
     */
    static public byte[] getNTLMResponse(final String password, final byte[] challenge) {

          || c > safeMaxChar
          || c < safeMinChar) {
        return escapeSlow(s, i);
      }
    }
    return s;
  }

  /**
   * Escapes a single Unicode code point using the replacement array and safe range values. If the
   * given character does not have an explicit replacement and lies outside the safe range then
   * {@link #escapeUnsafe} is called.
   *

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bufio

// Exported for testing only.
import (
	"unicode/utf8"
)

var IsSpace = isSpace

const DefaultBufSize = defaultBufSize

func (s *Scanner) MaxTokenSize(n int) {
	if n < utf8.UTFMax || n > 1e9 {
		panic("bad max token size")
	}
	if n < len(s.buf) {

     */
    int FLAGS2_PERMIT_READ_IF_EXECUTE_PERM = 0x2000;
    /**
     * Use 32-bit status codes flag.
     */
    int FLAGS2_STATUS32 = 0x4000;
    /**
     * Strings are Unicode flag.
     */
    int FLAGS2_UNICODE = 0x8000;

    /**
     * No capabilities.
     */
    int CAP_NONE = 0x0000;
    /**
     * Raw mode transfers are supported capability.
     */

		benchBytes(b, indexSizes, bmIndexRuneUnicode(unicode.Latin, 'é'))
	})
	b.Run("Cyrillic", func(b *testing.B) {
		// Cyrillic is mostly 2 and 3 byte runes.
		benchBytes(b, indexSizes, bmIndexRuneUnicode(unicode.Cyrillic, 'Ꙁ'))
	})
	b.Run("Han", func(b *testing.B) {
		// Han consists only of 3 and 4 byte runes.
		benchBytes(b, indexSizes, bmIndexRuneUnicode(unicode.Han, '𠀿'))
	})
}

      char c = s.charAt(index);
      if (c >= safeOctets.length || !safeOctets[c]) {
        return escapeSlow(s, index);
      }
    }
    return s;
  }

  /** Escapes the given Unicode code point in UTF-8. */
  @Override
  protected char @Nullable [] escape(int cp) {
    // We should never get negative values here but if we do it will throw an

	if atEOF {
		return len(data), dropCR(data), nil
	}
	// Request more data.
	return 0, nil, nil
}

// isSpace reports whether the character is a Unicode white space character.
// We avoid dependency on the unicode package, but check validity of the implementation
// in the tests.
func isSpace(r rune) bool {
	if r <= '\u00FF' {
		// Obvious ASCII ones: \t through \r plus space. Plus two Latin-1 oddballs.

    val unicode = "https://長.長.長崎.jp".toHttpUrl()
    assertThat(parse(unicode, "a=b; domain=長.長崎.jp")).isNotNull()
    assertThat(parse(unicode, "a=b; domain=長崎.jp")).isNull()
    val punycode = "https://xn--ue5a.xn--ue5a.xn--8ltr62k.jp".toHttpUrl()
    assertThat(parse(punycode, "a=b; domain=xn--ue5a.xn--8ltr62k.jp")).isNotNull()
    assertThat(parse(punycode, "a=b; domain=xn--8ltr62k.jp")).isNull()
  }

        assertEquals(testString, readString);
    }

    @Test
    void testStringReadWriteUnicode() throws UnsupportedEncodingException {
        smb.useUnicode = true;
        String testString = "Hello Unicode World";
        byte[] buffer = new byte[testString.length() * 2 + 2];
        int len = smb.writeString(testString, buffer, 0);
        assertEquals(testString.length() * 2 + 2, len);

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.dcerpc;

/**
 * A Unicode string representation for DCE/RPC operations in JCIFS.
 * This class wraps strings for use in RPC calls with optional zero termination.
 */
public class UnicodeString extends rpc.unicode_string {

    boolean zterm;