{"000000000000bogus", 0, "invalid byte in chunk length"},
		{"00000000000000000", 0, "http chunk length too large"}, // could accept if we wanted
		{"10000000000000000", 0, "http chunk length too large"},
		{"00000000000000001", 0, "http chunk length too large"}, // could accept if we wanted
	}
	for i := uint64(0); i <= 1234; i++ {
		tests = append(tests, testCase{in: fmt.Sprintf("%x", i), want: i})
	}
	for _, tt := range tests {

dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> 1742532981 +0100

    @Test
    @DisplayName("Should convert long to hex string with padding")
    void testLongToHexString() {
        // Test various long values
        assertEquals("0000000000000000", Hexdump.toHexString(0L, 16));
        assertEquals("00000000000000FF", Hexdump.toHexString(255L, 16));
        assertEquals("FFFFFFFFFFFFFFFF", Hexdump.toHexString(-1L, 16));

        // Test different sizes

		"\x020000000000000000000" +
		"00000\v\x00\x00\x00\x00\x00000000000" +
		"00000000000000PK\x01\x0200" +
		"00000000000000000000" +
		"00\v\x00\x00\x00\x00\x00000000000000" +
		"00000000000PK\x01\x020000<" +
		"0\x00\x0000000000000000\v\x00\v" +
		"\x00\x00\x00\x00\x0000000000\x00\x00\x00\x00000" +
		"00000000PK\x01\x0200000000" +
		"0000000000000000\v\x00\x00\x00" +
		"\x00\x0000PK\x05\x06000000\x05\x00\xfd\x00\x00\x00" +

    for (i in 0..0x3f) formattedFlags.add(formatFlags(TYPE_HEADERS, i))
    assertThat(formattedFlags).containsExactly(
      "",
      "END_STREAM",
      "00000010",
      "00000011",
      "END_HEADERS",
      "END_STREAM|END_HEADERS",
      "00000110",
      "00000111",
      "PADDED",
      "END_STREAM|PADDED",
      "00001010",
      "00001011",
      "00001100",

      listOf(
        "Parsing: <http://example\t.\norg> against <http://example.org/foo/bar>",
        "Parsing: <http://f:0/c> against <http://example.org/foo/bar>",
        "Parsing: <http://f:00000000000000/c> against <http://example.org/foo/bar>",
        "Parsing: <http://f:\n/c> against <http://example.org/foo/bar>",
        "Parsing: <http://f:999999/c> against <http://example.org/foo/bar>",

        assertEquals("953.7M", FessFunctions.formatFileSize(1000000000));
        assertEquals("931.3G", FessFunctions.formatFileSize(1000000000000L));
        assertEquals("909.5T", FessFunctions.formatFileSize(1000000000000000L));
    }

    @Test
    public void test_parseDate() {
        Date date;

        date = FessFunctions.parseDate("");
        assertNull(date);

     *
     */
    private static final String HMAC_KEY = "HMAC";
    private static final byte[] MD5_CONSTANT = "signaturekey\0".getBytes(StandardCharsets.US_ASCII);
    private static final byte[] ZERO_IV = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    /**
     * Calculates a MAC using the ARCFOUR-HMAC-MD5 algorithm.
     * This method implements the Microsoft variant of the Kerberos ARCFOUR-HMAC-MD5 checksum.
     *

    assertInvalid(
      "http://[0:0:0:0:0:1:0.0.0.000000]/",
      "Invalid URL host: \"[0:0:0:0:0:1:0.0.0.000000]\"",
    )
    assertInvalid(
      "http://[0:0:0:0:0:1:0.010.0.010]/",
      "Invalid URL host: \"[0:0:0:0:0:1:0.010.0.010]\"",
    )
    assertInvalid(
      "http://[0:0:0:0:0:1:0.0.0.000001]/",
      "Invalid URL host: \"[0:0:0:0:0:1:0.0.0.000001]\"",
    )
  }

  @Test

	//		outcode(int($1), &$2, 0, &$4);
	//	}
	MOVF	foo<>+3(SB), F2
	MOVF	16(R1), F2
	MOVF	(R1), F2

	//	LFMOV fimm ',' freg
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	MOVF	$0.1, F2	// MOVF $(0.10000000000000001), F2

	//	LFMOV freg ',' freg
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	MOVF	F1, F2

	//	LFMOV freg ',' addr
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	MOVF	F2, foo<>+3(SB)