executedAndNotSkipped(":zip")
        outputFile.exists()
        outputFile.unzipTo(unpackDir)
        unpackDir.file("subdir/B").text == "B"

        when:
        sourceDir.file("newdir").createDir()

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":zip")
    }

    def "using compressed files as inputs - #type #packType #source - readonly #readonly"() {

            )
        )
    }

    @Test
    fun `precompiled script plugins can be published by maven-publish plugin`() {

        val repository = newDir("repository")

        publishPluginsTo(repository) {

            withFile(
                "my-plugin.gradle.kts",
                """
                println("my-plugin applied!")
                """

	*LstatP = func(name string) (FileInfo, error) {
		if strings.HasSuffix(name, "some-file") {
			// Act like it's been deleted.
			return nil, ErrNotExist
		}
		return oldStat(name)
	}
	dir := newDir("TestReaddirRemoveRace", t)
	defer RemoveAll(dir)
	if err := WriteFile(filepath.Join(dir, "some-file"), []byte("hello"), 0644); err != nil {
		t.Fatal(err)
	}
	d, err := Open(dir)
	if err != nil {

            Wrapper::class.java,
            Wrapper.DistributionType::class.java,
            SomeKotlin::class.java,
            SomeKotlin.NestedType::class.java
        )

        val cpDir = newDir("cp-dir")
        unzipTo(cpDir, jar2)

        ClassBytesRepository(
            platformClassLoader = ClassLoaderUtils.getPlatformClassLoader(),
            classPathFiles = listOf(jar1, cpDir)

        val packageDeclaration = packageName?.let { "package $it" } ?: ""
        val packageQualifier = packageName?.let { "$it." } ?: ""

        withProjectRoot(newDir("external-plugins")) {
            withFolders {
                "external-foo" {
                    withKotlinDslPlugin()
                    withFile(
                        "src/main/kotlin/external-foo.gradle.kts",

// Uploaders should only be used for one call to [uploader.Run].
func newUploader(rcfg RunConfig) (*uploader, error) {
	// Determine the upload directory.
	var dir telemetry.Dir
	if rcfg.TelemetryDir != "" {
		dir = telemetry.NewDir(rcfg.TelemetryDir)
	} else {
		dir = telemetry.Default
	}

	// Determine the upload URL.
	uploadURL := rcfg.UploadURL
	if uploadURL == "" {
		uploadURL = "https://telemetry.go.dev/upload"
	}

    protected
    fun newFile(fileName: String): File {
        return canonicalFile(fileName).apply {
            parentFile.mkdirs()
            createNewFile()
        }
    }

    protected
    fun newDir(relativePath: String): File =
        existing(relativePath).apply { assert(mkdirs()) }

    protected
    fun newOrExisting(fileName: String) =
        existing(fileName).let {
            when {

        name: String,
        before: Project.() -> Unit = {},
        script: String,
        tasksAssertions: List<TaskAssertion> = tasksConfigurationAssertions
    ) {
        val projectDir = newDir(name)
        runWithProjectBuilderProject(projectDir) {
            preRegisteredTasks.forEach {
                tasks.register(it.name, it.type.java)
            }

            before()

                    @Override
                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attributes) throws IOException {
                        Path newDir = targetDir.resolve(sourceDir.relativize(dir));
                        Files.createDirectories(newDir);

                        return FileVisitResult.CONTINUE;
                    }
                });
            } catch (IOException e) {

// Start returns a StartResult, which may be awaited via [StartResult.Wait] to
// wait for all work done by Start to complete.
func Start(config Config) *StartResult {
	if config.TelemetryDir != "" {
		telemetry.Default = telemetry.NewDir(config.TelemetryDir)
	}
	result := new(StartResult)

	mode, _ := telemetry.Default.Mode()
	if mode == "off" {
		// Telemetry is turned off. Crash reporting doesn't work without telemetry