List<StackTraceElement> stack = failure.getStackTrace();
        int startPos;
        int endPos;
        if (fromException) {
            // When analysing an exception stack trace, consider all the user code in the stack.
            // This is because we cannot tell the difference between:
            // - a validation exception thrown in user code that is called from other user code, where the caller should be blamed

        assert output.contains("buildScan.unsupportedMessage: $unsupported")
    }

    BuildScanConfig.Attributes attributes(String output) {
        def all = allAttributes(output)
        all.empty ? null : all.first()
    }

    List<BuildScanConfig.Attributes> allAttributes(String output) {
        output.findAll("buildScan\\.attributes: \\{(.+)\\}\\\n") {
            it[1]
        }.collect {

}

plugins.withType<GroovyBasePlugin> {
    the<SourceSetContainer>().all {
        tasks.register<Checkstyle>(getTaskName("checkstyle", "groovy")) {
            config = configFile("checkstyle-groovy.xml")
            source(allGroovy)
            classpath = compileClasspath
            reports.xml.outputLocation = checkstyle.reportsDir.resolve("${this@all.name}-groovy.xml")
        }
    }
}

codenarc {

import javax.tools.Diagnostic
import javax.tools.JavaFileObject

class DiagnosticToProblemListenerTest extends Specification {

    def spec = Mock(InternalProblemSpec) {
        // We report the formatted message in all cases
        1 * additionalData(org.gradle.api.problems.internal.GeneralDataSpec, _)
    }

    def diagnosticToProblemListener = new DiagnosticToProblemListener(null, null)

    }

    @Override
    public Spec<Task> getFilter(SelectionContext context, ProjectState project, String taskName, boolean includeSubprojects) {
        if (includeSubprojects) {
            // Try to delay configuring all the subprojects
            configurer.configure(project.getMutableModel());
            if (taskNameResolver.tryFindUnqualifiedTaskCheaply(taskName, project.getMutableModel())) {

package org.gradle.integtests.tooling.fixture

import org.gradle.util.GradleVersion
import spock.lang.Specification

class GradleVersionSpecTest extends Specification {
    def "greater-than-or-equal version constraint matches all versions with specified base version and later"() {
        def spec = new GradleVersionSpec().toSpec(">=1.0")

        expect:
        spec.isSatisfiedBy(GradleVersion.version("1.0"))

    }

    public ProviderInternal<? extends T> getProvider() {
        // TODO(mlopatkin) while calling getProvider is not going to cause StackOverflowError by itself, the returned provider is typically used in some recursive call.
        //  Without the safety net of the EvaluationContext, it can cause hard-to-debug exceptions.
        try (EvaluationContext.ScopeContext context = openScope()) {
            return getSupplier(context);
        }

        delegate.setLocale(locale);
    }

    @Override
    public Boolean call() {
        if (called) {
            throw new IllegalStateException("Cannot reuse a compilation task");
        }
        called = true;
        try {
            setupProcessors();
            return delegate.call();
        } finally {
            cleanupProcessors();
        }
    }

        daemon --> worker

        worker2["Worker process"]
        daemon --> worker2

        worker3["Worker process"]
        daemon --> worker3
    
```

These are all Java processes. Each process has a corresponding "runtime".
All source code in Gradle is written to target one or more of these runtimes.

        bind(type.java, serializer)

    fun bind(type: Class<*>, serializer: Serializer<*>) =
        bind(type, SerializerCodec(serializer))

    fun bind(type: Class<*>, codec: Codec<*>) {
        require(bindings.all { it.encodingForType(type) == null }) {
            "There's already an encoding for type '$type'"
        }
        val codecForAny = codec.uncheckedCast<Codec<Any>>()