</configuration>
        <executions>
          <execution>
            <id>unzip-slf4j-simple</id>
            <goals>
              <goal>unpack</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>build-helper-maven-plugin</artifactId>
        <executions>
          <execution>

import org.gradle.integtests.fixtures.daemon.DaemonsFixture
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.integtests.fixtures.executer.IntegrationTestBuildContext
import org.gradle.integtests.fixtures.executer.ResultAssertion
import org.gradle.internal.service.DefaultServiceRegistry

    }

    private void withAgentApplied(boolean shouldApply) {
        executer.withArgument("-D${DaemonBuildOptions.ApplyInstrumentationAgentOption.GRADLE_PROPERTY}=$shouldApply")
    }

    private void withoutAgent() {
        withAgentApplied(false)
    }

    DaemonLogsAnalyzer getDaemons() {
        new DaemonLogsAnalyzer(executer.daemonBaseDir)
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.caching

import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleExecuter

import org.gradle.kotlin.dsl.fixtures.AbstractKotlinIntegrationTest

import org.junit.After
import org.junit.Before

                "For assistance with migration, see https://gradle.com/help/gradle-plugin-develocity-migration.")
        executer.expectDeprecationWarning("""- The deprecated "gradleEnterprise.buildScan.termsOfServiceUrl" API has been replaced by "develocity.buildScan.termsOfUseUrl"""")

    @Rule BlockingHttpServer server = new BlockingHttpServer()
    GradleExecuter executer

    List<String> changedPaths = [file("src/main/java").absolutePath]

    def setup() {
        toolingApi.requireIsolatedToolingApi()

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

        executer = toolingApi.createExecuter()
    }

    @TargetGradleVersion(">=3.0")

                        // Process Isolation is required here since we are testing that a
                        // long-lived daemon process doesn't keep project files open between
                        // separate gradle executions.
                        WorkQueue workQueue = getWorkerExecutor().processIsolation(spec -> {
                            spec.getClasspath().from(getClasspath());
                        });

        println "resolve-transitive: " + dep.resolve(true).collect { it.name }
        dep.getBuildDependencies()
    }
}
"""

        when:

  xla::Shape old_shape = xla::TypeToShape(t);
  XLA_Shape old_shape_c = {};
  XLA_Shape new_shape_c = {};
  TfTpu_ExecutorApiFn *executor = stream_executor::tpu::ExecutorApiFn();
  if (!stream_executor::tpu::IsInitialized(executor)) {
    return failure();
  }
  ApiConverter::ToC(old_shape, &old_shape_c);
  executor->TpuTransferManager_GetInfeedLayoutFn(&old_shape_c, &new_shape_c);
  xla::Shape new_shape = ApiConverter::FromC(&new_shape_c);

                        classpath = sourceSets.main.runtimeClasspath
                        mainClass = 'Main'
                    }
                }
            }
        """

        when:
        executer.withConsole(consoleType)
        succeeds("run")

        then:
        def output = result.groupedOutput.task(':run').output
        output.contains(EXPECTED_OUTPUT)