// ProcessBuilder.start()
        fromStringArray() | "new ProcessBuilder(command).start()"                                                             | ""                | ""
        fromStringList()  | "new ProcessBuilder(command).start()"                                                             | ""                | ""

does not really make any difference to the coverage
""")
    def "runs tasks in different projects in parallel by default"() {
        server.start()

        given:
        createDirs("a", "b", "c")
        settingsFile << """
            include 'a', 'b', 'c'
        """
        buildFile << """
            class SlowTask extends DefaultTask {

        when:
        start {
            server.addIncoming(serverService)
            server.setupOutgoingService1()
            server.setupOutgoingService2()
            server.connection.connect()
            server.outgoingService1.doStuff("from server 1")
            server.outgoingService1.doStuff("from server 2")
        }
        start {
            client.addIncoming(clientService)

			}
			if !stringslite.HasPrefix(name, "tiu") {
				t.Errorf("tiuTest+%#x: unexpected function %s", pc-pc1, name)
			}

			start := int(sf.startLine) - tiuStart
			if start != wantStart[name] {
				t.Errorf("tiuTest+%#x: want startLine %d, got %d", pc-pc1, wantStart[name], start)
			}
			if sf.funcID != abi.FuncIDNormal {
				t.Errorf("tiuTest+%#x: bad funcID %v", pc-pc1, sf.funcID)
			}

			if len(stack) > 0 {

=== Faster CI builds

CI builds benefit particularly from the build cache.
A typical CI build starts with a `clean`, which means that pre-existing build outputs are deleted and none of the tasks that make up the build will be `UP-TO-DATE`.

    }

    def "locks cache upon JAR creation"() {
        given:
        def startSecondInvocation = new CountDownLatch(1)
        def jarFile1
        def jarFile2

        when:
        concurrent.start {
            jarFile1 = defaultGeneratedGradleJarCache.get(CACHE_IDENTIFIER, new Action<File>() {
                @Override
                void execute(File file) {
                    startSecondInvocation.countDown()

}

func (*objTool) Open(name string, start, limit, offset uint64, relocationSymbol string) (driver.ObjFile, error) {
	of, err := objfile.Open(name)
	if err != nil {
		return nil, err
	}
	f := &file{
		name: name,
		file: of,
	}
	if start != 0 {
		if load, err := of.LoadAddress(); err == nil {
			f.offset = start - load
		}
	}
	return f, nil
}

	}
}

func parseARM64SVERegister(zfr0 uint64) {
	switch extractBits(zfr0, 0, 3) {
	case 1:
		ARM64.HasSVE2 = true
	}
}

func extractBits(data uint64, start, end uint) uint {
	return (uint)(data>>start) & ((1 << (end - start + 1)) - 1)

        server.start()
    }

    @Issue("https://issues.gradle.org/browse/GRADLE-2699")
    def "concurrent downloads do not stomp over each other"() {
        given:
        prepareWrapper(server.uri("gradle-bin.zip"))

        when:
        def results = [1..4].collect { wrapperExecuter.start() }*.waitForFinish()

        then:

          # Setup a script to start istio but exit the container if it exits. This more closely mirrors Pods.
          # This is not strictly needed, but it makes our CI properly report crashes (including core dumps)
          cat <<'EOF'>/tmp/start.sh
          #!/bin/bash
          /usr/local/bin/istio-start.sh
          kill "$1"
          EOF
          chmod +x /tmp/start.sh