* User-defined classes are loaded by and executed in the context of the application classloader. This classloader
 * contains classes from the {@code testRuntimeClasspath}. The implementation classpath includes classes required
 * by Gradle's test framework integrations.
 *
 * <p>In some cases, classes from the application classpath may be accessed by the implementation classpath. These

                public class B {
                    public String getId() { return "id"; }
                }
            '''
        ])

        when:
        def a = api.classes['com.acme.A'].clazz
        def b = api.classes['com.acme.B'].clazz

        then:
        a.name == 'com.acme.A'
        b.name == 'com.acme.B'

        when:
        def aa = createInstance(a)

        then:

            import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;

            @AnalyzeClasses(packages = "example")
            class DeclaresTestsAsFieldsNotMethodsTest {
                // this will create a JUnit Platform TestDescriptor with neither a Class- nor a MethodSource
                @ArchTest
                static final ArchRule example = classes().should().bePublic();
            }
        '''

    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") {
    val compileClasspath: FileCollection = configurations["compileClasspath"]
    dependsOn(compileClasspath)

class Other(thing: String) {
    def getThing(): String = thing
}
"""
        when:
        succeeds 'compileScala'

        then:
        file('build/classes/scala/main/org/test/Person.class').exists()
        file('build/classes/scala/main/org/test/Other.class').exists()

        when:
        file('src/main/scala/org/test/Other.scala').text = """
package org.test

guava-18.0.pom
Guava: Google Core Libraries for Java

    Guava is a suite of core and expanded libraries that include
    utility classes, google's collections, io classes, and much
    much more.

    Guava has only one code dependency - javax.annotation,

         * first value encountered in iteration order, which may be random.
         */
        if (classes | modules) {
            if (classes & modules) {
                selected = getPathType(path);
            } else if (classes) {
                selected = JavaPathType.CLASSES;
            } else {
                selected = JavaPathType.MODULES;
            }

  }

  public void testFindClassesToTest_withCorrespondingTestClassAndExplicitlyTested() {
    ImmutableList<Class<?>> classes = ImmutableList.of(Foo.class, FooTest.class);
    assertThat(findClassesToTest(classes, "testPublic")).isEmpty();
    assertThat(findClassesToTest(classes, "testNotThere", "testPublic")).isEmpty();
  }

  public void testFindClassesToTest_withCorrespondingTestClass_noTestName() {

        return classes.values().findAll { !it.name.contains('.internal.') }
    }

    boolean isKnownType(String className) {
        return classMetaData.find(className) != null
    }

    gradlebuild.docs.dsl.docbook.model.ClassDoc findClassDoc(String className) {
        gradlebuild.docs.dsl.docbook.model.ClassDoc classDoc = classes[className]

// tag::inner-link-task-properties[]
val archivesDirPath = layout.buildDirectory.dir("archives")
// end::inner-link-task-properties[]

tasks.register<Zip>("packageClasses") {
    archiveAppendix = "classes"
    destinationDirectory = archivesDirPath

    from(tasks.compileJava)
}
// end::link-task-properties[]

// tag::nested-specs[]
tasks.register<Copy>("nestedSpecs") {