}

    static final class DuplicateKey {
      private final Object key;
      private final Object value1;
      private final Object value2;

      DuplicateKey(Object key, Object value1, Object value2) {
        this.key = key;
        this.value1 = value1;
        this.value2 = value2;
      }

      IllegalArgumentException exception() {
        return new IllegalArgumentException(

- Fixed the documentation for the default value of the `procMount` entry in `securityContext` within a Pod.
  The documentation was previously using the name of the internal variable `DefaultProcMount`, rather than the actual value, "Default". ([#125782](https://github.com/kubernetes/kubernetes/pull/125782), [@aborrero](https://github.com/aborrero)) [SIG Apps and Node]

    builder.put("key", "value");
    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

  public void testBuilderWithExpectedKeysPositive() {
    ImmutableSetMultimap.Builder<String, String> builder =
        ImmutableSetMultimap.builderWithExpectedKeys(1);
    builder.put("key", "value");

        list.add("a-value");
        Object value = new ValueHolder(list);

        assertNull(ReflectionValueExtractor.evaluate("h.value[", value));
        assertNull(ReflectionValueExtractor.evaluate("h.value[]", value));
        assertNull(ReflectionValueExtractor.evaluate("h.value[a]", value));
        assertNull(ReflectionValueExtractor.evaluate("h.value[0", value));

  // MultimapPutTester tests non-duplicate values, but ignores ordering

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAddsValueAtEnd() {
    for (K key : sampleKeys()) {
      for (V value : sampleValues()) {
        resetContainer();

        List<V> values = multimap().get(key);
        List<V> expectedValues = copyToList(values);

        assertTrue(multimap().put(key, value));
        expectedValues.add(value);

                for sub_value in value:
                    tg.start_soon(process_fn, sub_value.read)
            value = serialize_sequence_value(field=field, value=results)
        if value is not None:
            values[field.alias] = value
    for key, value in received_body.items():
        if key not in values:
            values[key] = value
    return values


async def request_body_to_args(

      add(value);
    }
  }

  /**
   * Adds the given values to the dataset.
   *
   * @param values a series of values
   */
  public void addAll(int... values) {
    for (int value : values) {
      add(value);
    }
  }

  /**
   * Adds the given values to the dataset.
   *
   * @param values a series of values, which will be converted to {@code double} values (this may

    type annotation for variables representing a Tensor or a value that can be
    converted to Tensor by `tf.convert_to_tensor`.
*   Calling ops with a python constants or numpy values is now consistent with
    tf.convert_to_tensor behavior. This avoids operations like tf.reshape
    truncating inputs such as from int64 to int32.
*   Adds `tf.sparse.map_values` to apply a function to the `.value`s of
    `SparseTensor` arguments.

    checkArgument(values.length > 0);
    double mean = values[0];
    for (int index = 1; index < values.length; index++) {
      double value = values[index];
      if (isFinite(value) && isFinite(mean)) {
        // Art of Computer Programming vol. 2, Knuth, 4.2.2, (15)
        mean += (value - mean) / (index + 1);
      } else {
        mean = calculateNewMeanNonFinite(mean, value);
      }
    }

   * <p>Though the method signature doesn't say so explicitly, the returned map has {@link Set}
   * values.
   */
  @Override
  public Map<K, Collection<V>> asMap() {
    return super.asMap();
  }

  /**
   * Stores a key-value pair in the multimap.
   *
   * @param key key to store in the multimap
   * @param value value to store in the multimap