def "can define different implementation dependencies on each binary"() {
        given:
        createDirs("lib")
        settingsFile << 'include "lib"'
        makeComponentWithLibrary()
        buildFile << """
            ${componentUnderTestDsl} {
                binaries.getByName('mainDebug').configure {
                    dependencies {
                        implementation project(':lib')
                    }

                implementation.exclude(group: "implementation-group", module: "implementation-module")
                runtimeOnly.exclude(group: "runtimeOnly-group", module: "runtimeOnly-module")
            }

            dependencies {
                api "org.test:a:1.0"
                implementation "org.test:b:2.0"
                api project(':subproject')
            }

}

description = "Local build cache implementation"

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":build-cache"))
    api(project(":build-cache-spi"))
    api(project(":files"))
    api(project(":functional"))
    api(project(":hashing"))
    api(project(":persistent-cache"))

    implementation(libs.commonsIo)
    implementation(libs.guava)

    api(project(":core-api"))
    api(project(":core"))

    implementation(libs.guava)
    implementation(libs.slf4jApi)
    implementation(project(":io"))
    implementation(project(":enterprise-logging"))

    testImplementation(testFixtures(project(":serialization")))

plugins {
    id 'java'
}
// end::plugins[]

repositories {
    mavenCentral()
}

// tag::bom[]
dependencies {
    implementation platform('org.springframework.boot:spring-boot-dependencies:1.5.8.RELEASE') // <1>

    implementation 'com.google.code.gson:gson' // <2>
    implementation 'dom4j:dom4j'
}

     *
     * @implSpec Do not implement this method. Gradle generates the implementation automatically.
     *
     * @see PlatformDependencyModifiers.PlatformDependencyModifier#modifyImplementation(ModuleDependency)
     */
    @Nested
    PlatformDependencyModifier getPlatform();

    /**
     * Implementation for the platform dependency modifier.
     *
     * @see #modifyImplementation(ModuleDependency)

)

// NewFileWatcherFunc returns a function which creates a new file
// watcher. This may be used to provide test hooks for using the
// FakeWatcher implementation below.
type NewFileWatcherFunc func() FileWatcher

// FakeWatcher provides a fake file watcher implementation for unit
// tests. Production code should use the `NewWatcher()`.
type FakeWatcher struct {
	sync.Mutex

	events      map[string]chan fsnotify.Event

 * override {@code addAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardAddAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedSet}.
 *

        'CppLibraryDependenciesIntegrationTest',
    ])
    def "can define implementation dependencies on component"() {
        given:
        createDirs("lib")
        settingsFile << 'include "lib"'
        makeComponentWithLibrary()
        buildFile << """
            ${componentUnderTestDsl} { c ->
                c.dependencies {
                    implementation project(':lib')
                }
            }
        """

    }

    def "recompiles source when annotation processor implementation on annotation processor classpath changes"() {
        given:
        settingsFile << "include 'c'"

        buildFile << """
            project(':b') {
                dependencies {
                    implementation project(':a')
                }
            }
            project(':c') {