charset = charset,
          )
        values +=
          value.canonicalizeWithCharset(
            encodeSet = FORM_ENCODE_SET,
            alreadyEncoded = true,
            plusIsSpace = true,
            charset = charset,
          )
      }

      fun build(): FormBody = FormBody(names, values)
    }

  companion object {

    public void setAvailable_PercentileRanks(double[] values) {
        setAvailable_PercentileRanks(values, null);
    }

    public void setAvailable_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setAvailable_PercentileRanks("available", values, opLambda);
    }

    public void setAvailable_PercentileRanks(String name, double[] values,

        setCreatedTime_PercentileRanks(values, null);
    }

    public void setCreatedTime_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setCreatedTime_PercentileRanks("createdTime", values, opLambda);
    }

    public void setCreatedTime_PercentileRanks(String name, double[] values,

            final String[] values = StringUtils.split(s, "=", 2);
            List<Pair<String, String>> list = responseHeaderMap.get(values[0]);
            if (list == null) {
                list = new ArrayList<>();
                responseHeaderMap.put(values[0], list);
            }
            final String[] keyValue = StringUtils.split(values[1], ":", 2);
            if (keyValue.length == 2) {

        .add("kit:kat") // Space after colon is not required.
        .build()
    assertThat(headers.values("foo")).containsExactly("bar", "baz", "bak")
    assertThat(headers.values("key")).containsExactly("value")
    assertThat(headers.values("ping")).containsExactly("pong")
    assertThat(headers.values("kit")).containsExactly("kat")
  }

  @Test fun addThrowsOnEmptyName() {

        assertEquals("12345678", Hexdump.toHexString(0x12345678L, 8));
    }

    @Test
    @DisplayName("Should handle special byte values correctly")
    void testSpecialByteValues() {
        // Test boundary values
        byte[] data = { (byte) 0x00, // min value
                (byte) 0xFF, // max value (-1 as signed byte)
                (byte) 0x7F, // max positive

import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
@DisplayName("FileEntry interface contract tests")
class FileEntryTest {

    @Test
    @DisplayName("Mock returns configured values")
    void mockReturnsConfiguredValues() {
        FileEntry mock = mock(FileEntry.class);
        when(mock.getName()).thenReturn("test.txt");
        when(mock.getType()).thenReturn(1);

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testReplaceValuesPreservesOrder() {
    List<V> values = asList(v3(), v1(), v4());

    for (K k : sampleKeys()) {
      resetContainer();
      multimap().replaceValues(k, values);
      assertGet(k, values);
    }
  }

        return removeFromColumnIf(Maps.keyPredicateOnEntries(not(in(c))));
      }
    }

    @Override
    Collection<V> createValues() {
      return new Values();
    }

    @WeakOuter
    private final class Values extends Maps.Values<R, V> {
      Values() {
        super(Column.this);
      }

      @Override
      public boolean remove(@Nullable Object obj) {

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testReplaceValuesPreservesOrder() {
    List<V> values = asList(v3(), v1(), v4());

    for (K k : sampleKeys()) {
      resetContainer();
      multimap().replaceValues(k, values);
      assertGet(k, values);
    }
  }