assertThat(stopwatch.toString()).isEqualTo("1.001 \u03bcs");
    ticker.advance(8998);
    assertThat(stopwatch.toString()).isEqualTo("9.999 \u03bcs");
    stopwatch.reset();
    stopwatch.start();
    ticker.advance(1234567);
    assertThat(stopwatch.toString()).isEqualTo("1.235 ms");
    stopwatch.reset();
    stopwatch.start();
    ticker.advance(5000000000L);
    assertThat(stopwatch.toString()).isEqualTo("5.000 s");

        assertTrue(result.isPresent());
        assertEquals(testValue, result.get());
    }

    @Test
    public void test_ofNullable_withBigDecimal() {
        BigDecimal testValue = new BigDecimal("123.456");
        OptionalEntity<BigDecimal> result = OptionalUtil.ofNullable(testValue);

        assertNotNull(result);
        assertTrue(result.isPresent());
        assertEquals(testValue, result.get());
    }

        // Test with empty string
        searchRenderData.setQueryId("");
        assertEquals("", searchRenderData.getQueryId());

        // Test with UUID-like string
        String uuid = "123e4567-e89b-12d3-a456-426614174000";
        searchRenderData.setQueryId(uuid);
        assertEquals(uuid, searchRenderData.getQueryId());

        // Test with simple ID
        searchRenderData.setQueryId("query-001");

        assertEquals(minFlags, minAvFlags.getFlags(), "Flags should match Integer.MIN_VALUE");

        // Test with a negative integer
        int negativeFlags = -12345;
        AvFlags negAvFlags = new AvFlags(negativeFlags);
        assertNotNull(negAvFlags, "AvFlags object should not be null for negative flags");

    }

    @Test
    void throwsWhenOutputExceedsProvidedBuffer() throws Exception {
        byte[] header = buildHeader(NtStatus.NT_STATUS_SUCCESS);
        byte[] output = new byte[] { 1, 2, 3, 4, 5, 6 };
        byte[] body = buildIoctlResponseBody(Smb2IoctlRequest.FSCTL_SRV_COPYCHUNK_WRITE, new byte[16], 0, null, output.length, output, 0);
        byte[] packet = new byte[header.length + body.length];

    assertCrc(0xf3dbd4fe, "1234567890".getBytes(UTF_8));
    assertCrc(0xBFE92A83, "23456789".getBytes(UTF_8));
  }

  public void testAgainstSimplerImplementation() {
    Random r = new Random(1234567);
    for (int length = 0; length < 1000; length++) {
      byte[] bytes = new byte[length];
      r.nextBytes(bytes);
      assertCrc(referenceCrc(bytes), bytes);
    }
  }

  public void testBytes() {
    TestHasher hasher = new TestHasher(); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    hasher.putByte((byte) 1);
    hasher.putBytes(new byte[] {2, 3, 4, 5, 6});
    hasher.putByte((byte) 7);
    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});
    hasher.assertBytes(expected);
  }

  public void testShort() {

  static final double OTHER_TWO_VALUES_MEAN = (123.456 - 789.012) / 2;
  static final double TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS =
      (12.34 - TWO_VALUES_MEAN) * (123.456 - OTHER_TWO_VALUES_MEAN)
          + (-56.78 - TWO_VALUES_MEAN) * (-789.012 - OTHER_TWO_VALUES_MEAN);

  /**
   * Helper class for testing with non-finite values. {@link #ALL_MANY_VALUES} gives a number of

    @Test
    public void test_numberKeyObject() {
        Integer key = 12345;
        crawlerStatsHelper.begin(key);
        crawlerStatsHelper.record(key, "test_action");
        crawlerStatsHelper.done(key);

        String[] values = localLogMsg.get().split("\t");
        assertEquals(4, values.length);
        assertEquals("url:12345", values[0]);
        assertTrue(values[1].startsWith("time:"));

    assertThat(j.useForNull("00").join(mapWithNulls)).isEqualTo("a:00;00:b");

    StringBuilder sb = new StringBuilder();
    j.appendTo(sb, ImmutableMap.of(1, 2, 3, 4, 5, 6));
    assertThat(sb.toString()).isEqualTo("1:2;3:4;5:6");
  }

  public void testEntries() {
    MapJoiner j = Joiner.on(";").withKeyValueSeparator(":");