b.Run(" 00000000|X0000000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 0, 1, size, b) })
	b.Run(" X0000000|00000000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 1, 0, size, b) })
	b.Run(" X0000000|X0000000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 1, 1, size, b) })
	b.Run(" 00000000|XXXXXXXX ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 0, 8, size, b) })

                (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, // 0x00000000
                (byte) 0xEF, (byte) 0xCD, (byte) 0xAB, (byte) 0x89 // 0x89ABCDEF
        };

        assertEquals(0x12345678, SMBUtil.readInt4(src, 0));
        assertEquals(0xFFFFFFFF, SMBUtil.readInt4(src, 4));
        assertEquals(0x00000000, SMBUtil.readInt4(src, 8));
        assertEquals(0x89ABCDEF, SMBUtil.readInt4(src, 12));
    }

		domains          []string
		expectedResource string
	}{
		{"/a/b/c", "test.mydomain.com", []string{"mydomain.com"}, "/test/a/b/c"},
		{"/a/b/c", "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:17000", []string{"mydomain.com"}, "/a/b/c"},
		{"/a/b/c", "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", []string{"mydomain.com"}, "/a/b/c"},
		{"/a/b/c", "192.168.1.1:9000", []string{"mydomain.com"}, "/a/b/c"},

    ticker.advance((long) (1.5 * 60 * 1000000000L));
    assertThat(stopwatch.toString()).isEqualTo("1.500 min");
    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (2.5 * 60 * 60 * 1000000000L));
    assertThat(stopwatch.toString()).isEqualTo("2.500 h");
    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (7.25 * 24 * 60 * 60 * 1000000000L));

class HexdumpTest extends BaseTest {

    @Test
    @DisplayName("Should convert integer to hex string with specified size")
    void testToHexStringInt() {
        // Test zero
        assertEquals("00000000", Hexdump.toHexString(0, 8));
        assertEquals("0000", Hexdump.toHexString(0, 4));
        assertEquals("00", Hexdump.toHexString(0, 2));

        // Test positive values

        processRemaining(EMPTY);
      }
      return HashCode.fromInt(~crc0);
    }

    static final int[] byteTable = {
      0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c,
      0x26a1e7e8, 0xd4ca64eb, 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
      0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, 0x105ec76f, 0xe235446c,

      var hostname = inetAddress.hostName
      if (inetAddress is Inet6Address && hostname.contains(':')) {
        // hostname is likely some form representing the IPv6 bytes
        // 2001:0db8:85a3:0000:0000:8a2e:0370:7334
        // 2001:db8:85a3::8a2e:370:7334
        // ::1
        hostname = "[$hostname]"
      }

      val localPort = socket.localPort

 */
@NullUnmarked
public class HashCodeBenchmark {

  // Use a statically configured random instance for all of the benchmarks
  private static final Random random = new Random(42);

  @Param({"1000", "100000"})
  private int size;

  @Param WhereToDiffer whereToDiffer;

  @Param EqualsImplementation equalsImpl;

  private enum WhereToDiffer {
    ONE_PERCENT_IN,
    LAST_BYTE,
    NOT_AT_ALL;
  }

@Measurement(iterations = 7)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Fork(value = 1)
public class BytesArrayReadVLongBenchmark {

    @Param(value = { "10000000" })
    int entries;

    private StreamInput streamInput;

    @Setup
    public void initResults() throws IOException {
        final BytesStreamOutput tmp = new BytesStreamOutput();

        assertEquals("1,000,000", FessFunctions.formatNumber(1000000, "###,###"));
    }

    @Test
    public void test_formatFileSize() {
        assertEquals("0", FessFunctions.formatFileSize(0));
        assertEquals("1000", FessFunctions.formatFileSize(1000));
        assertEquals("976.6K", FessFunctions.formatFileSize(1000000));