given:
        def downloader = new SecureFileDownloader(transportFactory)
        def destinationFile = new File(Files.createTempDirectory(temporaryFolder.toPath(), null).toFile(), "target")

        when:
        URI uri = URI.create("https://foo")
        downloader.download(uri, destinationFile, downloader.getResourceFor(uri, Collections.emptyList()))

        then:

        }
        classes.baseline()
        buildScript(classes.buildScript())
    }

    @Override
    protected void moveFilesAround() {
        Files.move(file("src/main/scala").toPath(), file("src/main/new-scala").toPath())
        classes.sourceDir = 'src/main/new-scala'
        buildScript(classes.buildScript())
        // Move scala library dependency around on disk
        executer.requireOwnGradleUserHomeDir()
    }

import javax.net.ssl.SSLSocketFactory
import okhttp3.ConnectionSpec
import okhttp3.OkHttp
import okhttp3.survey.types.Client
import okhttp3.survey.types.SuiteId
import okio.FileSystem
import okio.Path.Companion.toPath
import org.conscrypt.Conscrypt

fun currentOkHttp(ianaSuites: IanaSuites): Client {
  return Client(
    userAgent = "OkHttp",
    version = OkHttp.VERSION,
    enabled =

            println("##teamcity[importData type='junit' path='$outputXmlPath/TEST-*.xml' verbose='true']")
        }
    }
}

if (isTeamCityParallelTestsEnabled) {
    val gradleRootDir = repoRoot().asFile.toPath()
    project.gradle.taskGraph.whenReady {

                    File potentialJava = Jvm.forHome(potentialJavaHome).getJavaExecutable();
                    File desiredJava = desiredJavaHome.getJavaExecutable();
                    return Files.isSameFile(potentialJava.toPath(), desiredJava.toPath());
                }
            } catch (IOException e) {
                // ignore
            }
        }
        return false;
    }

        val classGraph = classGraph()

        val jarUri = URI.create("jar:${jarFile.toPath().toUri()}")
        FileSystems.newFileSystem(jarUri, emptyMap<String, Any>()).use { jarFileSystem ->
            jarFileSystem.rootDirectories.forEach {
                visitClassDirectory(it, classGraph, classesDir, manifestFile.toPath(), buildReceipt.toPath())
            }
        }
        return classGraph
    }

    private

                    return outFile;
                }

                @TaskAction
                public void run() throws IOException {
                    Files.write(outFile.get().getAsFile().toPath(), "content".getBytes());
                }
            }
        """
    }

    @Override
    void taskWithNestedBeanDefinition() {
        pluginDir.file("src/main/java/ProducerTask.java") << """

@DisableCachingByDefault(because = "Abstract super-class, not to be instantiated directly")
abstract class SubprojectsInfo : DefaultTask() {

    private
    val rootPath = project.layout.projectDirectory.asFile.toPath()

    private
    val platformsFolder = project.layout.projectDirectory.dir("platforms")

    private
    val subprojectsFolder = project.layout.projectDirectory.dir("subprojects")

    private

        withDefaultSettings()
        def buildFile = withBuildScript("plugins {\n${plugins.join("\n")}\n}")
        def classFilePath = accessorsClassFor(buildFile).toPath()
        return projectDir.toPath().relativize(classFilePath).toFile()
    }

    private File accessorsClassFor(File buildFile) {
        return classPathFor(projectDir, buildFile)
            .tap { println(it) }

            Artifact artifact = createArtifact("artifact", "1.0");

            File file = new File(artifactBasedir, "artifact-1.0.jar");
            assertEquals("dummy", new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8).trim());

            artifactDeployer.deploy(file, artifact, remoteRepository(), localRepository());

            ArtifactRepository remoteRepository = remoteRepository();