commands: [{
    executable: gradle
    args: dependencyInsight --configuration functionalTestClasspath --dependency gson
    expected-output-file: dependencyInsight.out
    allow-additional-output: true
},{
    execution-subdirectory: lib
    executable: gradle
    args: usages
    expected-output-file: usages.out
    allow-additional-output: true

commands:[{
    executable: gradle
    args: "build -DtestToolchain=knownVendor"
}, {
    executable: gradle
    args: "build -DtestToolchain=matchingVendor"
    expect-failure: true  # The matching vendor uses a dummy vendor string that is never matched
    expected-output-file: matchingVendorWithCC.out
    allow-additional-output: true

commands: [{
    executable: gradle
    args: clean alwaysInstrumentClasses
    allow-additional-output: true
    allow-disordered-output: true
},{
    executable: gradle
    args: alwaysInstrumentClasses
    expected-output-file: incrementalBuildUpToDateWhenAgain.out
    allow-additional-output: true
    allow-disordered-output: true

}

val executableJar by tasks.registering(Jar::class) {
    archiveFileName = "gradle-wrapper-executable.jar"
    manifest {
        attributes.remove(Attributes.Name.IMPLEMENTATION_VERSION.toString())
        attributes(Attributes.Name.IMPLEMENTATION_TITLE.toString() to "Gradle Wrapper")
    }
    from(layout.projectDirectory.dir("src/executable/resources"))
    from(sourceSets.main.get().output)

commands: [{
    execution-subdirectory: project
    executable: gradle
    args: "dependencyInsight --configuration compileClasspath --dependency mongo"
    expected-output-file: compileClasspath.out
},{
    execution-subdirectory: project
    executable: gradle
    args: "dependencyInsight --configuration runtimeClasspath --dependency mongo"
    expected-output-file: runtimeClasspath.out

            apply plugin: 'java'

            task execTask(type: Exec) {
                dependsOn sourceSets.main.runtimeClasspath
                def testFile = file("${'$'}buildDir/${'$'}name")
                executable = Jvm.current().getJavaExecutable()
                args '-cp', sourceSets.main.runtimeClasspath.asPath, 'org.gradle.TestMain', projectDir, testFile
                doLast {
                    assert testFile.exists()

        properties.load(buildDir.file('gradle.properties').newInputStream())
        GpgCmdAndVersion client = getAvailableGpg()
        assert client
        properties.put('signing.gnupg.executable', client.executable)
        properties.put('signing.gnupg.useLegacyGpg', (client.version == 1).toString())
        properties.put('signing.gnupg.homeDir', gpgHomeSymlink.toAbsolutePath().toString())

  EXPECT_FALSE(status.ok());
  EXPECT_TRUE(absl::StrContains(status.message(), "XLA compilation disabled"));

  // Check that async compilation is disallowed.
  status = xla_device_compiler->CompileIfNeeded(
      XlaCompiler::Options{}, fn, args, XlaCompiler::CompileOptions{},
      DeviceCompileMode::kAsync, profiler, &compilation_result, &executable);
  EXPECT_FALSE(status.ok());

    bool may_alias_resource_update, FunctionLibraryRuntime* flr,
    ResourceMgr* rm, const XlaCompiler::CompilationResult** compilation_result,
    xla::PjRtClient** client, xla::PjRtLoadedExecutable** executable) {
  PjRtDeviceCompiler* pjrt_device_compiler;
  DeviceCompilationProfiler* profiler;
  TF_RETURN_IF_ERROR(GetOrCreatePjRtDeviceCompilerAndProfiler(
      platform_info, rm, flr, &pjrt_device_compiler, &profiler));

            test {
                executable "${TextUtil.escapeString(originalJavaExecutable)}"
            }

            afterEvaluate {
                println "Running with JDK: \$test.executable"
            }
        """
    }

    @Override
    protected void moveFilesAround() {
        buildFile << """
            test {
                executable "${TextUtil.escapeString(differentJavaExecutable)}"