inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
		wantErr:   ErrHeader,
	}, {
		inputData: padInput(strings.Repeat("0", 300) + "1\n" + strings.Repeat("0", 1000) + "5\n" + strings.Repeat("0", 800) + "2\n"),
		inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
		wantMap:   sparseDatas{{5, 2}},
	}, {
		inputData: padInput("2\n10737418240\n512\n21474836480\n512\n"),

		f.err = ErrFieldTooLong
	}

	s := strconv.FormatInt(x, 8)
	// Add leading zeros, but leave room for a NUL.
	if n := len(b) - len(s) - 1; n > 0 {
		s = strings.Repeat("0", n) + s
	}
	f.formatString(b, s)
}

// fitsInOctal reports whether the integer x fits in a field n-bytes long
// using octal encoding with the appropriate NUL terminator.
func fitsInOctal(n int, x int64) bool {
	octBits := uint(n-1) * 3

        assertEquals("", blob.toString(), "toString() should be empty for empty buffer");
    }

    // Ensures set(null) resets the buffer to empty and does not NPE
    @Test
    @DisplayName("set(null) resets to empty")
    void set_null_resetsToEmpty() {
        // Arrange
        SecurityBlob blob = new SecurityBlob(new byte[] { 1, 2, 3 });

        // Act
        blob.set(null);

    }

    @Test
    @DisplayName("Test username length validation")
    void testUsernameLengthValidation() {
        String longUsername = "a".repeat(InputValidator.MAX_USERNAME_LENGTH + 1);
        assertThrows(IllegalArgumentException.class, () -> InputValidator.validateUsername(longUsername));
    }

    @ParameterizedTest
    @DisplayName("Test valid domains")

func BenchmarkRingBuffer_Sync(b *testing.B) {
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

	for b.Loop() {
		rb.Write(data)
		rb.Read(buf)
	}
}

func BenchmarkRingBuffer_AsyncRead(b *testing.B) {
	// Pretty useless benchmark, but it's here for completeness.
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

	go func() {
		for {
			rb.Read(buf)

        sb.setLength(0);
        repeat(sb, BOX_CHAR, size);
        result.add(sb.toString());
        // lines
        for (String line : lines) {
            sb.setLength(0);
            String[] words = S_FILTER.split(line);
            for (String word : words) {
                if (sb.length() >= remainder - word.length() - (!sb.isEmpty() ? 1 : 0)) {
                    repeat(sb, ' ', remainder - sb.length());

	}
	rb.Write([]byte(strings.Repeat("abcd", 15)))

	if !bytes.Equal(rb.Bytes(nil), []byte("bcd"+strings.Repeat("abcd", 15))) {
		t.Fatalf("expect 63 ... but got %s. r.w=%d, r.r=%d", rb.Bytes(nil), rb.w, rb.r)
	}

	rb.Reset()
	n, err = rb.Write([]byte(strings.Repeat("abcd", 16)))
	if err != nil {
		t.Fatalf("write failed: %v", err)
	}
	if n != 64 {

  }

  @Test
  fun labelTooLongDueToAsciiExpansion() {
    val a60 = "a".repeat(60)
    assertThat(parse("http://\u2121$a60/").toString()).isEqualTo("http://tel$a60/")
    assertInvalid("http://a\u2121$a60/", "Invalid URL host: \"a\u2121$a60\"")
  }

  @Test
  fun hostnameTooLong() {
    val dotA126 = "a.".repeat(126)
    assertThat(parse("http://a$dotA126/").toString())

     * This field contains the full error information for debugging purposes.
     */
    public String errorLog;

    /**
     * The number of times this URL has failed.
     * This is a required field that tracks repeated failures for the same URL.
     */
    @Required
    @ValidateTypeFailure
    public String errorCount;

    /**
     * The timestamp of the last access attempt for this URL.

		{"a", 'ӆ', -1},
		{"  ӆ", 'ӆ', 2},
		{"  a", 'ӆ', -1},
		{strings.Repeat("ц", 64) + "ӆ", 'ӆ', 128}, // test cutover
		{strings.Repeat("ц", 64), 'ӆ', -1},

		// 3 bytes
		{"Ꚁ", 'Ꚁ', 0},
		{"a", 'Ꚁ', -1},
		{"  Ꚁ", 'Ꚁ', 2},
		{"  a", 'Ꚁ', -1},
		{strings.Repeat("Ꙁ", 64) + "Ꚁ", 'Ꚁ', 192}, // test cutover
		{strings.Repeat("Ꙁ", 64) + "Ꚁ", '䚀', -1},  // 'Ꚁ' and '䚀' share the same last two bytes

		// 4 bytes