@PackageScope
class PidInstrumentation {

    private final File pidFile = createPidFile()
    private final File pidFileInitScript = createPidFileInitScript(pidFile)

    List<String> getGradleArgs() {
        ["--init-script", pidFileInitScript.absolutePath]
    }

    String getPid() {
        pidFile.text
    }

    private static File createPidFile() {
        def pidFile = File.createTempFile("build-under-test", ".pid")

        """

        when:
        succeeds("compileJava")

        then:
        pidFile().exists()
        def pid1 = pidFile().text.strip() as long
        kill(pid1)

        when:
        args "--rerun-tasks"
        succeeds("compileJava")

        then:
        pidFile().exists()
        def pid2 = pidFile().text.strip() as long
        pid2 != pid1

        and:

        then:
        handler.waitForAllPendingCalls()

        then:
        cancelBuild()

        then:
        daemons.daemon.becomesIdle()

        and:
        pidFile().exists()
        def pid1 = pidFile().text.strip() as long
        new ProcessFixture(pid1).waitForFinish()

        when:
        handler = blockingHttpServer.expectAndBlock("/block")
        startBuild("compileJava")

        stdout.reset()
        stderr.reset()
        return executionOutput
    }

    def requestJstackForBuildProcess() {
        def pidFile = file("build/build.pid")
        if (pidFile.exists()) {
            def pid = pidFile.text
            def jdkBinDir = new File(System.getProperty("java.home"), "../bin").canonicalFile
            if (jdkBinDir.isDirectory() && new File(jdkBinDir, "jstack").exists()) {

                inputs.file file("$triggerFileName")
                outputs.file "$idFileName"
                doLast {
                    def idFile = file("${idFileName}")
                    def service = services.get(${service})
                    idFile << System.identityHashCode(service) + "\\n"
                }
            }
        """

        when:
        triggerFile << "content"

        then:

  if [ -f /etc/docker/daemon.json ]; then
    echo "Contents of the old docker config"
    cat /etc/docker/daemon.json
  fi

  cat <<EOF >/etc/docker/daemon.json
{
EOF

addockeropt "\"pidfile\": \"/var/run/docker.pid\",
  \"iptables\": false,
  \"ip-masq\": false,"

  echo "setting log-level"
  if [[ "${TEST_CLUSTER:-}" == "true" ]]; then
    addockeropt "\"log-level\": \"debug\","
  else

.idea
.ipynb_checkpoints
.mypy_cache
.vscode
__pycache__
.pytest_cache
htmlcov
dist
site
.coverage
coverage.xml
.netlify
test.db
log.txt
Pipfile.lock
env3.*
env
docs_build
site_build
venv
docs.zip
archive.zip

# vim temporary files
*~
.*.sw?
.cache

# macOS

/tensorflow/lite/**/coreml/**/BUILD
/tensorflow/lite/**/ios/BUILD
/tensorflow/lite/**/objc/BUILD
/tensorflow/lite/**/swift/BUILD
/tensorflow/lite/examples/ios/simple/data/*.tflite
/tensorflow/lite/examples/ios/simple/data/*.txt
Podfile.lock
Pods

			`
apiVersion: v1
kind: Pod
metadata:
  name: testpod
spec:
  - image: registry.k8s.io/busybox
`,
			true,
		},
	}

	for _, test := range tests {
		tempFile, err := os.CreateTemp("", "podfile")
		defer os.Remove(tempFile.Name())
		if err != nil {
			t.Fatalf("cannot create temporary file: %v", err)
		}
		if _, err = tempFile.Write([]byte(test.content)); err != nil {

	// Up to 10 locks held by this m, maintained by the lock ranking code.
	locksHeldLen int
	locksHeld    [10]heldLockInfo
}

type p struct {
	id          int32
	status      uint32 // one of pidle/prunning/...
	link        puintptr
	schedtick   uint32     // incremented on every scheduler call
	syscalltick uint32     // incremented on every system call
	sysmontick  sysmontick // last tick observed by sysmon