assertEquals(0, new BigDecimal("0.00001").compareTo(BigDecimalConversionUtil.toBigDecimal(Double.valueOf(0.00001D))));
        assertEquals(0, new BigDecimal("0.0000001").compareTo(BigDecimalConversionUtil.toBigDecimal(Double.valueOf(0.0000001D))));

        assertEquals(0, new BigDecimal("0.123").compareTo(BigDecimalConversionUtil.toBigDecimal(Double.valueOf(0.123D))));

        src[srcIndex + 16] = 0x00;
        src[srcIndex + 17] = 0x04; // 00000100 - B-node, active

        // P-node (01)
        System.arraycopy("PNODE           ".getBytes("US-ASCII"), 0, src, srcIndex + 19, 16);
        src[srcIndex + 34] = 0x00;
        src[srcIndex + 35] = 0x24; // 00100100 - P-node, active

        // M-node (10)

    private static int[] bigbyte = { 0x800000, 0x400000, 0x200000, 0x100000, 0x080000, 0x040000, 0x020000, 0x010000, 0x008000, 0x004000,
            0x002000, 0x001000, 0x000800, 0x000400, 0x000200, 0x000100, 0x000080, 0x000040, 0x000020, 0x000010, 0x000008, 0x000004,
            0x000002, 0x000001 };

  @Test
  fun hostIpv6WithIpv4SuffixWithHexadecimalPrefix() {
    // Chrome interprets a leading '0x' as hexadecimal; Firefox rejects them. (We reject them.)
    assertInvalid(
      "http://[0:0:0:0:0:1:0.0x10.0.0x10]/",
      "Invalid URL host: \"[0:0:0:0:0:1:0.0x10.0.0x10]\"",
    )
  }

  @Test
  fun hostIpv6WithMalformedIpv4Suffix() {
    assertInvalid(
      "http://[0:0:0:0:0:1:0.0:0.0]/",

    assertThat(cookie.matches("http://[::1]/".toHttpUrl())).isTrue()
  }

  @Test fun domainMatchesIpv6AddressWithCompression() {
    val cookie = parse("http://[0001:0000::]/".toHttpUrl(), "a=b; domain=0001:0000::")
    assertThat(cookie!!.domain).isEqualTo("1::")
    assertThat(cookie.matches("http://[1::]/".toHttpUrl())).isTrue()
  }

  @Test fun domainMatchesIpv6AddressWithIpv4Suffix() {

            b and 0x80 == 0x80 -> {
              // 1NNNNNNN
              val index = readInt(b, PREFIX_7_BITS)
              readIndexedHeader(index - 1)
            }
            b == 0x40 -> {
              // 01000000
              readLiteralHeaderWithIncrementalIndexingNewName()
            }
            b and 0x40 == 0x40 -> {
              // 01NNNNNN
              val index = readInt(b, PREFIX_6_BITS)

        assertNotNull(addresses);
        assertTrue(addresses.length > 0);
        // IPv6 loopback can be represented as ::1 or 0:0:0:0:0:0:0:1
        String hostAddress = addresses[0].getHostAddress();
        assertTrue(hostAddress.contains(":"));
        assertTrue(hostAddress.equals("::1") || hostAddress.equals("0:0:0:0:0:0:0:1"));

        // Test IPv6 address with brackets
        host = "[2001:db8::1]";
        addresses = resolver.resolve(host);

 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class HashMultisetAddPresentBenchmark {
  private static final int ARRAY_MASK = 0x0ffff;
  private static final int ARRAY_SIZE = 0x10000;
  List<Multiset<Integer>> multisets = new ArrayList<>(0x10000);
  int[] queries = new int[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {
    Random random = new Random();
    multisets.clear();
    for (int i = 0; i < ARRAY_SIZE; i++) {

     */
    public static final int FILE_OPEN_REQUIRING_OPLOCK = 0x10000;
    /**
     * Any open of this file cannot be exclusive
     */
    public static final int FILE_DISALLOW_EXCLUSIVE = 0x20000;
    /**
     * Reserve an opportunistic lock filter on the open
     */
    public static final int FILE_RESERVE_OPFILTER = 0x100000;
    /**
     * Open a reparse point and bypass normal reparse point processing

        });
    }

    @Test
    @DisplayName("Should convert integer to hex string with padding")
    void testIntToHexString() {
        // Test various integer values
        assertEquals("00000000", Hexdump.toHexString(0, 8));
        assertEquals("000000FF", Hexdump.toHexString(255, 8));
        assertEquals("00001000", Hexdump.toHexString(4096, 8));
        assertEquals("FFFFFFFF", Hexdump.toHexString(-1, 8));