${createDependenciesAndConfiguration()}

            dependencies.implementation 'com:foo:1.0'

            assert conf.dependencies*.name == ["foo"]

            dependencies.implementation 'com:bar:1.0'
        """

        when:
        fails("help")

        then:
        failure.assertHasErrorOutput("The value for property 'implementation' property 'dependencies' is final and cannot be changed any further.")
    }

configure(project(":a")){
    dependencies {
        implementation files("bar.jar")
        implementation project(':b')
    }
}

configure(project(":b")){
    dependencies {
        implementation project(':c')
        implementation files("baz.jar")

    }
}

configure(project(":c")){
    dependencies {
        implementation files("foo.jar")
    }
}
"""

    api(libs.groovyAnt)
    api(libs.guava)
    api(libs.ant)
    api(libs.inject)

    implementation(projects.io)
    implementation(project(":base-services-groovy"))
    implementation(project(":logging"))
    implementation(project(":build-process-services"))
    implementation(libs.commonsLang)
    implementation(libs.slf4jApi)

    runtimeOnly(libs.kotlinReflect)

    testImplementation(libs.asm)

val implementation = configurations.create("implementation")
val compileClasspath = configurations.create("compileClasspath") {
    extendsFrom(implementation)
}

// tag::generated-file-dependencies[]
dependencies {
    implementation(files(layout.buildDirectory.dir("classes")) {
        builtBy("compile")
    })
}

tasks.register("compile") {
    doLast {
        println("compiling classes")
    }
}

tasks.register("list") {

   * override {@link #setCount(Object, int, int)} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardSetCount(@ParametricNullness E element, int oldCount, int newCount) {
    return Multisets.setCountImpl(this, element, oldCount, newCount);
  }

  /**
   * A sensible implementation of {@link Multiset#elementSet} in terms of the following methods:

                Thread.sleep(100)
            }
        }
    }
}

dependencies {
    implementation 'commons-lang:commons-lang:2.5'
    implementation "commons-httpclient:commons-httpclient:3.0"
    implementation "commons-codec:commons-codec:1.2"
    implementation "org.slf4j:jcl-over-slf4j:1.7.10"
    implementation "org.codehaus.groovy:groovy:2.4.10"
    testImplementation 'junit:junit:4.13'

plugins {
    id("gradlebuild.distribution.implementation-java")
}

description = "Provides high-level insights into a Gradle build (--profile)"

dependencies {
    api(projects.stdlibJavaExtensions)
    api(projects.serviceProvider)
    api(projects.time)
    api(project(":base-services"))
    api(project(":core"))
    api(project(":core-api"))
    api(project(":enterprise-logging"))

    implementation(project(":logging"))

     *
     * @param parser The XML parser
     * @return Name of the custom implementation; otherwise {@code null}
     */
    private static String parseImplementation(final XmlPullParser parser) {
        return parser.getAttributeValue(null, "implementation");
    }

    /**
     * Attempts to load the named implementation, uses default implementation if no name is given.

    api(project(":build-operations"))
    api(project(":files"))

    api(libs.jsr305)

    implementation(projects.io)
    implementation(projects.time)

    implementation(libs.guava)
    implementation(libs.slf4jApi)
    implementation(libs.commonsIo)
    implementation(libs.commonsLang)

    testImplementation(projects.messaging)
    testImplementation(project(":core-api"))

    implementation(enforcedPlatform("org.springframework.boot:spring-boot-dependencies:1.5.8.RELEASE"))

    // define dependencies without versions
    implementation("com.google.code.gson:gson")
    implementation("dom4j:dom4j")

    // this version will be overridden by the one found in the BOM
    implementation("org.codehaus.groovy:groovy:1.8.6")
}
// end::dependency-on-bom[]