byte[] data4 = { 0x00, 0x11, 0x22, 0x33, 0x44 };
        assertEquals("00", Hexdump.toHexString(data4, 1, 2)); // Bug: ignores srcIndex, reads from 0
        assertEquals("0011", Hexdump.toHexString(data4, 1, 4)); // Bug: ignores srcIndex, reads from 0
        assertEquals("0011", Hexdump.toHexString(data4, 2, 4)); // Bug: ignores srcIndex, reads from 0
    }

    @Test

[61:24:74]:98  s:http h:example.org p:/foo/[61:24:74]:98
http:[61:27]/:foo  s:http h:example.org p:/foo/[61:27]/:foo
http://[1::2]:3:4
http://2001::1
http://2001::1]
http://2001::1]:80
http://[2001::1]  s:http h:[2001::1] p:/
http://[2001::1]:80  s:http h:[2001::1] p:/
http:/example.com/  s:http h:example.org p:/example.com/
ftp:/example.com/  s:ftp h:example.com p:/
https:/example.com/  s:https h:example.com p:/

        assertNull(sentIndex.get());

        sentIndex.set(null);
        sentDocList.clear();
        docList.add(new HashMap<>(Map.of(//
                "_id", "001", //
                "config_id", "W01", //
                "url", "http://test.com/001"//
        )));
        docList.add(new HashMap<>(Map.of(//
                "_id", "002", //
                "thumbnail", "http://test.com/002", //

    assertThat(Doubles.toArray(none)).isEqualTo(EMPTY);

    List<Double> one = Arrays.asList(1.0);
    assertThat(Doubles.toArray(one)).isEqualTo(ARRAY1);

    double[] array = {0.0, 1.0, Math.PI};

    List<Double> three = Arrays.asList(0.0, 1.0, Math.PI);
    assertThat(Doubles.toArray(three)).isEqualTo(array);

    assertThat(Doubles.toArray(Doubles.asList(array))).isEqualTo(array);
  }

        assertEquals(5120, stats.getBytesTransferred(), "Should have transferred 5KB total");
        assertEquals(1, stats.getOperationErrors(), "Should have 1 error");
        assertEquals(0.25, stats.getErrorRate(), 0.001, "Error rate should be 25% (1 error out of 4 successful operations)");

        // Verify latency calculations
        assertTrue(stats.getAverageReadLatencyMicros() > 0, "Read latency should be positive");

        checkVersionsOrder("1", "2");
        checkVersionsOrder("1.5", "2");
        checkVersionsOrder("1", "2.5");
        checkVersionsOrder("1.0", "1.1");
        checkVersionsOrder("1.1", "1.2");
        checkVersionsOrder("1.0.0", "1.1");
        checkVersionsOrder("1.0.1", "1.1");
        checkVersionsOrder("1.1", "1.2.0");

        checkVersionsOrder("1.0-alpha-1", "1.0");

            double percentUsed = ((fileFsSizeInfo.getCapacity() - fileFsSizeInfo.getFree()) * 100.0) / fileFsSizeInfo.getCapacity();

            // Then
            assertEquals(25.0, percentFree, 0.001);
            assertEquals(75.0, percentUsed, 0.001);
        }
    }

        .testEquals();
  }

  /**
   * The maximum allowed probability of falsely detecting a hash flooding attack if the input is
   * randomly generated.
   */
  private static final double HASH_FLOODING_FPP = 0.001;

  public void testReuseBuilderReducingHashTableSizeWithPowerOfTwoTotalElements() {
    ImmutableSet.Builder<Object> builder = ImmutableSet.builderWithExpectedSize(6);
    builder.add(0);

            // When - calculate percentage free
            double percentFree = (allocInfo.getFree() * 100.0) / allocInfo.getCapacity();

            // Then
            assertEquals(25.0, percentFree, 0.001);
        }

        @Test
        @DisplayName("Should support available space check pattern")
        void shouldSupportAvailableSpaceCheckPattern() {
            // Given

                    ((fileFsFullSizeInfo.getCapacity() - fileFsFullSizeInfo.getFree()) * 100.0) / fileFsFullSizeInfo.getCapacity();

            // Then
            assertEquals(25.0, percentFree, 0.001);
            assertEquals(75.0, percentUsed, 0.001);
        }

        @Test
        @DisplayName("Should differentiate between caller available and actual free units")