assert request.getInternalJvmTestRequests().collect {[it.className, it.methodName]} == [["clazz", "method"]]
        }
    }

    def "test class requests with specific task added to test request"() {
        given:
        launcher.withTaskAndTestClasses("test", ["clazz1", "clazz2"])
        when:
        launcher.run()

        then:

        )

        when:
        def clazzA = api.classes['com.acme.A']
        def clazzB = api.classes['com.acme.B']
        def extractedA = api.extractAndLoadApiClassFrom(clazzA)
        def extractedB = api.extractAndLoadApiClassFrom(clazzB)

        then:
        hasMethod(clazzA.clazz, 'foo').modifiers == Opcodes.ACC_ABSTRACT + Opcodes.ACC_PUBLIC
        hasMethod(clazzA.clazz, 'bar').modifiers == Opcodes.ACC_PUBLIC

                    Class clazz = getClazz(classInfo);
                    if (clazz != null && clazz.getClassLoader() == classLoader) {
                        removeFromGlobalClassValue.invoke(globalClassValue, clazz);
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("Removed ClassInfo from {} loaded by {}", clazz.getName(), clazz.getClassLoader());
                        }

     *            {@link Object}クラスも反復する場合は {@literal true}
     */
    public ClassIterator(final Class<?> clazz, final boolean includeObject) {
        assertArgumentNotNull("clazz", clazz);
        assertArgument("clazz", !clazz.isInterface(), MessageFormatter.getSimpleMessage("ECL0103", clazz));

        this.clazz = clazz;
        this.includeObject = includeObject;
    }

    @Override
    public boolean hasNext() {

    public String prompt(String message, List<String> possibleValues, String defaultReply) throws PrompterException {
        try {
            Class<?> clazz = container.getContainerRealm().loadClass(PROMPTER_CLASS);
            Object instance = container.lookup(clazz);
            Method method = clazz.getMethod("prompt", String.class, List.class, String.class);
            return (String) method.invoke(instance, message, possibleValues, defaultReply);

    classes.asSequence().map { classEntryFor(it) }


fun classEntryFor(clazz: KClass<*>): Pair<String, ByteArray> =
    classEntryFor(clazz.java)


fun classEntryFor(clazz: Class<*>): Pair<String, ByteArray> {
    val classFilePath = clazz.name.replace('.', '/') + ".class"
    return classFilePath to clazz.getResource("/$classFilePath").readBytes()

        Class<?> clazz;
        try {
            clazz = classLoader.loadClass(BEACON_CLASS_NAME);
        } catch (ClassNotFoundException e) {
            clazz = CurrentGradleInstallationLocator.class;
        }
        return locateViaClass(clazz);
    }

    static CurrentGradleInstallation locateViaClass(Class<?> clazz) {
        File dir = findDistDir(clazz);
        if (dir == null) {

    def "should not return self as a constant origin class"() {
        given:
        String clazz = """
class A {
    public static final int CONSTANT = 1;
    public static final int CONSTANT2 = A.CONSTANT;

    @Annotation(A.CONSTANT)
    public final int field = A.CONSTANT;
}
"""

        when:
        compiler.compile(toSourceFile(clazz) + getAnnotation("int"))

        then:
        privateDependentToConstants["A"] == null

    private final int hash;

    SingleWeakClassSet(Class<?> clazz) {
        this.reference = new WeakReference<Class<?>>(clazz);
        this.hash = clazz.hashCode();
    }

    @Override
    public boolean equals(Object o) {
        Class<?> clazz = reference.get();
        if (clazz == null) {
            return false; // can't be equal otherwise wouldn't have been collected
        }

        private final Class<T> clazz;

        public PotentialImperativeClassPlugin(Class<T> clazz) {
            this.clazz = clazz;
        }

        @Override
        public Class<T> asClass() {
            return clazz;
        }

        @Override
        public boolean isImperative() {
            return true;
        }