tasks.all.logger.lifecycle("build finished from \${tasks.all.path}")
                }
            }

            threaded {
                println("threaded configuration output")
            }

            def threaded(Closure action) {
                Thread.start(action).join()
            }
        """

        when:
        succeeds("all")

        then:

    private transient MarkupBuilder suiteXmlBuilder;

    private final Cached<String> cachedSuiteXml = Cached.of(new Callable<String>() {
        @Override
        public String call() {
            return suiteXmlWriter != null ? suiteXmlWriter.toString() : null;
        }
    });

    private final File projectDir;

    @Inject
    public TestNGOptions(ProjectLayout projectLayout) {

                result -> result.fold(
                    file -> left(Convert.fileToURL(file)),
                    transform -> right(() -> Convert.fileToURL(transform.call()))
                )
            );
        }
        return Optional.of(left(original));
    }

    private Optional<Either<File, Callable<File>>> cachedFile(
        File original,

        new GroovyShell().parse(code)
    }

    static Object call(String text, Object... params) {
        toClosure(text).call(*params)
    }

    static Closure toClosure(String text) {
        return new GroovyShell().evaluate("return " + text)
    }

    static Closure toClosure(TestClosure closure) {
        return { param -> closure.call(param) }
    }

    static Closure returns(Object value) {

public interface ManagedExecutor extends AsyncStoppable, ExecutorService {
    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed.
     */
    @Override
    void stop();

    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed. Once the given
     * timeout has been reached, forcefully stops remaining jobs and throws an exception.

        try {
            oos.writeObject(message);
        } finally {
            oos.flush();
        }
    }

    /**
     * Read back an object from the provided stream that has been serialized by a call to {@link #send(Object, java.io.OutputStream)}. Any {@link Throwable} that cannot be de-serialized (for whatever
     * reason) will be replaced by a {@link PlaceholderException}.
     *

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marks a type or a whole package as providing a non-null API by default.
 *
 * All parameter and return types are assumed to be {@link Nonnull} unless specifically marked as {@link Nullable}.
 *
 * All types of an annotated package inherit the package rule.
 * Subpackages do not inherit nullability rules and must be annotated.
 *
 * @since 4.2
 */

This image reveals that the repository contains a version of `com.google.guava:guava` with a moderate vulnerability.

image::ci-systems/github-actions-dependency-graph.png[View dependency graph]

=== Viewing all dependency alerts

You can view a list of all vulnerabilities by navigating to `Security -> Dependabot`.

        configurationCacheRun(":a:thing")

        then:
        with(fixture.all(LoadBuildBuildOperationType)) {
            size() == 2
            with(get(0)) {
                details.buildPath == ':'
            }
            with(get(1)) {
                details.buildPath == ':buildSrc'
            }
        }
        with(fixture.all(LoadProjectsBuildOperationType)) {
            size() == 2

import java.util.regex.Pattern;

import static org.gradle.util.internal.GroovyDependencyUtil.groovyModuleDependency;

public class GroovyJarFile {
    private static final Pattern FILE_NAME_PATTERN = Pattern.compile("(groovy(?:-all)?)-(\\d.*?)(-indy)?.jar");

    private final File file;
    private final Matcher matcher;

    private GroovyJarFile(File file, Matcher matcher) {
        this.file = file;
        this.matcher = matcher;
    }