.map(it -> (ExecutableElement) it)
            // Ensure that the elements have a stable order, as the annotation processing engine does not guarantee that for type elements.
            // The order in which the executable elements are listed should be the order in which they appear in the code but
            // we take an extra measure of care here and ensure the ordering between all elements.

import org.gradle.util.internal.TextUtil

import java.nio.file.Path

/**
 * The cross-platform builder of shell scripts that can be used to verify correctness of the
 * invocation of an executable. It uses "sh" syntax on POSIX platforms and batch files on Windows.
 */
abstract class ShellScript {
    protected final TestFile scriptFile

    protected ShellScript(TestFile scriptFile) {

    the region owned by the former will be outlined to a function with a
    `tfrt_ifrt_serving.program_id` attribute. After that, the runtime ensures
    that the outlined function is compiled into an executable and is available
    for lookup from `IfrtCall` TF ops.

    `variable_arg_indices` is a sorted (ascending order) array and indicates which
    element of `args` is a key to a loaded array corresponding to a variable.

    public abstract String getLinkLibraryName(String libraryPath);

    @UsedByScanPlugin
    public abstract String getFamilyName();

    /**
     * Locates the given executable in the system path. Returns null if not found.
     */
    @Nullable
    public File findInPath(String name) {
        String exeName = getExecutableName(name);
        if (exeName.contains(File.separator)) {

		{[]Checker{InPathCheck{executable: "foobarbaz", exec: exec.New()}}, true, "\t[WARNING FileExisting-foobarbaz]: foobarbaz not found in system path\n"},
		{[]Checker{InPathCheck{executable: "foobarbaz", mandatory: true, exec: exec.New()}}, false, ""},

The extra functions here are stubs to satisfy the references in the C
code generated for gcc. The build process links this stub, along with
_cgo_export.c and *.cgo2.c, into a dynamic executable and then lets
cgo examine the executable. Cgo records the list of shared library
references and resolved names and writes them into a new file
_cgo_import.go, which looks like:

	//go:cgo_dynamic_linker "/lib64/ld-linux-x86-64.so.2"

// meta-data file. Pods are intended to simplify processing of
// coverage output files in the case where we have several coverage
// output directories containing output files derived from more
// than one instrumented executable. In the case where the files that
// make up a pod are spread out across multiple directories, each
// element of the "Origins" field below will be populated with the

            problemReporter.reportProblemIfNeeded(logger, installationLocation, "Path for java installation " + installationLocation.getDisplayName() + " does not contain a java executable");
            return false;
        }
        return true;
    }

    private InstallationLocation canonicalize(InstallationLocation location) {
        final File file = location.getLocation();

			// see https://go.dev/cl/416174.
			return false
		}
		return true
	case "darwin":
		return true
	}
	return false
}

// ExecutableHasDWARF reports whether the linked executable includes DWARF
// symbols on goos/goarch.
func ExecutableHasDWARF(goos, goarch string) bool {
	switch goos {
	case "plan9", "ios":
		return false
	}
	return true
}

As seen in the output, the `build` task compiles, assembles, tests, and checks the code.

The tasks are printed in order of execution.
The `jar` tasks is a dependency of the `build` task.

The `jar` task creates an executable JAR file of the app.
Let's run it by itself:
[source,text]
----
$ ./gradlew jar
----
----
> Task :app:compileJava
> Task :app:processResources
> Task :app:classes
> Task :app:jar
----