import java.nio.file.Files

class SecureFileDownloaderTest extends Specification {

    @TempDir
    public File temporaryFolder

    def "successful download creates destination file with the right content"() {
        RepositoryTransportFactory transportFactory = newTransportFactory()

        given:
        def downloader = new SecureFileDownloader(transportFactory)

        if (!executableFile.isAbsolute()) {
            DeprecationLogger.deprecateBehaviour("Configuring a Java executable via a relative path.")
                    .withContext("Resolving relative file paths might yield unexpected results, there is no single clear location it would make sense to resolve against.")
                    .withAdvice("Configure an absolute path to a Java executable instead.")

#### Core automation platform

This is a general-purpose automation platform which takes care of the efficient definition and execution of work, such as tasks.
This platform is agnostic to what exactly the purpose of the work is.
It might be creating an application, setting up development environments, orchestrating deployments, running simulations, etc.

            node -> node
            else -> get(value).also { dsu[node] = it }
        }

        fun union(left: ResolutionNode, right: ResolutionNode) {
            dsu[get(left)] = right
        }

        assignmentByNode.forEach { (key, value) ->
            union(key, value.node)
        }

        return buildMap {

        val logger = mock<Logger>()
        val template = """
            WARNING: Unsupported Kotlin plugin version.
            The `embedded-kotlin` and `kotlin-dsl` plugins rely on features of Kotlin `{}` that might work differently than in the requested version `{}`.
        """.trimIndent()


        logger.warnOnDifferentKotlinVersion(embeddedKotlinVersion)

        inOrder(logger) {
            verifyNoMoreInteractions()

import org.gradle.tooling.internal.protocol.PhasedActionResultListener;

import java.util.ArrayList;
import java.util.List;

/**
 * Listener that will collect failures from the delegate listener and rethrow them in the right moment of the build.
 */
public class FailsafePhasedActionResultListener implements PhasedActionResultListener {
    private final PhasedActionResultListener delegate;

    /**
     * Adds an action to be called immediately before a project is evaluated.
     * <p>
     * The action will be applied to all projects configured in the current build. Due to `Isolated Projects`, a particular build might only configure a subset of all projects.
     *
     * @param action The action to execute.
     */
    void beforeProject(Action<? super Project> action);

         '/I' + includeDir.absoluteFile.toString(), '/I' + systemIncludeDir.absoluteFile.toString()]
    }

    def "check that position sensitive arguments are in the right order"() {
        given:
        def genericArgs = [ '/nologo' ]
        def sourceArgs = [ 'path/to/source.rc' ]
        def outputArgs = [ 'path/to/output.res' ]
        def compiler = getCompiler()
        expect:

import org.gradle.internal.classloader.ClassLoaderVisitor

import org.gradle.kotlin.dsl.support.foldHierarchy

import java.net.URL

import java.util.*


/**
 * A formatter for strings that might contain file system paths.
 */
internal
typealias PathStringFormatter = (String) -> String


internal
fun classLoaderHierarchyJsonFor(
    klass: Class<*>,
    targetScope: ClassLoaderScope,

import org.gradle.internal.exceptions.DefaultMultiCauseException


/**
 * Marker interface for exception handling.
 */
internal
interface ConfigurationCacheThrowable


/**
 * State might be corrupted and should be discarded.
 */
@Contextual
class ConfigurationCacheError internal constructor(
    error: String,
    cause: Throwable? = null
) : ConfigurationCacheThrowable, Exception(error, cause)