Duration initial = MonotonicClock.elapsed();
        Thread.sleep(50); // Longer delay for more reliable measurement
        Duration later = MonotonicClock.elapsed();

        assertTrue(later.compareTo(initial) > 0, "Elapsed time should increase");
        assertTrue(
                later.minus(initial).toMillis() >= 45,
                "Elapsed time difference should be at least 45ms (accounting for some timing variance)");

    assertEquals(0, binarySearch(0, 6) { index -> 1.compareTo(table[index]) })
    assertEquals(1, binarySearch(0, 6) { index -> 3.compareTo(table[index]) })
    assertEquals(2, binarySearch(0, 6) { index -> 5.compareTo(table[index]) })
    assertEquals(3, binarySearch(0, 6) { index -> 7.compareTo(table[index]) })
    assertEquals(4, binarySearch(0, 6) { index -> 9.compareTo(table[index]) })

        assertEquals(0, new BigDecimal("0.1").compareTo(BigDecimalConversionUtil.toBigDecimal(Float.valueOf(0.1F))));

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

* Validação de dados
* Anotação da API e documentação automática

Você apenas tem que declará-los uma vez.

        assertTrue(DialectVersion.SMB1.compareTo(DialectVersion.SMB202) < 0);
        assertTrue(DialectVersion.SMB202.compareTo(DialectVersion.SMB210) < 0);
        assertTrue(DialectVersion.SMB210.compareTo(DialectVersion.SMB300) < 0);
        assertTrue(DialectVersion.SMB300.compareTo(DialectVersion.SMB302) < 0);
        assertTrue(DialectVersion.SMB302.compareTo(DialectVersion.SMB311) < 0);
    }

    @Test

        }

        @Override
        public int compareTo(Item item) {
            if (item == null) {
                return BigInteger.ZERO.equals(value) ? 0 : 1; // 1.0 == 1, 1.1 > 1
            }

            return switch (item.getType()) {
                case INT_ITEM, LONG_ITEM -> 1;
                case BIGINTEGER_ITEM -> value.compareTo(((BigIntegerItem) item).value);
                case STRING_ITEM -> 1;

        assertTrue(CrawlerStatus.INITIALIZING.compareTo(CrawlerStatus.RUNNING) < 0);
        assertTrue(CrawlerStatus.INITIALIZING.compareTo(CrawlerStatus.DONE) < 0);
        assertTrue(CrawlerStatus.RUNNING.compareTo(CrawlerStatus.DONE) < 0);

        // Reverse comparisons
        assertTrue(CrawlerStatus.RUNNING.compareTo(CrawlerStatus.INITIALIZING) > 0);
        assertTrue(CrawlerStatus.DONE.compareTo(CrawlerStatus.INITIALIZING) > 0);

        if (size.divide(ONE_EB_BI).compareTo(BigInteger.ZERO) > 0) {
            displaySize = new BigDecimal(size.divide(ONE_PB_BI)).divide(BigDecimal.valueOf(1000)) + "EB";
        } else if (size.divide(ONE_PB_BI).compareTo(BigInteger.ZERO) > 0) {
            displaySize = new BigDecimal(size.divide(ONE_TB_BI)).divide(BigDecimal.valueOf(1000)) + "PB";
        } else if (size.divide(ONE_TB_BI).compareTo(BigInteger.ZERO) > 0) {

        // Digits are greater than letters
        assertTrue(seven.compareTo(capitalJ) > 0, "expected 7 > J");
        assertTrue(capitalJ.compareTo(seven) < 0, "expected J < 1");
        assertTrue(seven.compareTo(lowerCaseC) > 0, "expected 7 > c");
        assertTrue(lowerCaseC.compareTo(seven) < 0, "expected c < 7");
    }

    @Test
    void testNonAsciiDigits() { // These should not be treated as digits.

      assertTrue(result.compareTo(x) >= 0);
      assertTrue(result.compareTo(x.add(x)) < 0);
    }
  }

  public void testFloorPowerOfTwo() {
    for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) {
      BigInteger result = BigIntegerMath.floorPowerOfTwo(x);
      assertTrue(BigIntegerMath.isPowerOfTwo(result));
      assertTrue(result.compareTo(x) <= 0);