exceptionNestingLevel << (0..2).toList()
    }

    def createBuildFileForExecutionPhaseCheck(int exceptionNestingLevel) {
        file('build.gradle') << """
class CustomException extends Exception {
    Thread thread = Thread.currentThread() // non-serializable field
    CustomException(String msg) {
        super(msg)
    }
}

task run {
    doLast {

            }

            @Override
            protected List<PerformanceReportScenario> getCrossVersionScenarios() {
                return executionDataProvider.getReportScenarios().stream().filter(PerformanceReportScenario::isCrossVersion).collect(toList());
            }

            @Override
            protected List<PerformanceReportScenario> getCrossBuildScenarios() {

        AttributeContainer requested = attribute(attr1, "v3")

        when:
        def extraAttributes = schema.collectExtraAttributes(candidates, requested).toList()

        then:
        extraAttributes.contains(attr2)
        !extraAttributes.contains(attr1)
    }

    def "collects extra attributes, two candidates"() {
        def attr1 = Attribute.of("foo", String)

    when {
      PlatformVersion.majorVersion > 11 ->
        assertThat(s.enabledProtocols.toList()).containsExactly(
          "TLSv1.3",
          "TLSv1.2",
        )
      // Not much we can guarantee on JDK 11.
      PlatformVersion.majorVersion == 11 ->
        assertThat(s.enabledProtocols.toList()).contains(
          "TLSv1.2",
        )
      // JDK 8 291 removed older versions

        Collection<Project> children,
        List<IsolatedGradleProjectInternal> isolatedChildrenModels
    ) {
        return Streams.zip(children.stream(), isolatedChildrenModels.stream(), (c, ic) -> build(rootProject, (ProjectInternal) c, ic, parameter))
            .map(it -> it.setParent(parent))
            .collect(toList());
    }

        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))
                .collect(Collectors.toList()));
    }

    @Override
    protected void mergeDependency_Exclusions(
            Dependency.Builder builder,
            Dependency target,
            Dependency source,
            boolean sourceDominant,

                })
                .map(Method::getName)
                .collect(Collectors.toList());

        List<String> overriddenMethods = Stream.of(FileToRawModelMerger.class.getDeclaredMethods())
                .map(Method::getName)
                .filter(m -> m.startsWith("merge"))
                .collect(Collectors.toList());

        assertThat(overriddenMethods, hasItems(methodNames.toArray(new String[0])));
    }

        ['name/some', 'name2/other'],
        ['name', 'name1/some', 'name2/other/third'],
        ['aa/b1', 'ab/a1', 'name', 'name1/some', 'name2/other/third'],
        ("a".."z").toList(),
        ("a".."z").collect { "$it/$it".toString() }.toList(),
    ]

    /**
     * The queried/updated path has no common prefix with any of the initial children of the node under test.
     *
     * E.g.
     *   path: 'name0/some

        static class B extends RuleSource {}

        static class A extends RuleSource {}
    }

    def "find model rule sources - #clazz"() {
        expect:
        detector.getDeclaredSources(clazz).toList() == expected

        where:
        clazz         | expected
        String        | []
        HasOneSource  | [HasOneSource.Source]
        HasTwoSources | [HasTwoSources.SourceOne, HasTwoSources.SourceTwo]

import org.gradle.internal.SystemProperties
import org.gradle.internal.logging.text.TestStyledTextOutputFactory
import org.gradle.util.Path
import spock.lang.Specification

import static org.gradle.util.internal.WrapUtil.toList

class DryRunBuildExecutionActionTest extends Specification {
    private static final String EOL = SystemProperties.instance.lineSeparator
    def delegate = Mock(BuildWorkExecutor)