buildTimeout *= 100
    }

    def cleanup() {
        stopGradle()
        if (OperatingSystem.current().isWindows()) {
            // needs delay to release file handles
            sleep(500L)
        }
    }

    def setup() {
        Assume.assumeFalse("Continuous build doesn't work with --no-daemon", GradleContextualExecuter.noDaemon)
        executer.beforeExecute {

    // CHECK: [[handle:%.*]] = "foo.bar"
    %2 = "foo.bar"(%0) : (tensor<!tf_type.resource<tensor<10xf32>>>) -> tensor<!tf_type.resource<tensor<10xf32>>>
    // CHECK-NOT: AssignVariableOp
    // CHECK: "tf.AssignVariableOp"([[handle]]
    "tf.AssignVariableOp"(%2, %1) : (tensor<!tf_type.resource<tensor<10xf32>>>, tensor<10xf32>) -> ()
    return
  }

	case "windows":
		return []string{"SystemRoot", "COMSPEC", "PATHEXT", "WINDIR"}
	}
	return nil
}()

// Handler runs an executable in a subprocess with a CGI environment.
type Handler struct {
	Path string // path to the CGI executable
	Root string // root URI prefix of handler or empty for "/"

	// Dir specifies the CGI executable's working directory.
	// If Dir is empty, the base directory of Path is used.

In most cases, the same tool that is used to **run the program on startup** is also used to handle automatic **restarts**.

For example, this could be handled by:

* Docker
* Kubernetes
* Docker Compose
* Docker in Swarm Mode
* Systemd
* Supervisor
* Handled internally by a cloud provider as part of their services
* Others...

## Replication - Processes and Memory

	// If there is any error, processing gets aborted.
	// We could try to continue, but that would make the code more complex.
	for pluginName, claims := range batches {
		// Call NodePrepareResources RPC for all resource handles.
		client, err := dra.NewDRAPluginClient(pluginName)
		if err != nil {
			return fmt.Errorf("failed to get DRA Plugin client for plugin name %s: %v", pluginName, err)
		}

// NewRequestInfo returns the information from the http request.  If error is not nil, RequestInfo holds the information as best it is known before the failure
// It handles both resource and non-resource requests and fills in all the pertinent information for each.
// Valid Inputs:
// Resource paths
// /apis/{api-group}/{version}/namespaces
// /api/{version}/namespaces

                }
            }
        """

        when:
        moduleA.ivy.expectDownload()
        moduleA.jar.expectDownload()

        // Handles missing in repo1
        missingModuleB.ivy.expectDownloadMissing()

        moduleB.ivy.expectDownload()
        moduleB.jar.expectDownload()


        then:
        succeeds('listJars')

                doLast {
                    println 'do something'
                }
            }
        """

        expect:
        succeeds(":third-build:sub:doSomething")
    }

    def "handles overlapping names between composite and a subproject within the composite"() {
        setup:
        settingsFile << """
            rootProject.name = 'root-project'
            includeBuild('lib')
        """

        checkCompile recompiled: [], removed: [source2]

        when:
        sourceAdded(source2, [])

        then:
        checkCompile recompiled: [source2], removed: []
    }

    def "handles source file that is also a dependency"() {
        given:
        initialFiles()

        when:
        modified(dep2, [source2])

        then:
        checkCompile recompiled: [source1], removed: []

     * @param number the total number of diagnostics of the given kind
     */
    private static void printDiagnosticCount(Log logger, String kind, int number) {
        // Compiler only handles 'error' and 'warn' kinds
        if (!("error".equals(kind) || "warn".equals(kind))) {
            throw new IllegalArgumentException("kind must be either 'error' or 'warn'");
        }