// new file for each pass. The file name will have the format
// {file_name_prefix}_{pass_number}_{pass_name}_{before|after}.mlir.
// * `file_name_prefix` is from input.
// * `pass_number` increments from 1 for each pass.
// * `pass_name` is the name of the pass.
// * `before|after` indicates whether the dump occurs before or after the pass.
absl::Status MaybeEnableIrPrinting(mlir::PassManager &pm,

package report

import "regexp"

// pkgRE extracts package name, It looks for the first "." or "::" that occurs
// after the last "/". (Searching after the last / allows us to correctly handle
// names that look like "some.url.com/foo.bar".)
var pkgRE = regexp.MustCompile(`^((.*/)?[\w\d_]+)(\.|::)([^/]*)$`)

// packageName returns the package name of the named symbol, or "" if not found.
func packageName(name string) string {

            logger.info("Processing request. Number of temp files: " + countTmpFiles());
        }, e -> {});
        long after = countTmpFiles();
        logger.info("After close response. Number of temp files: " + after);

        // ## Assert ##
        assertEquals(before, after);
    }

    private long countTmpFiles() {

    public void afterSessionStart(MavenSession session) throws MavenExecutionException {
        // do nothing
    }

    /**
     * Invoked after all projects were built.
     *
     * This callback is intended to allow extensions to perform cleanup of any
     * allocated external resources after the build. It is invoked on best-effort
     * basis and may be missed due to an Error or RuntimeException in Maven core
     * code.
     *

        fails("mutateAfterResolve")

        then:
        failure.assertHasCause "Cannot change attributes of configuration ':compile' after it has been locked for mutation"
    }

    @ToBeFixedForConfigurationCache(because = "Task uses the Configuration API")
    def "cannot add outgoing variants after configuration is resolved"() {
        given:
        buildFile << """

        configurations {
            compile {

	}

	s = append(s, toInsert) // for grow the cap
	copy(s[idx+1:], s[idx:])
	s[idx] = toInsert

	return s, true
}

// insertAfterFunc find and insert an element after the found element.
// If the f function returns true, the returned value will be inserted after the found element.
func insertAfterFunc[E any](s []E, f func(e E) (bool, E)) ([]E, bool) {
	var toInsert E
	idx := -1
	for k, v := range s {
		if ok, r := f(v); ok {

func (info *ClaimInfo) setCDIDevices(pluginName string, cdiDevices []string) error {
	// NOTE: Passing CDI device names as annotations is a temporary solution
	// It will be removed after all runtimes are updated
	// to get CDI device names from the ContainerConfig.CDIDevices field
	annotations, err := cdi.GenerateAnnotations(info.ClaimUID, info.DriverName, cdiDevices)
	if err != nil {

// tag::after-evaluate[]
gradle.beforeProject {
    // Set a default value
    project.ext.set("hasTests", false)
}

gradle.afterProject {
    if (project.ext.has("hasTests") && project.ext.get("hasTests") as Boolean) {
        val projectString = project.toString()
        println("Adding test task to $projectString")
        tasks.register("test") {
            doLast {
                println("Running tests for $projectString")
            }

import org.gradle.internal.service.scopes.StatefulListener;

@EventScope(Scope.BuildTree.class)
@StatefulListener
public interface BuildTreeLifecycleListener {
    /**
     * Called after the build tree has been created, just after the services have been created.
     *
     * This method is called before the root build operation has started, so implementations should not perform any expensive work
     * and should not run any user code.

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.

Because this code is executed before the application **starts** taking requests, and right after it **finishes** handling requests, it covers the whole application **lifespan** (the word "lifespan" will be important in a second 😉).