}
		})
	}
}

var (
	bigDataOnce  sync.Once
	bigDataBytes []byte
	bigDataErr   error
)

// bigData returns the contents of our large test file repeated multiple times.
func bigData(t testing.TB) []byte {
	bigDataOnce.Do(func() {
		bigDataBytes, bigDataErr = os.ReadFile("../../testdata/Isaac.Newton-Opticks.txt")
		if bigDataErr == nil {

                def compileGroovyDestinationDir = compileGroovy.destinationDirectory
                def binDir = file("$buildDir/bin")
                doLast {
                    assert mainGroovyDestDir.get().asFile == compileGroovyDestinationDir.get().asFile
                    assert mainGroovyDestDir.get().asFile == binDir
                }
            }
        '''

        expect:

      - '-c'
      - |
        gcloud auth configure-docker \
        && docker buildx create --name img-builder --use \
        && docker buildx inspect --bootstrap \
        && docker run --rm --privileged linuxkit/binfmt:4ea3b9b0938cbd19834c096aa31ff475cc75d281 \

)

// VolumeSchedulerSubsystem - subsystem name used by scheduler
const VolumeSchedulerSubsystem = "scheduler_volume"

var (
	// VolumeBindingRequestSchedulerBinderCache tracks the number of volume binder cache operations.
	VolumeBindingRequestSchedulerBinderCache = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Subsystem:      VolumeSchedulerSubsystem,
			Name:           "binder_cache_requests_total",

    val kmType: KmType
        get() = newClassTypeOf(internalName.value)
}


internal
fun IO.writeClassFileTo(binDir: File, internalClassName: InternalName, classBytes: ByteArray) {
    val classFile = binDir.resolve("$internalClassName.class")
    writeFile(classFile, classBytes)
}


internal

syso/goboringcrypto_linux_arm64.syso is built with:

	GOARCH=arm64 ./build.sh

Both run on an x86 Debian Linux system using Docker.
For the arm64 build to run on an x86 system, you need

	apt-get install qemu-user-static qemu-binfmt-support

to allow the x86 kernel to run arm64 binaries via QEMU.

		f.Add([]byte(test.data))
	}
	f.Add(bytes.Repeat([]byte("abcdefghijklmnop"), 256))
	var buf bytes.Buffer
	for i := 0; i < 256; i++ {
		buf.WriteByte(byte(i))
	}
	f.Add(bytes.Repeat(buf.Bytes(), 64))
	f.Add(bigData(f))

	f.Fuzz(func(t *testing.T, b []byte) {
		cmd := exec.Command(xxhsum, "-H64")
		cmd.Stdin = bytes.NewReader(b)
		var hhsumHash bytes.Buffer
		cmd.Stdout = &hhsumHash
		if err := cmd.Run(); err != nil {

	f.Add(bytes.Repeat([]byte("abcdefghijklmnop"), 256))
	var buf bytes.Buffer
	for i := 0; i < 256; i++ {
		buf.WriteByte(byte(i))
	}
	f.Add(bytes.Repeat(buf.Bytes(), 64))
	f.Add(bigData(f))

	f.Fuzz(func(t *testing.T, b []byte) {
		cmd := exec.Command(zstd, "-z")
		cmd.Stdin = bytes.NewReader(b)
		var compressed bytes.Buffer
		cmd.Stdout = &compressed
		cmd.Stderr = os.Stderr

static pthread_cond_t runtime_init_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t runtime_init_mu = PTHREAD_MUTEX_INITIALIZER;
static int runtime_init_done;

// pthread_g is a pthread specific key, for storing the g that binded to the C thread.
// The registered pthread_key_destructor will dropm, when the pthread-specified value g is not NULL,
// while a C thread is exiting.
static pthread_key_t pthread_g;
static void pthread_key_destructor(void* g);

        }
        DefaultNativePlatform targetPlatform = new DefaultNativePlatform("default");
        def visualCpp = vsInstall.visualCpp.forPlatform(targetPlatform)
        vcBin = visualCpp.binDir
        vcPath = visualCpp.path.join(';')
    }

    static @Nullable VisualStudioInstall findVisualStudio() {
        return VisualStudioLocatorTestFixture.visualStudioLocator.locateComponent(null).component
    }