onlyIf("By default not in CI") {
    !isCi.isPresent
      || (containerTests.isPresent && containerTests.get().toBoolean())
  }

  jvmArgs(
    "-Dokhttp.platform=$platform",
  )

  if (platform == "loom") {
    jvmArgs(
      "-Djdk.tracePinnedThreads=short",
    )
  }

  val javaToolchains = project.extensions.getByType<JavaToolchainService>()

  testRuntimeOnly(library("junit-vintage-engine"))
  testRuntimeOnly(library("junit-platform-launcher"))
}

tasks.withType<Test> {
  useJUnitPlatform()
  jvmArgs("-Dokhttp.platform=$platform")

  if (platform == "loom") {
    jvmArgs("-Djdk.tracePinnedThreads=short")
  }
  if (platform == "openjsse") {
    if (testJavaVersion > 8) {
      throw GradleException("OpenJSSE is only supported on Java 8")
    }
  }

        val rootProperties = readProperties(rootPropertiesFile.asFile)
        val jvmArgs = listOf(buildLogicProperties, rootProperties).map { it.getProperty("org.gradle.jvmargs") }.toSet()
        if (jvmArgs.size > 1) {
            throw GradleException("gradle.properties and build-logic/gradle.properties have different org.gradle.jvmargs " +
                "which may cause two daemons to be spawned on CI and in IDEA. " +

  from { configurations.painless.collect { zipTree(it) } }
  into "${buildDir}/plugins/painless"
}

tasks.named("run").configure {
  executable = "${BuildParams.runtimeJavaHome}/bin/java"
  jvmArgs << "-Dplugins.dir=${buildDir}/plugins" << "-Dtests.index=${buildDir}/index"
  dependsOn "copyExpression", "copyPainless"
}

spotless {
  java {
    // IDEs can sometimes run annotation processors that leave files in

                    args(stylesheetFile.absolutePath)
                    args(fvd.file.absolutePath)
                    args(outFile.absolutePath)
                    args(destDir.absolutePath)
                    jvmArgs('-Xmx1024m')
                    classpath = xslClasspath
                    systemProperty 'xslthl.config', xslthlConfigFile

sudo cp .libs/libhsdis.so.0.0.0 /usr/lib/jvm/java-14-adoptopenjdk/lib/hsdis-amd64.so
```

If you want to disassemble a single method do something like this:

```
gradlew -p benchmarks run --args ' MemoryStatsBenchmark -jvmArgs "-XX:+UnlockDiagnosticVMOptions -XX:CompileCommand=print,*.yourMethodName -XX:PrintAssemblyOptions=intel"
```

If you want `perf` to find the hot methods for you then do add `-prof perfasm`.

## Async Profiler

    val alpnBootJar =
      configurations
        .detachedConfiguration(
          dependencies.create("org.mortbay.jetty.alpn:alpn-boot:$alpnBootVersion"),
        ).singleFile
    tasks.withType<Test> {
      jvmArgs("-Xbootclasspath/p:$alpnBootJar")
    }
  }
}

// From https://github.com/Kotlin/kotlinx-atomicfu/blob/master/atomicfu/build.gradle.kts
val compileJavaModuleInfo by tasks.registering(JavaCompile::class) {

            String argline = System.getProperty("tests.jvm.argline");
            if (argline != null) {
                test.jvmArgs((Object[]) argline.split(" "));
            }

            if (Util.getBooleanProperty("tests.asserts", true)) {
                test.jvmArgs("-ea", "-esa");
            }

            Map<String, String> sysprops = Map.of(
                "java.awt.headless",

name: containers

on:
  push:
    branches:
      - master
  pull_request:
    types: [opened, labeled, unlabeled, synchronize]

permissions:
  contents: read

env:
  GRADLE_OPTS: "-Dorg.gradle.jvmargs=-Xmx4g -Dorg.gradle.daemon=false -Dkotlin.incremental=false"

jobs:
  test_containers:
    permissions:
      checks: write # for actions/upload-artifact
    runs-on: ubuntu-latest

            if (BuildParams.getRuntimeJavaVersion().compareTo(JavaVersion.VERSION_14) < 0) {
                task.jvmArgs("-XX:+UseConcMarkSweepGC", "-XX:CMSInitiatingOccupancyFraction=75", "-XX:+UseCMSInitiatingOccupancyOnly");
            } else {
                task.jvmArgs("-XX:+UseG1GC");
            }
        });

        // TODO: fix usages of IT tests depending on Tests methods so this extension is not necessary