String value();
                }
            '''
        ])

        when:
        def clazz = api.classes.A
        def annotations = clazz.clazz.annotations
        def annClazz = api.classes.Ann
        def subAnnClazz = api.classes.SubAnn

        api.extractAndLoadApiClassFrom(subAnnClazz)
        def extractedAnn = api.extractAndLoadApiClassFrom(annClazz)

		// use just this size instead of having two
		// different sizes.
		if len(classes) > 1 && npages == classes[len(classes)-1].npages && allocsize/size == allocsize/classes[len(classes)-1].size {
			classes[len(classes)-1].size = size
			continue
		}
		classes = append(classes, class{size: size, npages: npages})
	}

	// Increase object sizes if we can fit the same number of larger objects

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*

public object KotlinEmptyDeclarationProvider : KotlinDeclarationProvider() {
    override fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration? = null
    override fun getAllClassesByClassId(classId: ClassId): List<KtClassOrObject> = emptyList()

                        attributes { it.attribute(artifactType, 'classes') }
                    }
                    inputs.files view.files
                    doLast {
                        assert view.files.collect { it.name } == ['lib.classes', 'lib-util.classes', 'ui.classes', 'some-classes-1.0.classes']

    }

    void writeAllOutput(long classId, TestOutputEvent.Destination destination, Writer writer) {
        doWrite(classId, 0, true, destination, writer)
    }

    void writeNonTestOutput(long classId, TestOutputEvent.Destination destination, Writer writer) {
        doWrite(classId, 0, false, destination, writer)
    }

    @Override
    public void writeNonTestOutput(long classId, TestOutputEvent.Destination destination, Writer writer) {
        for (DelegateProvider delegateProvider : classOutputProviders.get(classId)) {
            delegateProvider.provider.writeNonTestOutput(delegateProvider.id, destination, writer);
        }
    }

    @Override

        annotation.classes() == [] as Class[]
    }

    def "loads class annotated with transformer class"() {
        expect:
        def cl = loader.loadClass(WithClassSpecified.name)
        def annotation = cl.getAnnotation(classAnnotation)
        annotation.value() == [Transformer.name] as String[]
        annotation.classes() == [] as Class[]
    }

    def "inherited constants points to original class"() {
        given:
        String clazz = """
class A {
    static final String STATIC_FINAL_FIELD = "hello";
}
class B extends A {
}
class C {
    static final String STATIC_FINAL_FIELD = B.STATIC_FINAL_FIELD;
}
"""
        List<File> classes = toSourceFile(clazz)

        when:
        compiler.compile(classes)

        then:

#
#Fri Jan 19 18:01:32 EST 2024
classes\ that\ are\ Gradle\ public\ API\ should\ have\ accessors\ with\ symmetrical\ @Nullable\ annotations=public-api-symmetrical-accessors-nullability.txt
classes\ that\ are\ Gradle\ public\ API\ should\ not\ have\ direct\ super-class\ or\ interface\ that\ are\ Gradle\ Internal\ API=public-api-not-extends-internal-types.txt

    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return hasAnnotation(firSymbol, classId, useSiteSession)
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return annotationsByClassId(firSymbol, classId, builder)
    }

    override val classIds: Collection<ClassId>
        get() = withValidityAssertion {