description = "Provides plugins that configures the root Gradle project"

dependencies {
    implementation("gradlebuild:basics")

    implementation(project(":idea"))
    implementation(project(":profiling"))

    implementation(project(":cleanup")) {
        because("The CachesCleaner service is shared and needs to be on the root classpath")
    }

    implementation("com.autonomousapps:dependency-analysis-gradle-plugin")

        }
        if (this.implementation != null) {
            throw new InvalidModelException(String.format("Method annotated with @%s cannot set default implementation multiple times.", markerAnnotation.getSimpleName()));
        }
        this.implementation = implementation;
        return this;
    }

    api(libs.nativePlatform)

    implementation(projects.io)
    implementation(project(":base-asm"))
    implementation(project(":input-tracking"))
    implementation(project(":model-groovy"))

    implementation(libs.asmCommons)
    implementation(libs.commonsIo)
    implementation(libs.commonsLang)
    implementation(libs.errorProneAnnotations)
    implementation(libs.fastutil)
    implementation(libs.groovyAnt)

import java.util.Queue;
import java.util.concurrent.atomic.AtomicReference;

public class IsolationScheme<IMPLEMENTATION, PARAMS> {
    private final Class<IMPLEMENTATION> interfaceType;
    private final Class<PARAMS> paramsType;
    private final Class<? extends PARAMS> noParamsType;

    public IsolationScheme(Class<IMPLEMENTATION> interfaceType, Class<PARAMS> paramsType, Class<? extends PARAMS> noParamsType) {

}

// RootFsInfo is a fake implementation of Interface.RootFsInfo.
func (c *Fake) RootFsInfo() (cadvisorapiv2.FsInfo, error) {
	return cadvisorapiv2.FsInfo{}, nil
}

// ContainerFsInfo is a fake implementation of Interface.ContainerFsInfo.
func (c *Fake) ContainerFsInfo() (cadvisorapiv2.FsInfo, error) {
	return cadvisorapiv2.FsInfo{}, nil
}

// GetDirFsInfo is a fake implementation of Interface.GetDirFsInfo.

// tag::exclude-transitive-dependencies-1[]
dependencies {
    implementation('commons-beanutils:commons-beanutils:1.9.4') {
        exclude group: 'commons-collections', module: 'commons-collections'
    }
}
// end::exclude-transitive-dependencies-1[]
} else if (project.hasProperty('sample2')) {
// tag::exclude-transitive-dependencies-2[]
    dependencies {
        implementation('commons-beanutils:commons-beanutils:1.9.4') {

            @Override
            public void visitImplementation(Class<?> implementation) {
                workClass.set(GeneratedSubclasses.unpack(implementation));
            }

            @Override
            public void visitImplementation(ImplementationSnapshot implementation) {
            }
        });

    api(libs.groovy)
    api(libs.inject)
    api(libs.jsr305)

    implementation(projects.stdlibJavaExtensions)
    implementation(project(":base-services-groovy")) {
        because("Required for Specs")
    }
    implementation(project(":functional"))

    implementation(libs.commonsLang)
    implementation(libs.gson)
    implementation(libs.guava)

    testImplementation(testFixtures(project(":core")))

    Configuration implementation = Stub(ConfigurationInternal)

    def "has implementation dependencies"() {
        given:
        def binary = new TestBinary("binary", project.objects, implementation)

        expect:
        binary.implementationDependencies == project.configurations.binaryImplementation
        binary.implementationDependencies.extendsFrom == [implementation] as Set
    }

dependencies {
    api(project(":declarative-dsl-tooling-models"))

    api(libs.kotlinCompilerEmbeddable)
    api(libs.kotlinStdlib)

    implementation(project(":declarative-dsl-api"))
    implementation(libs.kotlinReflect)
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.6.2")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2")

    testImplementation(libs.futureKotlin("test-junit5"))