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

		{+1, +1e3 - 0e0, "1.000001"},
		{+1, +1e0 - 0e0, "1.000000001"},
		{0, 1e9 - 1e0, "0.999999999"},
		{0, 1e9 - 1e3, "0.999999"},
		{0, 1e9 - 1e6, "0.999"},
		{0, 0e0, "0"},
		{0, 1e6 + 0e0, "0.001"},
		{0, 1e3 + 0e0, "0.000001"},
		{0, 1e0 + 0e0, "0.000000001"},
		{-1, -1e9 + 1e0, "-1.999999999"},
		{-1, -1e9 + 1e3, "-1.999999"},
		{-1, -1e9 + 1e6, "-1.999"},
		{-1, -0e0 + 0e0, "-1"},

  /**
   * 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;

      base
        .newBuilder()
        .host("[::0001]")
        .build()
        .toString(),
    ).isEqualTo("http://[::1]/")
    assertThat(
      base
        .newBuilder()
        .host("::1")
        .build()
        .toString(),
    ).isEqualTo("http://[::1]/")
    assertThat(
      base
        .newBuilder()
        .host("::0001")
        .build()
        .toString(),

		},
		{
			name:    valueBuilders[4]().String(),
			want:    "4919",
			wantAlt: "0",
		},
		{
			name:    valueBuilders[5]().String(),
			want:    "2006-01-02T15:04:05Z",
			wantAlt: "0001T",
		},
		{
			name:    valueBuilders[6]().String(),
			want:    "string contents",
			wantAlt: "",
		},
	}

	for i, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {

    assertEquals('q', in.readChar());
    assertEquals('e', in.readChar());
    assertEquals('d', in.readChar());
  }

  public void testNewDataInput_readUnsignedShort() {
    byte[] data = {0, 0, 0, 1, (byte) 0xFF, (byte) 0xFF, 0x12, 0x34};
    ByteArrayDataInput in = ByteStreams.newDataInput(data);
    assertEquals(0, in.readUnsignedShort());
    assertEquals(1, in.readUnsignedShort());

          Doubles.asList(
              -Double.MIN_VALUE,
              -Double.MIN_NORMAL,
              -1,
              -20,
              Double.NaN,
              Double.NEGATIVE_INFINITY,
              -0.001));

  public void testFuzzyEqualsFinite() {
    for (double a : FINITE_DOUBLE_CANDIDATES) {
      for (double b : FINITE_DOUBLE_CANDIDATES) {
        for (double tolerance : FINITE_TOLERANCE_CANDIDATES) {

  }

  /**
   * 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;

    assertEquals('q', in.readChar());
    assertEquals('e', in.readChar());
    assertEquals('d', in.readChar());
  }

  public void testNewDataInput_readUnsignedShort() {
    byte[] data = {0, 0, 0, 1, (byte) 0xFF, (byte) 0xFF, 0x12, 0x34};
    ByteArrayDataInput in = ByteStreams.newDataInput(data);
    assertEquals(0, in.readUnsignedShort());
    assertEquals(1, in.readUnsignedShort());

        .isEqualTo("BigInteger must be greater than or equal to 0");
  }

  public void testFromIpv4BigIntegerValid() {
    checkBigIntegerConversion("0.0.0.0", BigInteger.ZERO);
    checkBigIntegerConversion("0.0.0.1", BigInteger.ONE);
    checkBigIntegerConversion("127.255.255.255", BigInteger.valueOf(Integer.MAX_VALUE));
    checkBigIntegerConversion(