if (problems.isEmpty()) {
            getLogger().info("Plugin validation finished without warnings.");
        } else {
            if (getFailOnWarning().get() || problems.stream().anyMatch(problem -> problem.getDefinition().getSeverity() == ERROR)) {
                if (getIgnoreFailures().get()) {
                    getLogger().warn("Plugin validation finished with errors. {} {}",
                        annotateTaskPropertiesDoc(),

     */
    ModelTransformerContext initialize(ModelBuilderRequest request, ModelProblemCollector problems);

    /**
     * The immutable transformerContext, can be used after the buildplan is finished.
     *
     * @return the immutable transformerContext
     */
    ModelTransformerContext build();

  optional JobTemplateSpec jobTemplate = 5;

  // The number of successful finished jobs to retain.
  // This is a pointer to distinguish between explicit zero and not specified.
  // Defaults to 3.
  // +optional
  optional int32 successfulJobsHistoryLimit = 6;

  // The number of failed finished jobs to retain.
  // This is a pointer to distinguish between explicit zero and not specified.

        withSomeToolingModelBuilderPluginInBuildSrc()
        settingsFile << ""
        buildFile << """
            plugins.apply(my.MyPlugin)
            gradle.buildFinished {
                println("build finished")
            }
        """

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModelFails()

        then:
        fixture.assertStateStoredAndDiscarded {

    def "intermediate model is cached and reused for nested concurrent requests"() {
        // Sleep to ensure concurrent requests for the same model catch up before the first one is finished
        withSomeToolingModelBuilderPluginInBuildSrc("""
            Thread.sleep(3000)
        """)

        settingsFile << """
            rootProject.name = "root"
        """

        buildFile << """

import java.util.Map;
import java.util.function.Consumer;

@ServiceScope(Scope.Global.class)
public interface CacheFactory {
    /**
     * Opens a cache with the given options. The caller must close the cache when finished with it.
     */

            collectOutputs(build)
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()
            sync.releaseAll()
            resultHandler.finished()
        }

        then:
        configureWasCancelled(resultHandler, "Could not run phased build action using")
    }

        then:
        def e = thrown(IllegalStateException)
        e.message == "No work graph available for this thread."
    }

    def "cannot schedule tasks when after graph has finished execution"() {
        when:
        graph.withNewWorkGraph { 12 }
        graph.locateTask(taskIdentifier(DefaultBuildIdentifier.ROOT, ":task")).queueForExecution()

        then:

}

func (g *goroutineGenerator) Finish(ctx *traceContext) {
	ctx.SetResourceType("G")

	// Finish off global ranges.
	g.globalRangeGenerator.Finish(ctx)

	// Finish off all the goroutine slices.
	for id, gs := range g.gStates {
		gs.finish(ctx)

		// Tell the emitter about the goroutines we want to render.
		ctx.Resource(uint64(id), gs.name())

    SnapshotHierarchy updateVfsOnBuildStarted(SnapshotHierarchy root, WatchMode watchMode, List<File> unsupportedFileSystems);

    /**
     * Remove everything from the root which can't be kept after the current build finished.
     *
     * @see FileWatcherRegistry#updateVfsBeforeBuildFinished(SnapshotHierarchy, int, List)
     */
    @CheckReturnValue