private fun mainFiles(): List<File> {
  val directories =
    listOf(
      "$prefix/samples/guide/src/main/java/okhttp3/guide",
      "$prefix/samples/guide/src/main/java/okhttp3/recipes",
      "$prefix/samples/guide/src/main/java/okhttp3/recipes/kt",
    ).map { File(it) }

  return directories.flatMap {
    it.listFiles().orEmpty().filter { f -> f.isFile }.toList()
  }
}

        def typesArray = types.collect { new CachedClass(it, null) } as CachedClass[]
        def argsArray = args as Object[]

        expect:
        transformer.transform(typesArray, argsArray).toList() == transformed

        where:
        types              | args           | transformed           | desc
        [TestEnum]         | ["abc"]        | [TestEnum.ABC]        | "one arg"

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class DefaultArtifactSelectionDetails implements ArtifactSelectionDetailsInternal {

    private final DefaultDependencySubstitution owner;
    private final List<DependencyArtifactSelector> requestedSelectors;
    private List<DependencyArtifactSelector> targetSelectors;

        }

        void assertHasModules(String... name) {
            List<String> modules = name.toList()
            assert this.modules.every { modules.contains(it) }
        }
    }

    }

    fun collectSideEffects(): List<BlockAddress> = entries.toList()

    fun write(sideEffect: BuildTreeModelSideEffect) {
        val blockAddress = valuesStore.write(sideEffect)
        entries += blockAddress
    }

    fun restoreFromCacheEntry(sideEffects: List<BlockAddress>): List<BuildTreeModelSideEffect> {
        return sideEffects.map {
            valuesStore.read(it)

     * Returns any additional JVM arguments for the compiler process.
     * Defaults to the empty list.
     */
    @Nullable
    @Optional
    @Input
    public List<String> getJvmArgs() {
        return jvmArgs;
    }

    /**
     * Sets any additional JVM arguments for the compiler process.
     * Defaults to the empty list. Empty or null arguments are filtered out because they cause
     * JVM Launch to fail.
     */

            arguments,
            experimentSpec.getBuildMutators().stream()
                .map(mutatorFunction -> mutatorFunction.apply(invocationSettings))
                .collect(Collectors.toList()),
            invocationSettings.getWarmUpCount(),
            invocationSettings.getBuildCount(),
            invocationSettings.getOutputDir(),
            experimentSpec.getInvocation().getInstallation().getHome()

            } else if (CommitDistribution.isCommitDistribution(toolingApiVersion)) {
                File toolingApiJar = CommitDistribution.getToolingApiJar(toolingApiVersion)
                List<File> slf4j = resolveDependency("org.slf4j:slf4j-api:1.7.25").toList()
                distributions[toolingApiVersion] = new ExternalToolingApiDistribution(toolingApiVersion, slf4j + toolingApiJar)
            } else {

    @SuppressWarnings({"unchecked"}) // TODO: Change this signature once we can break compatibility
    public Object configure(List<?> newEntries) {
        List<SourceFolder> newSourceFolders = newEntries.stream()
            .filter(SourceFolder.class::isInstance)
            .map(SourceFolder.class::cast)
            .collect(toList());

        Set<ClasspathEntry> updatedEntries = entries.stream()

        namedOne.get().value == "original"
        namedTwo.present
        namedTwo.get().value == "changed"
    }

    def containerHas(def container, String... names) {
        assert container.toList().collect {it.name} == names as List
        true
    }

    Type type(def name) {
        Stub(Type) {
            getName() >> name
        }
    }

    SubType subtype(def name) {
        Stub(SubType) {