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)

    cppCompileVariant[label=<cppCompile<i>Variant</i> (R)>]
    nativeLinkVariant[label=<nativeLink<i>Variant</i> (R)>]
    nativeRuntimeVariant[label=<nativeRuntime<i>Variant</i> (R)>]
  }

  subgraph right {
    node[style=filled, fillcolor="#ea9999"]
    variantRuntimeElements [weight=1000]

    variantRuntimeElements[label=<<i>variant</i>RuntimeElements (C)>]
  }

  // Ensure the order is preserved

import org.gradle.model.Model;
import org.gradle.model.ModelMap;
import org.gradle.model.Mutate;
import org.gradle.model.RuleSource;

/**
 * These bindings are only here for backwards compatibility, as some users might depend on the extensions being available in the model.
 */
class PublishingPluginRules extends RuleSource {
    @Model
    PublishingExtension publishing(ExtensionContainer extensions) {

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,

class JULRedirectorIntegrationTest extends AbstractSampleIntegrationTest {
    def static final LYRICS = [
        "I'm a lumberjack, and I'm okay.",
        "I sleep all night and I work all day.",
        "He's a lumberjack, and He's okay.",
        "He sleeps all night and he works all day."
    ]
    @Rule TestResources testResources = new TestResources(temporaryFolder)

    /* Relies on the resources directory:

### 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.

            .assertTestPassed('superTest')
    }

    /**
     * This test documents the status quo behavior of the test runner, where tests based on fields
     * are not filtered by exclude patterns.  It might be desirable to change this behavior in the
     * future to filter on field names directly; if this is done, this test should be replaced.
     */
    @Issue("https://github.com/gradle/gradle/issues/19352")

import java.util.concurrent.CountDownLatch

class DefaultDynamicCallContextTrackerTest extends Specification {
    def tracker = new DefaultDynamicCallContextTracker()

    def "invokes callbacks in the right order with the right arguments"() {
        given:
        def log = []
        tracker.onEnter { log += ["enter", it] }
        tracker.onLeave { log += ["leave", it] }

        when:
        def entryPoint1 = new Object()

        for (int i = 0; i < extraAttributesArray.length; i++) {
            Attribute<?> extraAttribute = extraAttributesArray[i];
            // Some of these attributes might be weakly typed, e.g. coming as Strings from an
            // artifact repository. We always check whether the schema has a more strongly typed

            .withPathSensitivity(PathSensitivity.NAME_ONLY);

        // Should repositories be able to participate in incremental?
        // At the least, they may be able to express themselves as output files
        // They *might* have input files and other dependencies as well though
        // Inputs: The credentials they need may be expressed in a file
        // Dependencies: Can't think of a case here
    }

    /**