/**
 * Checks if entity has annotation with specified [classId].
 *
 * @see [KaAnnotationList.contains]
 */
@Deprecated("Use 'annotations' instead.", replaceWith = ReplaceWith("classId in annotations"))
public fun KaAnnotated.hasAnnotation(classId: ClassId): Boolean {
    return annotations.contains(classId)
}

/**
 * A list of annotations applied with specified [classId].
 *
 * @see [KaAnnotationList.classIds]
 */

            doLast {
                def classes = configurations.compile.outgoing.variants['classes']
                classes.attributes.attribute(format, 'classes2')
            }
        }
        task mutateAfterResolve {
            doLast {
                configurations.compile.resolve()
                def classes = configurations.compile.outgoing.variants['classes']
                classes.attributes.attribute(format, 'classes-dir')

                    Class[] dup = new Class[classes.length * 2]
                    System.arraycopy(classes, 0, dup, 0, classes.length)
                    System.arraycopy(classes, 0, dup, classes.length, classes.length)
                    classes = dup
                }
                i++
            }
        } catch (OutOfMemoryError e) {
            classes = []

internal
object GradleType {

    val artifactHandler = classOf<ArtifactHandler>()

    val configurablePublishArtifact = classOf<ConfigurablePublishArtifact>()

    val dependencyConstraintHandler = classOf<DependencyConstraintHandler>()

    val dependencyConstraint = classOf<DependencyConstraint>()

    val dependencyHandler = classOf<DependencyHandler>()

    val dependency = classOf<Dependency>()

            }
        }

    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

        }

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