}

    @Requires(value = IntegTestPreconditions.NotParallelExecutor, reason = """
Don't run in parallel mode, as the expectation for the setup build are incorrect
It could potentially be worth running this in parallel mode to demonstrate the difference between
parallel and configuration cache
""")
    def "runs tasks in same project in parallel by default"() {
        server.start()

        given:
        buildFile << """

            includeGroups == source.includeGroups
            excludeGroups == source.excludeGroups
            configFailurePolicy == source.configFailurePolicy
            listeners == source.listeners
            parallel == source.parallel
            threadCount == source.threadCount
            suiteThreadPoolSize.get() == source.suiteThreadPoolSize.get()
            useDefaultListeners == source.useDefaultListeners

//go:build unix

package os_test

import (
	"errors"
	"internal/testenv"
	"math"
	. "os"
	"runtime"
	"syscall"
	"testing"
)

func TestErrProcessDone(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	p, err := StartProcess(testenv.GoToolPath(t), []string{"go"}, &ProcAttr{})
	if err != nil {
		t.Fatalf("starting test process: %v", err)
	}
	p.Wait()
	if got := p.Signal(Kill); got != ErrProcessDone {

import org.gradle.test.fixtures.file.TestFile

class IsolatedProjectsJavaPluginIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {

    def "java projects can be configured in a parallel"() {
        given:
        withSomeToolingModelBuilderPluginInBuildSrc()
        settingsFile << """
            include("a")
            include("b")
        """
        javaProject(file("a"))

# Reduce Xmx after https://github.com/gradle/gradle-private/issues/4168 is resolved
org.gradle.jvmargs=-Xmx2700m -XX:MaxMetaspaceSize=768m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.configuration-cache=true
systemProp.gradle.publish.skip.namespace.check=true
# Kotlin DSL settings
org.gradle.kotlin.dsl.allWarningsAsErrors=true
# Kotlin settings
kotlin.incremental.useClasspathSnapshot=true

package os_test

import (
	"errors"
	"internal/testenv"
	"os"
	"syscall"
	"testing"
)

func TestFindProcessViaPidfd(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	if err := os.CheckPidfdOnce(); err != nil {
		// Non-pidfd code paths tested in exec_unix_test.go.
		t.Skipf("skipping: pidfd not available: %v", err)
	}

	select {
	case <-time.After(1 * time.Second):
		t.Error("timeout waiting for signal")
	case <-c:
		// Good
	}
}

func TestProcessReleaseTwice(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	r, w, err := os.Pipe()
	if err != nil {
		t.Fatalf("Pipe() got err %v, want nil", err)
	}
	defer r.Close()
	defer w.Close()

	p, err := os.StartProcess(testenv.GoToolPath(t), []string{"go"}, &os.ProcAttr{

@LeaksFileHandles
class CrossVersionToolingApiSpecificationRetryTest extends ToolingApiSpecification {

    def setup() {
        //these meta tests mess with the daemon log: do not interfere with other tests when running in parallel
        toolingApi.requireIsolatedDaemons()
    }

    def iteration = 0

    def "does not retry if NPE is thrown in daemon registry in >=1.8"() {
        given:
        iteration++

        when:

    app.kubernetes.io/version: "3.0.0"
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/component: single-binary
    app.kubernetes.io/part-of: memberlist
spec:
  replicas: 1
  podManagementPolicy: Parallel
  updateStrategy:
    rollingUpdate:
      partition: 0
  serviceName: loki-headless
  revisionHistoryLimit: 10
  
  persistentVolumeClaimRetentionPolicy:
    whenDeleted: Delete