}

  @Override
  Spliterator<K> keySpliterator() {
    return delegate.keySet().spliterator();
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    return delegate.containsKey(key);
  }

  @Override
  @CheckForNull
  public V get(@CheckForNull Object key) {

        futures.isEmpty()
            ? Collections.<@Nullable Present<V>>emptyList()
            : Lists.<@Nullable Present<V>>newArrayListWithCapacity(futures.size());

    // Populate the results list with null initially.
    for (int i = 0; i < futures.size(); ++i) {
      values.add(null);
    }

    this.values = values;
  }

  @Override
  final void collectOneValue(int index, @ParametricNullness V returnValue) {

        assertNotNull(res, "null classpath container after compile transform");
        assertNotNull(res.getClasspath(), "null classpath after compile transform");
        assertEquals(3, res.getClasspath().size(), "compile classpath should have 3 entries");
    }

    // ------------------------------------------------------------------------------------------
    @Test
    void testRuntimeClasspathTransform() throws Exception {

if err != nil {
 log.Fatalln(err)
}

n, err := s3Client.PutObject("my-bucketname", "my-objectname", object, objectStat.Size(), minio.PutObjectOptions{ContentType: "application/octet-stream", StorageClass: "REDUCED_REDUNDANCY"})
if err != nil {
 log.Fatalln(err)
}
log.Println("Uploaded", "my-objectname", " of size: ", n, "Successfully.")

   * them until they are needed.  When there is no contention, all
   * updates are made to the base field.  Upon first contention (a
   * failed CAS on base update), the table is initialized to size 2.
   * The table size is doubled upon further contention until
   * reaching the nearest power of two greater than or equal to the
   * number of CPUS. Table slots remain empty (null) until they are
   * needed.
   *

import org.lastaflute.web.validation.Required;
import org.lastaflute.web.validation.theme.conversion.ValidateTypeFailure;

import jakarta.validation.constraints.Size;

/**
 * @author Keiichi Watanabe
 */
public class EditForm extends CreateForm {

    @Required
    @Size(max = 1000)
    public String id;

    @Required
    @ValidateTypeFailure
    public Integer versionNo;

        requestBody.put("doc", doc);
        return requestBody;
    }

    @Override
    protected Map<String, Object> createSearchBody(final int size) {
        final Map<String, Object> searchBody = new HashMap<>();
        searchBody.put("size", size);
        searchBody.put("q", NAME_PREFIX + "*");
        return searchBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {

      assertThat(graph.edges()).isEmpty();
      AbstractGraphTest.validateGraph(graph);

      while (graph.nodes().size() < NUM_NODES) {
        graph.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(graph.nodes());
      while (graph.edges().size() < NUM_EDGES) {
        graph.putEdge(getRandomElement(nodeList, gen), getRandomElement(nodeList, gen));
      }

    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
    assertEquals("[foo x 2, bar]", multiset.toString());
  }

  public void testCreateWithSize() {
    Multiset<String> multiset = LinkedHashMultiset.create(50);
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));

rep_obj2_etag=$(echo "${stat_out2_rep}" | jq '.etag')
rep_obj2_size=$(echo "${stat_out2_rep}" | jq '.size')
rep_obj2_md5=$(echo "${stat_out2_rep}" | jq '.metadata."X-Amz-Server-Side-Encryption-Customer-Key-Md5"')

# Check the etag and size of replicated SSEC objects
if [ "${rep_obj1_etag}" != "${src_obj1_etag}" ]; then