* plugins {
 *     id 'java' // so that we can use 'implementation', 'testImplementation' for dependencies
 * }
 *
 * dependencies {
 *   //for dependencies found in artifact repositories you can use
 *   //the group:name:version notation
 *   implementation 'commons-lang:commons-lang:2.6'
 *   testImplementation 'org.mockito:mockito:1.9.0-rc1'
 *
 *   //map-style notation:

        plugin         | configuration                  | alternatives

        'java'         | 'compileOnly'                  | VALID
        'java'         | 'runtimeOnly'                  | VALID
        'java'         | 'implementation'               | VALID
        'java'         | 'apiElements'                  | FORBIDDEN
        'java'         | 'runtimeElements'              | FORBIDDEN
        'java'         | 'compileClasspath'             | FORBIDDEN

    }

    def "auxclasspath contains transitive implementation dependencies"() {
        Assume.assumeTrue(supportsAuxclasspath() && fileLockingIssuesSolved())

        setupIntermediateProject(ASSERTJ_IMPL_DEPENDENCY)
        setupRuleUsingProject(classReferencingIntermediate(), "implementation project(':intermediate')")

        expect:
        fails ":rule-using:pmdMain"

            subprojects {
                apply plugin: 'cpp-library'
            }
            project(':greeter') {
                dependencies { implementation project(':logger') }
            }
            project(':consumer') {
                dependencies { implementation project(':greeter') }
            }
"""
        app.greeterLib.writeToProject(file('greeter'))
        app.loggerLib.writeToProject(file('logger'))

                resolvable("runtimeClasspath") {
                    attributes.attribute(Attribute.of("attr1", Named), objects.named(Named,"value"))
                    extendsFrom(implementation)
                }
            }
            dependencies {
                implementation project(':producer')
            }

            task resolve {

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Function;

/**
 * Constructs the application and implementation classpaths for a test process,
 * while also optionally loading test framework implementation dependencies from
 * the distribution.
 *
 * @see ForkedTestClasspath
 */
public class ForkedTestClasspathFactory {

               .assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +
                   "Some toolchain resolvers had provisioning failures: custom (Unable to download toolchain matching the requirements ({languageVersion=11, vendor=any, implementation=vendor-specific}) " +

        module.artifact(classifier: "sources")
        module.artifact(classifier: "javadoc")
        module.publish()
        module.allowAll()

        buildFile << """
dependencies {
    implementation 'some:module:1.0:api'
}
"""

        when:
        useMavenRepo(repo)
        succeeds ideTask

        then:

        }
        verifyAll(receivedProblem(1)) {
            fqid == 'validation:property-validation:unknown-implementation'
            contextualLabel == 'Implementation of task \':customTask\' was loaded with an unknown classloader (class \'CustomTask_Decorated\').'
            details == 'Gradle cannot track the implementation for classes loaded with an unknown classloader.'

                }
            }
            project(':deck') {
                dependencies {
                    api project(':card')
                    implementation project(':shuffle')
                }
            }
"""
        app.deck.writeToProject(file('deck'))
        app.card.writeToProject(file('card'))
        app.shuffle.writeToProject(file('shuffle'))