given:
        def execHandleFactory = createExecHandleFactory(currentGradle())

        when:
        def detector = createDefaultJvmMetadataDetector(execHandleFactory)
        def javaHome = new File(temporaryFolder, "localGradle").tap { mkdirs() }
        def metadata = detector.getMetadata(testLocation(javaHome))

        then:
        metadata
        tmpDir.assertIsEmptyDir()
    }

  labels:
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:node-problem-detector
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: User

// license that can be found in the LICENSE file.

package main

// Setting an environment variable in a cgo program changes the C
// environment. Test that this does not confuse the race detector.

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread
*/
import "C"

import (
	"fmt"
	"os"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup

        FileLockManager lockManager,
        JvmMetadataDetector detector,
        GradleUserHomeTemporaryFileProvider temporaryFileProvider
    ) {
        this.operations = operations;
        this.jdkDirectory = new File(homeDirProvider.getGradleUserHomeDirectory(), "jdks");
        this.lockManager = lockManager;
        this.detector = detector;
        this.temporaryFileProvider = temporaryFileProvider;
    }

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This package holds the race detector .syso for
// amd64 architectures with GOAMD64>=v3.

//go:build amd64 && linux && amd64.v3

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This package holds the race detector .syso for
// amd64 architectures with GOAMD64<v3.

//go:build amd64 && ((linux && !amd64.v3) || darwin || freebsd || netbsd || openbsd || windows)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package race contains helper functions for manually instrumenting code for the race detector.

The runtime package intentionally exports these functions only in the race build;
this package exports them unconditionally but without the "race" build tag they are no-ops.
*/

    protected class TikaDetectParser extends CompositeParser {
        private static final long serialVersionUID = 1L;

        /**
         * The type detector used by this parser to auto-detect the type of a
         * document.
         */
        private final Detector detector; // always set in the constructor

        /**
         * Creates an auto-detecting parser instance using the default Tika
         * configuration.

# Test that when both race detection and coverage instrumentation are enabled,
# and seed values are being executed, the race detector isn't mistakenly
# triggered.

[short] skip
[!fuzz] skip
[!race] skip
env GOCACHE=$WORK/cache

# Test with coverage instrumentation enabled (-fuzz) and race instrumentation
# but without actually fuzzing the target (by using a non-matching pattern)
go test -fuzz=xxx -race -v

package rand_test

import (
	. "math/rand"
	"sync"
	"testing"
)

// TestConcurrent exercises the rand API concurrently, triggering situations
// where the race detector is likely to detect issues.
func TestConcurrent(t *testing.T) {
	const (
		numRoutines = 10
		numCycles   = 10
	)
	var wg sync.WaitGroup
	defer wg.Wait()
	wg.Add(numRoutines)