import org.gradle.internal.serialize.codecs.core.JavaRecordCodec
import org.gradle.internal.serialize.codecs.guava.guavaTypes
import org.gradle.internal.serialize.codecs.stdlib.stdlibTypes
import org.gradle.internal.serialize.graph.codecs.BindingsBuilder


internal
fun BindingsBuilder.baseTypes() {
    stdlibTypes()
    guavaTypes()
    bind(JavaRecordCodec)
    bind(BuildIdentifierSerializer())

    id("gradlebuild.kotlin-experimental-contracts")
}

description = "Efficient and extensible serialization for object graphs, with the capability to isolate and manage portions of the graph independently"

dependencies {
    api(projects.configurationProblemsBase)
    api(projects.stdlibJavaExtensions)
    api(projects.loggingApi)
    api(projects.serialization)

    api(libs.guava)

                }
                graph(elements.get())
            }
        }
    }

    private fun PrintWriter.graph(elements: List<ArchitectureElement>) {
        println(
            """
            $markerComment
            $startDiagram
        """.trimIndent()
        )
        val writer = NodeWriter(this, "    ")
        writer.node("graph TD")
        for (element in elements) {

 */
class DefaultDependencyResolverResult implements DependencyResolverResult {
    /**
     * The exceptions that occurred while building the dependency graph.
     */
    private final List<Exception> exceptions;

    /**
     * The root node of the dependency graph.
     */
    private final Node root;

    /**
     * The ordered list of the flattened dependency nodes.
     */
    private final List<Node> nodes;

        given:
        configurationCacheRun(task, *options)
        def firstRunOutput = removeVfsLogOutput(result.normalizedOutput)
            .replaceAll(/Calculating task graph as no cached configuration is available for tasks: ${task}.*\n/, '')
            .replaceAll(/Configuration cache entry stored.\n/, '')

        when:
        configurationCacheRun(task, *options)

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.project;

import java.util.List;

import org.eclipse.aether.graph.Dependency;

/**
 */
public class DependencyResolutionException extends Exception {

    private final transient DependencyResolutionResult result;
    private final transient String detailMessage;

import org.gradle.api.Task
import org.gradle.api.internal.GradleInternal
import org.gradle.api.internal.project.ProjectInternal
import org.gradle.api.invocation.Gradle
import org.gradle.internal.serialize.graph.IsolateOwner


interface HostServiceProvider {
    fun <T> service(serviceType: Class<T>): T
}


inline fun <reified T : Any> HostServiceProvider.service(): T =
    service(T::class.java)

        executer.withArguments(commandLineArgs)
        configurationCacheRun "myTask"

        then:
        outputContains("bar")
        outputContains("Calculating task graph as configuration cache cannot be reused due to ${commandLineArgs.first()}")
        configurationCache.assertStateStored()

        when:
        configurationCacheRun "myTask"

        then:

        server.expectHead "/$scriptName", scriptFile
        server.expectGet "/$scriptName", scriptFile

        and:
        configurationCacheRun 'ok'

        then:
        output.contains "Calculating task graph as configuration cache cannot be reused because remote script $scriptUrl has changed."
        configurationCache.assertStateStored()
    }

    def "reuse cache if remote script is up to date"() {
        when:

import org.gradle.initialization.StartParameterBuildOptions

class ConfigurationCacheInputListenerLifecycleIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "configuration inputs are tracked during task graph serialization"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        and: "a project that has a provider having undeclared configuration inputs, which is linked to a task"