recessive.setSourceLevel(recessiveSourceLevel);

        shallowMerge(dominant.getToolchains(), recessive.getToolchains(), recessiveSourceLevel);
    }

    private void shallowMerge(
            List<ToolchainModel> dominant, List<ToolchainModel> recessive, String recessiveSourceLevel) {
        Map<Object, ToolchainModel> merged = new LinkedHashMap<>();

        for (ToolchainModel dominantModel : dominant) {

 * Side Public License, v 1.
 */

package org.elasticsearch.gradle.internal.util.ports;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReservedPortRange {
    private final int startPort;

    throw new UnsupportedOperationException();
  }

  private transient @Nullable ImmutableList<E> asList;

  public ImmutableList<E> asList() {
    ImmutableList<E> list = asList;
    return (list == null) ? (asList = createAsList()) : list;
  }

  ImmutableList<E> createAsList() {
    switch (size()) {
      case 0:
        return ImmutableList.of();
      case 1:

	// User account credentials
	minioUsername string
	minioPassword string

	// Display credentials flag
	displayCreds bool

	// Credential expiry duration
	expiryDuration time.Duration

	// Bucket to list
	bucketToList string

	// Session policy file (FIXME: add support in minio-go)
	sessionPolicyFile string
)

func init() {
	flag.StringVar(&stsEndpoint, "sts-ep", "http://localhost:9000", "STS endpoint")

}

type targetsList struct {
	list []Target
	mu   sync.RWMutex
}

func newTargetsList() *targetsList {
	return &targetsList{}
}

func (tl *targetsList) get() []Target {
	tl.mu.RLock()
	defer tl.mu.RUnlock()

	return tl.list
}

func (tl *targetsList) add(t Target) {
	tl.mu.Lock()
	defer tl.mu.Unlock()

	tl.list = append(tl.list, t)
}

    SampleElements<E> samples = samples();
    List<E> allSampleElements =
        asList(samples.e0(), samples.e1(), samples.e2(), samples.e3(), samples.e4());
    return new ArrayList<>(allSampleElements.subList(0, howMany));
  }

  @Override
  public CollectionSize getCollectionSize() {
    return collectionSize;
  }

  @Override
  public Iterable<E> order(List<E> insertionOrder) {

     * prefixes and setting whether the {@link PrefixedValueSourceWrapper} allows
     * unprefixed expressions.
     * @param possiblePrefixes The possible prefixes.
     * @param root The root of the graph.
     * @param allowUnprefixedExpressions if we allow undefined expressions or not.
     */

        protected void mergeDependency_Exclusions(
                Dependency target, Dependency source, boolean sourceDominant, Map<Object, Object> context) {
            List<Exclusion> tgt = target.getExclusions();
            if (tgt.isEmpty()) {
                List<Exclusion> src = source.getExclusions();

                for (Exclusion element : src) {
                    Exclusion clone = element.clone();

 *
 * <p>For example, to test {@link java.util.Collections#unmodifiableList(java.util.List)
 * Collections.unmodifiableList}'s iterator:
 *
 * {@snippet :
 * List<String> expectedElements = Arrays.asList("a", "b", "c", "d", "e");
 * List<String> actualElements =
 *     Collections.unmodifiableList(Arrays.asList("a", "b", "c", "d", "e"));
 * IteratorTester<String> iteratorTester =

    private String extractDescription(PlexusConfiguration c) {
        return c.getChild("description").getValue();
    }

    private List<MojoDescriptor> extractMojos(PlexusConfiguration c, PluginDescriptor pluginDescriptor)
            throws PlexusConfigurationException {
        List<MojoDescriptor> mojos = new ArrayList<>();

        PlexusConfiguration[] mojoConfigurations = c.getChild("mojos").getChildren("mojo");