}
	data = data[len(line):]
	line, isPrefix, err = l.ReadLine()
	if !isPrefix || !bytes.Equal(line, data[:minReadBufferSize]) || err != nil {
		t.Errorf("bad result for second line: got %q want %q %v", line, data[:minReadBufferSize], err)
	}
	data = data[len(line):]
	line, isPrefix, err = l.ReadLine()
	if isPrefix || !bytes.Equal(line, data[:minReadBufferSize/2]) || err != nil {

            searchPaging(data, form);
        });
    }

    /**
     * Search with paging.
     * @param data The render data.
     * @param form The search form.
     */
    protected void searchPaging(final RenderData data, final SearchForm form) {

        // Create test data and dump from offset
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        Hexdump.hexdump(ps, data, offset, length);
        String output = baos.toString();

        assertNotNull(output);
        // Should start at offset 0 in display but show data from offset 16
        assertTrue(output.contains("00000:"));

							<c:if test="${eoled}">
								<li class="nav-item" data-bs-toggle="tooltip" data-placement="left" title="<la:message key="labels.eol_error" />">
									<a class="nav-link active" href="${eolLink}" target="_olh"><em class="fas fa-times-circle text-danger"></a>
								</li>
							</c:if>
							<c:if test="${developmentMode}">
								<li class="nav-item" data-bs-toggle="tooltip" data-placement="left"

      if (context.executionException.isPresent) return@AfterEachCallback
      assertThat(data.readByteString().hex(), "Data not empty")
        .isEqualTo("")
    }

  // Mutually exclusive. Use the one corresponding to the peer whose behavior you wish to test.
  private val serverWriter =
    WebSocketWriter(
      isClient = false,
      sink = data,
      random = random,
      perMessageDeflate = false,

                .body("{\"test\":\"data\"}");

        assertNotNull(request);
        assertEquals(Method.POST, request.method());
        assertEquals("UTF-8", request.encoding());
        assertEquals(2048, request.threshold());
        assertEquals("{\"test\":\"data\"}", request.body());
    }

    @Test
    public void testAllHttpMethods() {

    }

    @Test
    void testReadUnparsedTagged_WrongTag() {
        // Expecting tag 2, but data has tag 1
        byte[] data = new byte[] { (byte) 0xA1, 0x03, 0x01, 0x02, 0x03 };
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        ASN1InputStream ais = new ASN1InputStream(bais);
        assertThrows(IOException.class, () -> {
            ASN1Util.readUnparsedTagged(2, 10, ais);

        assertEquals(20, SMBUtil.readInt4(dst, 19));

        // Verify data count (4 bytes at position 23)
        assertEquals(80, SMBUtil.readInt4(dst, 23));

        // Verify data offset (4 bytes at position 27)
        assertEquals(90, SMBUtil.readInt4(dst, 27));

        // Verify data displacement (4 bytes at position 31)
        assertEquals(70, SMBUtil.readInt4(dst, 31));

        byte[] invalidToken = "invalid-relevant-auth-data-token".getBytes();

        // WHEN parsing the auth data
        // THEN a PACDecodingException should be thrown
        assertThrows(PACDecodingException.class, () -> {
            KerberosAuthData.parse(KerberosConstants.AUTH_DATA_RELEVANT, invalidToken, mockKeys);
        }, "Parsing invalid relevant auth data should throw a PACDecodingException.");
    }

                                                       items="${stopwordsItemItems}">
                                                <tr
                                                        data-href="${contextPath}/admin/dict/stopwords/details/${f:u(dictId)}/4/${f:u(data.id)}">
                                                    <td>${f:h(data.inputValue)}</td>