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

    implementation(projects.concurrent)
    implementation(project(":functional"))
    implementation(project(":logging-api"))

    implementation(libs.groovyJson)
    implementation(libs.guava)
    implementation(libs.commonsLang)
    implementation(libs.jatl)

    testImplementation(project(":process-services"))

            ${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.")
    }

    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)

// 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") {

                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'

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") {

    api(project(":process-services"))

    api(libs.inject)
    api(libs.jsr305)
    api(libs.nativePlatform)

    implementation(project(":functional"))
    implementation(project(":native"))

    implementation(libs.guava)
    implementation(libs.asm)
    implementation(libs.xmlApis)
    implementation(libs.slf4jApi)

    testImplementation(project(":native"))
    testImplementation(project(":file-collections"))

    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[]

 * </ul>
 *
 * <p>
 * A value source implementation will most likely take parameters. To do this create a
 * subtype of {@link ValueSourceParameters} and declare this type as the type parameter
 * to the value source implementation.
 * </p>
 *
 * <p>
 * A value source implementation doesn't have to be thread-safe, as the single call
 * to {@link #obtain()} is synchronized.
 * </p>

    api(project(":declarative-dsl-tooling-models"))
    api(libs.kotlinStdlib)


    implementation(libs.inject)
    testImplementation(libs.mockitoKotlin2)

    implementation(project(":base-services"))
    implementation(project(":resources"))
    implementation(project(":model-core"))

    implementation(libs.guava)
    implementation(libs.kotlinReflect)

    integTestImplementation(project(":internal-testing"))