* k, valueFunction))}. {@code ImmutableMap.copyOf(stream.collect(Collectors.toMap(k -> k,
   * valueFunction)))} behaves similarly, but may not preserve the order of entries.
   *
   * @throws NullPointerException if any element of this iterable is {@code null}, or if {@code
   *     valueFunction} produces {@code null} for any key
   * @since 14.0
   */

        assertNotNull(key1);
        assertNotNull(key2);
        assertNotEquals(key1, key2);

        // Verify both cache entries exist
        DirectoryCacheEntry entry1 = directoryLeaseManager.getCacheEntry(dir1);
        DirectoryCacheEntry entry2 = directoryLeaseManager.getCacheEntry(dir2);

        assertNotNull(entry1);

                (scenarioDurations["durations"] as List<Map<String, Any>>).flatMap { duration ->
                    val testProject = duration["testProject"] as String
                    duration.entries
                        .filter { (key, _) -> key != "testProject" }
                        .map { (osString, timeInMs) ->
                            val os = Os.valueOf(osString.uppercase(Locale.US))

            new EntriesGenerator<K, V>(parentBuilder.getSubjectGenerator()))
        .withFeatures(computeEntriesFeatures(parentBuilder.getFeatures()))
        .named(parentBuilder.getName() + ".entries")
        .suppressing(parentBuilder.getSuppressedTests())
        .createTestSuite();
  }

  private static final class EntriesGenerator<K, V>

		return err
	}
	parentCtx := ctx
	ctx, cancelCause := context.WithCancelCause(ctx)
	var entries []chan metaCacheEntry

	for poolIdx, erasureSet := range z.serverPools {
		for setIdx, set := range erasureSet.sets {
			listOut := make(chan metaCacheEntry, 1)
			entries = append(entries, listOut)
			disks, infos, _ := set.getOnlineDisksWithHealingAndInfo(true)
			if len(disks) == 0 {

          Multisets.immutableEntry(samples.e4(), 2));
    }

    @Override
    public Set<Multiset.Entry<E>> create(Object... entries) {
      List<Object> contents = new ArrayList<>();
      Set<E> elements = new HashSet<>();
      for (Object o : entries) {
        @SuppressWarnings("unchecked")
        Multiset.Entry<E> entry = (Entry<E>) o;
        checkArgument(

// and number of entries that failed replication after 3 retries
type ReplicationMRFStats struct {
	LastFailedCount uint64 `json:"failedCount_last5min"`
	// Count of unreplicated entries that were dropped after MRF retry limit reached since cluster start.
	TotalDroppedCount uint64 `json:"droppedCount_since_uptime"`
	// Bytes of unreplicated entries that were dropped after MRF retry limit reached since cluster start.

	// Deleted is set when this FileInfo represents
	// a deleted marker for a versioned bucket.
	Deleted bool `msg:"del"`

	// TransitionStatus is set to Pending/Complete for transitioned
	// entries based on state of transition
	TransitionStatus string `msg:"ts"`
	// TransitionedObjName is the object name on the remote tier corresponding
	// to object (version) on the source tier.
	TransitionedObjName string `msg:"to"`

		},
	}
	creds := globalActiveCred
	token, err := authenticateNode(creds.AccessKey, creds.SecretKey)
	if err != nil {
		t.Fatal(err)
	}
	return fsDir, locker, token
}

// Test function to remove lock entries from map based on name & uid combination
func TestLockRpcServerRemoveEntry(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	testPath, locker, _ := createLockTestServer(ctx, t)

```

Let's take for example a set of 12 compute nodes with an aggregate memory of _1.2TiB_, we need to do following settings for optimal results. Add the following optimal entries for _core-site.xml_ to configure _s3a_ with **MinIO**. Most important options here are

```
cat ${HADOOP_CONF_DIR}/core-site.xml | kv-pairify | grep "mapred"