assertEquals("１２３ あいう", normalizeText("　１２３　あいう　", 100, -1, 2, false));
        assertEquals("123 abc", normalizeText(" 123\nabc ", 100, -1, 2, false));
        assertEquals("123abc", normalizeText(" 123abc ", 100, -1, 2, false));

        assertEquals("!!", normalizeText("!!!", 100, -1, 2, false));
        assertEquals("//", normalizeText("///", 100, -1, 2, false));

        assertEquals("123 abc", documentHelper.getContent(null, responseData, " 123\nabc ", dataMap));
        assertEquals("123abc", documentHelper.getContent(null, responseData, " 123abc ", dataMap));

        assertEquals("!!", documentHelper.getContent(null, responseData, "!!!", dataMap));
        assertEquals("//", documentHelper.getContent(null, responseData, "///", dataMap));

			ok:   true,
		},
		{
			name: "WithNanoTruncate",
			in:   "1.123456789123",
			want: time.Unix(1, 123456789),
			ok:   true,
		},
		{
			name: "TrailingError",
			in:   "1.123abc",
			want: time.Time{},
			ok:   false,
		},
		{
			name: "LeadingError",
			in:   "1.abc123",
			want: time.Time{},
			ok:   false,
		},
	}
	for _, tt := range tests {

		}
	}
}

var EqualFoldTests = []struct {
	s, t string
	out  bool
}{
	{"abc", "abc", true},
	{"ABcd", "ABcd", true},
	{"123abc", "123ABC", true},
	{"αβδ", "ΑΒΔ", true},
	{"abc", "xyz", false},
	{"abc", "XYZ", false},
	{"abcdefghijk", "abcdefghijX", false},
	{"abcdefghijk", "abcdefghij\u212A", true},

        QueryBuilder builder = queryProcessor.execute(context, prefixQuery, 1.0f);

        assertNotNull(builder);
        assertTrue(builder instanceof MatchPhrasePrefixQueryBuilder);

        MatchPhrasePrefixQueryBuilder mpqb = (MatchPhrasePrefixQueryBuilder) builder;
        assertEquals("test-123_abc", mpqb.value());

    void testToHexChars() {
        // Test integer conversion
        char[] dst1 = new char[8];
        Hexdump.toHexChars(0x1234ABCD, dst1, 0, 8);
        assertEquals("1234ABCD", new String(dst1));

        // Test with smaller size
        char[] dst2 = new char[4];
        Hexdump.toHexChars(0xABCD, dst2, 0, 4);
        assertEquals("ABCD", new String(dst2));

	signedHeaders = append(signedHeaders, "expect")
	// expected header values.
	expectedHost := "play.min.io:9000"
	expectedContentSha256 := "1234abcd"
	expectedTime := UTCNow().Format(iso8601Format)
	expectedTransferEncoding := "gzip"
	expectedExpect := "100-continue"

	r, err := http.NewRequest(http.MethodGet, "http://play.min.io:9000", nil)
	if err != nil {

	n2, err := w.ReadFrom(r)
	if n2 != 4 || err != nil {
		t.Fatalf("ReadFrom returned (%v, %v), want (4, nil)", n2, err)
	}
	w.Flush()
	if got, want := buf.String(), "0123abcd"; got != want {
		t.Fatalf("buf.Bytes() returned %q, want %q", got, want)
	}
}

func TestWriterReadFromErrNoProgress(t *testing.T) {
	buf := new(bytes.Buffer)
	w := NewWriterSize(buf, 5)

   */
  @Override
  public String toString() {
    return super.toString();
  }

  /**
   * Returns the Java Unicode escape sequence for the given {@code char}, in the form "\u12AB" where
   * "12AB" is the four hexadecimal digits representing the 16-bit code unit.
   */
  private static String showCharacter(char c) {
    String hex = "0123456789ABCDEF";
    char[] tmp = {'\\', 'u', '\0', '\0', '\0', '\0'};

AB7A          ; mapped                 ; 13AA          # 8.0  CHEROKEE SMALL LETTER GO
AB7B          ; mapped                 ; 13AB          # 8.0  CHEROKEE SMALL LETTER GU
AB7C          ; mapped                 ; 13AC          # 8.0  CHEROKEE SMALL LETTER GV
AB7D          ; mapped                 ; 13AD          # 8.0  CHEROKEE SMALL LETTER HA