// The recommended way of dealing with existing platforms
        LEGACY_PLATFORM,   // constraints in platform are published without strict constraints, consumer uses 'platform()' dependencies + component metadata rules to make all published constraints strict
        // The discouraged way of dealing with existing platforms

Obsolete artifacts are then deleted to ensure the cache does not grow indefinitely.

[[sub:ephemeral-ci-cache]]
== Dealing with ephemeral builds

It's a common practice to run builds in ephemeral containers.
A container is typically spawned to only execute a single build before it is destroyed.

            "gradleEnvironmentVariables" to mapOf("myEnvVar" to "envValue")
        )
    }

    @Test
    fun `report file fatality on TAPI failure`() {
        // thus disabling syntax highlighting

        val editedScript = withBuildScript("")

        val wrongEnv = arrayOf("gradleHome" to existing("absent"))
        resolvedScriptDependencies(editedScript, env = wrongEnv).apply {

                   https://github.com/google/guava/commit/e06a8cec65815599e510d7f9c1ea9d2a8eaa438a,
                   builds with JDK8 began failing animal-sniffer with the error:

                   Failed to check signatures: Bad class file .../CollectionFuture$ListFuture.class

                   One way of dealing with that would be to disable
                   animal-sniffer. And that would be fine for our -jre builds:

                   https://github.com/google/guava/commit/e06a8cec65815599e510d7f9c1ea9d2a8eaa438a,
                   builds with JDK8 began failing animal-sniffer with the error:

                   Failed to check signatures: Bad class file .../CollectionFuture$ListFuture.class

                   One way of dealing with that would be to disable
                   animal-sniffer. And that would be fine for our -jre builds:

            }
"""
        checkConfiguration("conf")
        resolve.expectDefaultConfiguration("runtime")

        expect:
        succeeds 'checkDeps'
        //Shape of the graph is not checked as bug was failing resolution altogether
    }

    def 'platform upgrade does not leave orphaned edges'() {
        given:
        def depA = mavenHttpRepo.module('org.test', 'depA', '1.0').withModuleMetadata()

* when more than one variant from the producer matches the consumer attributes (ambiguity error)
* when no variants from the producer match the consumer attributes (incompatibility error)

[[sub:variant-ambiguity]]
=== Dealing with ambiguity errors

An ambiguous variant selection looks like the following:

[listing]
----
> Could not resolve all files for configuration ':compileClasspath'.
   > Could not resolve project :lib.

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;

/**
 * Self contained utility functions for dealing with AST.
 */
public abstract class AstUtils {

    private AstUtils() {
    }

    public static boolean isMethodOnThis(MethodCallExpression call, String name) {

	T     time.Duration // The total time taken.
	Error error         // Error is the error from the failing input
}

func (r fuzzResult) String() string {
	if r.Error == nil {
		return ""
	}
	return r.Error.Error()
}

// fuzzCrashError is satisfied by a failing input detected while fuzzing.
// These errors are written to the seed corpus and can be re-run with 'go test'.

     */
    ResolutionStrategy deactivateDependencyLocking();


    /**
     * Deactivates dependency verification for this configuration.
     * You should always be careful when disabling verification, and in particular avoid
     * disabling it for verification of plugins, because a plugin could use this to disable
     * verification itself.
     *
     * @since 6.2
     */