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

    <target name="cleanAll">
        <delete dir="${build.dir}"/>
    </target>

    <target name="prepare">
        <tstamp>
            <format property="now" pattern="yyyy-MM-dd hh:mm:ss"/>
        </tstamp>
    </target>

    <target name="build" depends="prepare">
        <mkdir dir="${classes.dir}"/>

    <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"/>  <!--1-->
    </target>
    <!-- end::build-required[] -->

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

               }
            }
        """

        when:
        def outer = api.classes.A
        def inner = api.classes['A$Inner']
        def extractedOuter = api.extractAndLoadApiClassFrom(outer)

        then:
        !api.isApiClassExtractedFrom(inner)
        extractedOuter.classes.length == 0

        where:
        modifier | _
        ''       | _
        'static' | _
    }

                    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)

		// objects into the page, we might as well
		// 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

                        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']

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

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

#
#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

        return value;
    }
}
"""
        List<File> classes = toSourceFile(clazz) + getConstants("int", "1")

        when:
        compiler.compile(classes)

        then:
        privateDependentToConstants["A"] == ["Constant1"] as Set
        accessibleDependentToConstants.isEmpty()
    }

    def "collect constants from inner classes"() {
        given:
        String clazz = """
class OuterClass {

| <<<javadoc>>>         | <<<javadoc>>> | <<<jar>>>  | java      | classes               |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<test-jar>>>        | <<<tests>>>   | <<<jar>>>  | java      | classes, patch module |                       |