unit.completed(testDescriptor, testResult, completeEvent)

        then:
        1 * delegate.completed(testDescriptor, testResult, completeEvent)

        where:
        result << TestResult.ResultType.values().toList()
    }

        projects.forEach(p -> {
            P projectDetails = projectProjector.apply(p);
            Iterable<C> configurationDetails = configurationProjector.apply(p).collect(Collectors.toList());
            details.put(projectDetails, configurationDetails);
        });
        return new ProjectsWithConfigurations<P, C>() {
            @Override
            public Set<P> getProjects() {

                return -1;
            } else if (this.selected.getId().getModule().equals(second)) {
                return 1;
            }
            return 0;
        }).collect(Collectors.toList());
    }

    @Override
    public void withParticipatingModules(Action<? super ModuleIdentifier> action) {
        for (ModuleIdentifier module : participatingModules) {
            action.execute(module);
        }

    @Override
    void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        Map<String, String> entries = request.getHeaderNames().toList().collectEntries { headerName -> [headerName, request.getHeader(headerName as String)] }
        allHeaders.add(entries)
        String authorization = getAuthorizationHeader(request)
        if (authorization != null) {

     */
    public GroupedTransformOutputFixture transform(String transformer) {
        List<GroupedTransformOutputFixture> foundTransforms = transforms.values().stream()
            .filter(transform -> transform.getTransformer().equals(transformer))
            .collect(Collectors.toList());

        if (foundTransforms.size() == 0) {

internal
fun compactStringFor(paths: Iterable<String>, separator: Char) =
    CompactTree.of(paths.map { it.splitIncluding(separator).toList() }).toString()


private
sealed class CompactTree {

    companion object {

        fun of(paths: Iterable<List<String>>): CompactTree =
            paths
                .filter { it.isNotEmpty() }
                .groupBy({ it[0] }, { it.drop(1) })

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Mojo (goals) bindings to a lifecycle phase.
 *
 * @see LifecycleMojo
 */
public class LifecyclePhase {

    private List<LifecycleMojo> mojos;

    public LifecyclePhase() {}

            .filter(it -> classNameForRequest(it) != null)
            .collect(Collectors.groupingBy(this::classNameForRequest, LinkedHashMap::new, Collectors.toList()));

        List<HasFailures.FailureInfo> failuresInfo = new ArrayList<>();
        Set<CallInterceptionRequest> processedRequests = new LinkedHashSet<>(interceptionRequests.size());
        Map<String, Consumer<TypeSpec.Builder>> classContentByName = new LinkedHashMap<>();

        return interceptionRequests.stream()
            .filter(request -> request.getRequestExtras().getByType(RequestExtra.InterceptJvmCalls.class).isPresent())
            .collect(Collectors.toList());
    }

    @Override
    public GenerationResult generateResourceForRequests(Collection<CallInterceptionRequest> filteredRequests) {
        return new GenerationResult.CanGenerateResource() {
            @Override

    }


    private fun collectInheritancePath(
        baseSymbol: FirClassSymbol<*>,
        superSymbol: FirClassSymbol<*>,
    ): List<Pair<ConeClassLikeType, FirRegularClassSymbol>>? {
        val stack = mutableListOf<Pair<ConeClassLikeType, FirRegularClassSymbol>>()
        var result: List<Pair<ConeClassLikeType, FirRegularClassSymbol>>? = null

        fun dfs(symbol: FirClassSymbol<*>) {