def buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

        buildFile << """
            apply plugin: "java"

            tasks.compileJava {
                options.fork = true
                options.forkOptions.jvmArgs = ['--not-a-real-argument']
            }
        """

        file('src/main/java/ClassToCompile.java') << """
            class ClassToCompile {
            }

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Random;

@Fork(4)
@Threads(2)
@Warmup(iterations = 10)
@State(Scope.Benchmark)
public class CachedConstructorsBenchmark {

- [ ] Check ["Allow edit from maintainers" option](https://help.github.com/articles/allowing-changes-to-a-pull-request-branch-created-from-a-fork/) in pull request so that additional changes can be pushed by Gradle team.
- [ ] Provide integration tests (under `<subproject>/src/integTest`) to verify changes from a user perspective.

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import org.apache.commons.io.FileUtils;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;

                compileScala {
                    options.fork = true
                    options.forkOptions.executable = "${TextUtil.normaliseFileSeparators(otherJdk.javaExecutable.absolutePath)}"
                }
            """
        } else {
            buildFile << """
                compileScala {
                    options.fork = true

                compileGroovy {
                    options.fork = true
                    options.forkOptions.executable = "${TextUtil.normaliseFileSeparators(otherJdk.javaExecutable.absolutePath)}"
                }
            """
        } else {
            buildFile << """
                compileGroovy {
                    options.fork = true

        buildFile << """
            plugins {
                id 'java'
            }
            ${dependsOnPidCapturingAnnotationProcessor}
            tasks.withType(JavaCompile).configureEach {
                options.fork = true
            }
        """
        file('src/main/java/Foo.java') << blockingFooClass
        def handler = blockingHttpServer.expectAndBlock("/block")

        when:
        startBuild("compileJava")

                .debugTestsOn(jdwpClient.port)
                .run()
        }

        then:
        true // test successfully executed with debugger attached
    }

    def "forks only one JVM to debug"() {
        setup:
        buildFile << """
             tasks.withType(Test) {
                  forkEvery = 1
                  maxParallelForks = 2
            }
        """

permissions: {}

jobs:
  build:

    # execute on any push or pull request from forked repo
    if: github.event_name == 'push' || ( github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork )

    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        java: [17, 21]
      fail-fast: false

    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v4

	if GOOS == "solaris" || GOOS == "illumos" {
		// Be explicit that we don't want to reserve swap space
		// for PROT_NONE anonymous mappings. This avoids an issue
		// wherein large mappings can cause fork to fail.
		flags |= _sunosMAP_NORESERVE
	}
	p, err := mmap(v, n, _PROT_NONE, flags, -1, 0)
	if err != 0 {
		return nil
	}
	return p
}

const _sunosEAGAIN = 11
const _ENOMEM = 12