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

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

     *
     * @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.

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

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

 */

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

description = "Controls for the instrumentation agent potentially applied to the process"

dependencies {
    api(projects.stdlibJavaExtensions)

    implementation(projects.baseServices)
    implementation(projects.functional)

    implementation(libs.jsr305)
    implementation(libs.slf4jApi)

    api(project(":problems-api"))
    api(project(":snapshots"))

    implementation(projects.time)
    implementation(project(":logging"))
    implementation(projects.enterpriseOperations) {
        because("Adds generic build operations for the execution engine")
    }

    implementation(libs.commonsLang)
    implementation(libs.commonsIo)

    testImplementation(project(":native"))

                val ${suiteName}Implementation = configurations.getByName("${suiteName}Implementation")
                // We might get junit included too, dependending on the test suite, so filter it
                val deps = ${suiteName}Implementation.dependencies
                            .filter { it.name != "junit-jupiter" }

            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
            }
        }

        named("jsTest") {
            dependencies {
                implementation(kotlin("test-js"))
            }
        }

        named("jvmTest") {
            dependencies {
                implementation(kotlin("test-junit5"))