operationParamsBuilder.setTasks(tasks != null ? Arrays.asList(tasks) : null);
        return getThis();
    }

    @Override
    public BuildActionExecuter<Void> forTasks(Iterable<String> tasks) {
        operationParamsBuilder.setTasks(tasks != null ? CollectionUtils.toList(tasks) : null);
        return getThis();
    }

    @Override

            throw new IllegalArgumentException(name + " is not an instance of " + clazz.getName());
        }
        return clazz.cast(o);
    }

    static <U, V> List<V> map(Collection<U> list, Function<U, V> mapper) {
        return list.stream().map(mapper).collect(Collectors.toList());
    }

        "remote"      | fs("/dev/remote", "/mnt/unsupported", "ext4", true)
    }

    private List<FileSystemInfo> detect() {
        detector.detectUnsupportedFileSystems()
            .collect(Collectors.toList())
    }

    private static FileSystemInfo fs(String deviceName, String mountPoint, String type, boolean remote = false) {

import org.gradle.util.internal.VersionNumber;

import javax.annotation.Nullable;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;
import static java.util.stream.StreamSupport.stream;
import static org.gradle.util.internal.GroovyDependencyUtil.groovyModuleDependency;

                if (substitutor != null) {
                    val functions = superClassSymbol.getDeclaredMemberScope().getAllSymbols()
                        .filterIsInstance<KaFunctionSymbol>()
                        .toList()
                    if (functions.isNotEmpty()) {
                        appendLine("Substituted callables:")
                        withIndent {
                            for (function in functions) {

        return asJson(new ApiResult.ApiConfigsResponse<ListBody>()
                .settings(Stream.of(dictFiles).map(this::createListBody).collect(Collectors.toList())).status(ApiResult.Status.OK)
                .result());
    }

    protected ListBody createListBody(final DictionaryFile<? extends DictionaryItem> dictionaryFile) {
        final ListBody body = new ListBody();

        result.assertTasksExecuted(":$spec.copyTask")
        excludedByBuildScriptFileCopy.exists()

        where:
        scriptLanguage << DefaultExcludesFixture.ScriptLanguage.values().toList()
    }

            .filter(request -> request.getRequestExtras().getByType(RequestExtra.InterceptGroovyCalls.class).isPresent())
            .collect(Collectors.toList());
    }

    @Override
    public GenerationResult generateResourceForRequests(Collection<CallInterceptionRequest> filteredRequests) {
        List<String> callInterceptorTypes = new ArrayList<>();
        CallInterceptorSpecs specs = GroovyClassGeneratorUtils.groupRequests(filteredRequests);

            // need a loop because IBM JDK is much more proactive in cleaning weak references
            constructor = cache.get(clazz, [] as Class[]).method
        }
        def constructors = clazz.getConstructors().toList()

        expect:
        constructor == constructors.find { it.parameterTypes.length == 0 }
        cache.size() == expectedCacheSize

        where:
        clazz              | expectedCacheSize

            }
        }
        return visitor.leave(this);
    }

    @Override
    public Node filter(Predicate<Node> filter) {
        List<Node> children =
                getChildren().stream().filter(filter).map(n -> n.filter(filter)).collect(Collectors.toList());
        return new WrapperNode(this, Collections.unmodifiableList(children));
    }

    @Override
    public String asString() {