buildConfiguration: implementation("baz:buzz:2.0"),
                expectedConfigurations: [
                    "implementation = ${projectDependency(':foo')}, ${externalDependency('baz', 'buzz', '2.0')}"
                ]
            ],
            [
                testCase: "implementation has convention and is set to project",
                convention: implementation("foo:bar:1.0"),

            dependencies {
                implementation("org.codehaus.woodstox:wstx-asl:4.0.6")
                implementation("javax.xml.stream:stax-api:1.0")
                implementation("org.codehaus.woodstox:wstx-lgpl:3.2.9")
                implementation("org.codehaus.woodstox:woodstox-core-asl:4.4.1")
                implementation("stax:stax-api:1.0.1")
                implementation("woodstox:wstx-asl:2.9.3")

            doLast {
                assert testCompile*.name == ['commons-lang3-3.11.jar'] : 'commons-lang3 is an implementation dependency for the default test suite'
                assert testRuntime*.name == ['commons-lang3-3.11.jar'] : 'commons-lang3 is an implementation dependency for the default test suite'

        mavenRepo.module("org.test", "buildC", "1.0").publish()

        buildA.buildFile << """
            dependencies {
                implementation "org.different:buildB:1.0"
                implementation "org.test:buildC:1.0"
            }
        """

        when:
        checkDependencies()

        then:
        checkGraph {
            module("org.different:buildB:1.0")

    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)

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

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

project(':other-java') {
    apply plugin: 'java-library'
}

project(':java') {
    apply plugin: 'application'
    dependencies {
        implementation project(':other-java')
        implementation files('file-dep.jar')
        compileOnly 'test:compile-only:1.0'
        implementation 'test:implementation:1.0'
        runtimeOnly 'test:runtime-only:1.0'
    }
}

project(':consumer') {
    configurations { consume }

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

project(':java') {
    apply plugin: 'java'
    java {
        withJavadocJar()
        withSourcesJar()
    }
    dependencies {
        implementation project(':other-java')
        implementation files('file-dep.jar')
        compileOnly 'test:compile-only:1.0'
        implementation 'test:implementation:1.0'
        runtimeOnly 'test:runtime-only:1.0'
    }
}

project(':consumer') {
    configurations { consume }