}
        }

    override fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration? {
        return getClassLikeDeclarationsByClassId(classId).firstOrNull()
    }

    override fun getAllClassesByClassId(classId: ClassId): Collection<KtClassOrObject> {
        return getClassLikeDeclarationsByClassId(classId).filterIsInstance<KtClassOrObject>().toList()
    }

    }

    private TestCaseExecution success(long classId, long id) {
        return new TestCaseExecutionSuccess(outputProvider(classId, id), options);
    }

    private TestCaseExecution skipped(long classId, long id) {
        return new TestCaseExecutionSkipped(outputProvider(classId, id), options);
    }

    <property name="build.dir" value="target"/>
    <property name="classes.dir" value="${build.dir}/classes"/>

    <!-- tag::build-required[] -->
    <target name="buildRequiredProjects">
        <ant dir="${root.dir}/util" target="build"/>
    </target>
    <!-- end::build-required[] -->

    <target name="compile" depends="buildRequiredProjects">
        <mkdir dir="${classes.dir}"/>

     *
     * Starts at this class and capture all classes that reference this class and all classes and resources that were generated from this class.
     * Then does the same analysis for all classes that expose this class on their ABI recursively until no more new classes are discovered.
     */

        currentMetaAnnotations: Set<ClassId>?,
        indent: Int
    ) {
        appendLine("annotations: [".indented(indent))
        for (annotation in annotations) {
            appendLine(DebugSymbolRenderer().renderAnnotationApplication(analysisSession, annotation).indented(indent = indent + 2))
            if (currentMetaAnnotations != null) {
                val classId = annotation.classId ?: continue

        TestDomainObject value2 = new TestDomainObject('a')
        repository.put('class1', value1)
        repository.put('class2', value2)
        Closure cl = Mock()

        when:
        repository.each(cl)

        then:
        1 * cl.call(['class1', value1] as Object[])
        1 * cl.call(['class2', value2] as Object[])
        0 * cl._
    }

    def canIterateOverClassesUsingAction() {

        }

        public void onOutput(long classId, TestOutputEvent outputEvent) {
            onOutput(classId, 0, outputEvent);
        }

        public void onOutput(long classId, long testId, TestOutputEvent outputEvent) {
            boolean stdout = outputEvent.getDestination() == TestOutputEvent.Destination.StdOut;
            mark(classId, testId, stdout);

            output.writeBoolean(stdout);

`output.classesDirs` — (read-only) link:{javadocPath}/org/gradle/api/file/FileCollection.html[FileCollection]::
_Default value_: `layout.buildDirectory.dir("classes/java/$name")`, e.g. _build/classes/java/main_
+
The directories to generate the classes of this source set into. May contain directories for other JVM languages, e.g. _build/classes/kotlin/main_.

Secondary variants (*)
    - Variant : classes
       - Attributes
          - org.gradle.category            = library
          - org.gradle.dependency.bundling = external
          - org.gradle.jvm.version         = 11
          - org.gradle.libraryelements     = classes
          - org.gradle.usage               = java-api
       - Artifacts
          - build/classes/java/main (artifactType = java-classes-directory)

        when:
        def p = path('lib.jar', 'module.jar', 'classes', 'classes-module', 'automaticModule.jar')

        then:
        inferClasspath(p) == ['lib.jar', 'classes']
        inferModulePath(p) == ['module.jar', 'classes-module', 'automaticModule.jar']
        inferClasspath(p) == ['lib.jar', 'classes']
        inferModulePath(p) == ['module.jar', 'classes-module', 'automaticModule.jar']