The install is organized in 'environments' - each environment consists of a set of components
in different namespaces that are configured to work together. Regardless of 'environment',
workloads can talk with each other and obey the Istio configuration resources, but each environment
can use different Istio versions and different configuration defaults.

/**< Sets the message handler to call before each suite is run. */
CU_EXPORT void CU_set_test_start_handler(CU_TestStartMessageHandler pTestStartMessage);
/**< Sets the message handler to call before each test is run. */
CU_EXPORT void CU_set_test_complete_handler(CU_TestCompleteMessageHandler pTestCompleteMessage);
/**< Sets the message handler to call after each test is run. */

        def variantVersion = context.details.id.version
        def version = variantVersion.substring(0, variantVersion.indexOf("-"))
        ["compile", "runtime"].each { base ->
            [6: "android", 8: "jre"].each { targetJvmVersion, jarName ->
                context.details.addVariant("jdk$targetJvmVersion${base.capitalize()}", base) {
                    attributes {

            settingsFile << """
                rootProject.name = '$rootProjectName'
            """
            includes.each { pName ->
                settingsFile << """
                include '$pName'
            """
            }
            includeBuilds.each { pName ->
                settingsFile << """
                includeBuild '$pName'
            """
            }
        }
    }

        given:
        def inputFiles = (1..changesCount).collect { inputDir.file("input${it}.txt") }
        inputFiles.each { it.createFile() }
        boolean expectMoreChanges = (changesCount > changesLimit)

        when:
        succeeds("theTask")
        inputFiles.each { it.delete() }

        then:
        buildTriggeredAndSucceeded()
        sendEOT()

 * - Adds a {@link BinarySpec} container named {@code binaries} to the project.
 * - Registers the base {@link BinarySpec} type.
 * - For each {@link BinarySpec}, registers a lifecycle task to assemble that binary.
 * - For each {@link BinarySpec}, adds the binary's source sets as its default inputs.
 * - Links the tasks for each {@link BinarySpec} across to the tasks container.
 */
@Incubating
public abstract class BinaryBasePlugin implements Plugin<Project> {

            configuration.getDependencies().each { Dependency d ->
                reply.append("\n   ").append(d)
            }
        } else {
            reply.append("\n   none")
        }

        reply.append("\nLocal Artifacts:")
        if (configuration.getArtifacts().size() > 0) {
            configuration.getArtifacts().each { PublishArtifact a ->
                reply.append("\n   ").append(a)

    
```

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.
Most source code targets the daemon and the remaining code either targets a single runtime, for example the Gradle client, or is shared across multiple runtimes.

## Composition by architecture modules

// fully-built model.
//
// Implementation steps:
//
//   1) For each function def in the SavedModel, register it with the runtime.
//   2) For each object in the object graph def, build it.
//   3) For each variable stored in the checkpoint in the SavedModel,
//      restore it, and attach it to the associated variable object.
//   4) For each polymorphic function, associate it with the appropriate
//      concrete function(s).

     * @return this
     */
    ContentFilterable filter(Transformer<@org.jetbrains.annotations.Nullable String, String> transformer);

    /**
     * <p>Expands property references in each file as it is copied. More specifically, each file is transformed using
     * Groovy's {@link groovy.text.SimpleTemplateEngine}. This means you can use simple property references, such as