}
        }
        return urls;
    }

    public JavaClass plus(JavaClass other) {
        if (files.isEmpty()) {
            return other;
        }
        if (other.isEmpty()) {
            return this;
        }
        return new JavaClass(concat(files, other.getAsFiles()));
    }

    public JavaClass plus(Collection<File> other) {
        if (other.isEmpty()) {
            return this;

package org.gradle.test;

/**
 * This is a java class.
 */
public class JavaClass extends A implements CombinedInterface, JavaInterface {
    /**
     * A read-only property.
     */
    public String getReadOnly() {
        return "value";
    }

    /**
     * An ignored field.
     */
    String ignoreMe1;

    /**
     * Another ignored field.
     */
    final long ignoreMe2 = 9;

    /**

    /**
     * [javaClass] is used to defer some properties to the compiler's view of a Java class.
     */
    private val javaClass: JavaClass = JavaClassImpl(JavaElementSourceFactory.getInstance(analysisSession.project).createPsiSource(psi))

    override val name: Name = withValidityAssertion { javaClass.name }

    override val classId: ClassId = withValidityAssertion {

    private static final DescribedPredicate<JavaClass> special_classes = new DescribedPredicate<JavaClass>("special class") {
        @Override
        public boolean test(JavaClass javaClass) {
            return javaClass.isEquivalentTo(ServiceRegistry.class) || javaClass.isEquivalentTo(Factory.class);
        }
    };

        return new ArchCondition<JavaClass>(" override method " + getMethodDescription(name, parameterTypes)) {

            @Override
            public void check(JavaClass javaClass, ConditionEvents events) {
                Optional<JavaMethod> method = getMethodRecursively(javaClass);
                if (method.isPresent()) {

    private static boolean isInIgnoredPackage(JavaClass javaClass) {
        return IGNORED_PACKAGES_FOR_CYCLES.test(javaClass.getPackageName());
    }

    private static boolean isIgnoredClass(JavaClass javaClass) {
        return javaClass.isAnnotation() || IGNORED_CLASSES_FOR_CYCLES.stream().anyMatch(prefix -> javaClass.getFullName().startsWith(prefix));
    }

        MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry();

        MetaClass originalMetaClass = metaClassRegistry.getMetaClass(javaClass);
        if (!(originalMetaClass instanceof CallInterceptingMetaClass)) {
            metaClassRegistry.setMetaClass(javaClass, interceptedMetaClass(javaClass, metaClassRegistry, originalMetaClass, resolver));
        }
    }

        file('src/org/gradle/main/JavaClass.java') << 'package org.gradle; public class JavaClass { }'
        file('src/org/gradle/test/JavaClassTest.java') << 'package org.gradle; class JavaClassTest { JavaClass c = new JavaClass(); @org.junit.jupiter.api.Test public void test() { } }'
        file('src/java/org/gradle/main/JavaClass2.java') << 'package org.gradle; class JavaClass2 { }'

        JavaClass javaClass = new ClassFileImporter().importClass(clazz);
        CollectingConditionEvents events = new CollectingConditionEvents();
        archCondition.check(javaClass, events);
        assertThat(events.getAllEvents()).hasSize(1);
        return events.getAllEvents().iterator().next();
    }

    @Nonnull

            .because(RATIONALE);


    public static ArchCondition<JavaClass> callMethodWithName(String ownerName, String methodName) {
        return callMethodWhere(JavaCall.Predicates.target(HasOwner.Predicates.With.<JavaClass>owner(name(ownerName)))
            .and(JavaCall.Predicates.target(name(methodName))))