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

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

      0x1e,
      0x1f,
      0x5c,
      0xfb,
      0x7ffc,
      0x20,
      0xffb,
      0x3fc,
      0x1ffa,
      0x21,
      0x5d,
      0x5e,
      0x5f,
      0x60,
      0x61,
      0x62,
      0x63,
      0x64,
      0x65,
      0x66,
      0x67,
      0x68,
      0x69,
      0x6a,
      0x6b,
      0x6c,
      0x6d,
      0x6e,
      0x6f,

  }

  /** Tests that we always get a non-negative optimal size. */
  public void testOptimalSize() {
    for (int n = 1; n < 1000; n++) {
      for (double fpp = Double.MIN_VALUE; fpp < 1.0; fpp += 0.001) {
        assertTrue(BloomFilter.optimalNumOfBits(n, fpp) >= 0);
      }
    }

    // some random values
    Random random = new Random(0);
    for (int repeats = 0; repeats < 10000; repeats++) {

        assertEquals(2000, channelInfo.getBytesReceived());
        assertEquals(1, channelInfo.getRequestsSent());
        assertEquals(1, channelInfo.getErrors());
        assertEquals(1.0, channelInfo.getErrorRate(), 0.01);
    }

    @Test
    void testPendingOperations() {
        assertEquals(0, channelInfo.getRequestsPending());
        assertTrue(channelInfo.getPendingOperations().isEmpty());

  /**
   * Maximum allowed false positive probability of detecting a hash flooding attack given random
   * input.
   */
  @VisibleForTesting static final double HASH_FLOODING_FPP = 0.001;

  /**
   * Maximum allowed length of a hash table bucket before falling back to a j.u.HashMap based
   * implementation. Experimentally determined.
   */
  static final int MAX_HASH_BUCKET_LENGTH = 8;

                    ((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")

        assertEquals("010203", StringUtil.toHex(new byte[] { 1, 2, 3 }));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToHex2() throws Exception {
        assertEquals("0001", StringUtil.toHex(1));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testAppendHex() throws Exception {
        final StringBuilder buf = new StringBuilder();

    assertThat(array).hasLength(2);
    assertNull(array[0]);
  }

  public void testNewArray_fromArray_ofArray() {
    String[][] array = ObjectArrays.newArray(new String[0][0], 1);
    assertEquals(String[][].class, array.getClass());
    assertThat(array).hasLength(1);
    assertNull(array[0]);
  }

  @GwtIncompatible // ObjectArrays.concat(Object[], Object[], Class)

 *   <dt>An IPv6 "IPv4 compatible" (or "compat") address, {@code "::192.168.0.1"}.
 *   <dd>{@code 00 00 00 00 00 00 00 00 00 00 00 00 c0 a8 00 01}
 *   <dt>An IPv6 "IPv4 mapped" address, {@code "::ffff:192.168.0.1"}.
 *   <dd>{@code 00 00 00 00 00 00 00 00 00 00 ff ff c0 a8 00 01}
 * </dl>
 *
 * <p>A few notes about IPv6 "IPv4 mapped" addresses and their observed use in Java.
 *

  }

  /**
   * Maximum allowed false positive probability of detecting a hash flooding attack given random
   * input.
   */
  @VisibleForTesting(
      )
  static final double HASH_FLOODING_FPP = 0.001;

  /**
   * Maximum allowed length of a hash table bucket before falling back to a j.u.LinkedHashSet based
   * implementation. Experimentally determined.
   */
  private static final int MAX_HASH_BUCKET_LENGTH = 9;