.append("\n");

        return sb.toString();
    }

    public boolean isAsList() {
        return asList;
    }

    public MetadataResolutionRequest setAsList(boolean asList) {
        this.asList = asList;
        return this;
    }

    public boolean isAsDirtyTree() {
        return asDirtyTree;
    }

      return ImmutableSet.copyOf(elements).asList();
    }
  }

  public static class ImmutableSortedSetAsListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      Comparator<String> comparator = createExplicitComparator(elements);
      ImmutableSet<String> set = ImmutableSortedSet.copyOf(comparator, Arrays.asList(elements));
      return set.asList();
    }

    for (int i = 0; i < numStripes; i++) {
      stripes[i] = i;
    }
    List<Integer> asList = Ints.asList(stripes);
    Collections.shuffle(asList, new Random(0xdeadbeef));

    // do bulk gets with exactly 10 keys (possibly <10 stripes) (or less if numStripes is smaller)
    bulkGetSet = ImmutableList.copyOf(limit(cycle(asList), 10));
  }

  @Footprint
  Object sizeOfStriped() {
    return impl.get(numStripes);
  }

package org.gradle.process.internal;

import java.util.Arrays;

public class TestApp {
    public static void main(String[] args) {
        System.out.print("output args: " + Arrays.asList(args));
        System.err.print("error args: " + Arrays.asList(args));
    }

  }

  public final void clear() {
    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:

        return methodNameColumnExists
            ? Arrays.asList(test.getDisplayName(), test.getName(), test.getFormattedDuration(), test.getFormattedResultType())
            : Arrays.asList(test.getDisplayName(), test.getFormattedDuration(), test.getFormattedResultType());
    }

    private List<String> determineTableHeaders() {

            if (name.equals("li")) {
                unwindTo(Arrays.asList("ul", "ol"), visitor);
            } else if (name.equals("dt") || name.endsWith("dd")) {
                unwindTo(Arrays.asList("dl"), visitor);
            } else if (name.equals("tr")) {
                unwindTo(Arrays.asList("table", "thead", "tbody"), visitor);
            } else if (name.equals("th") || name.endsWith("td")) {

    List<Integer> ints = Arrays.asList(0, 1, 2);
    List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2);
    List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2);
    List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2);

    assertThat(Longs.toArray(bytes)).isEqualTo(array);
    assertThat(Longs.toArray(shorts)).isEqualTo(array);
    assertThat(Longs.toArray(ints)).isEqualTo(array);

        if (session != null) {
            repositorySystem.injectMirror(session, Arrays.asList(repository));
            repositorySystem.injectProxy(session, Arrays.asList(repository));
            repositorySystem.injectAuthentication(session, Arrays.asList(repository));
        }

        return repository;
    }

    private static RepositorySystem rs(PlexusContainer c) {

import javax.annotation.Nullable;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;

import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
import static java.util.Optional.ofNullable;
import static org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework.JUNIT;