ctx := genericapirequest.NewDefaultContext()
		slice := slice.DeepCopy()
		newClass := slice.DeepCopy()
		newClass.Name = "valid-class-2"
		newClass.ResourceVersion = "4"

		Strategy.PrepareForUpdate(ctx, newClass, slice)
		errs := Strategy.ValidateUpdate(ctx, newClass, slice)
		if len(errs) == 0 {
			t.Errorf("expected a validation error")
		}
	})

		ctx := genericapirequest.NewDefaultContext()
		resourceClass := resourceClass.DeepCopy()
		newClass := resourceClass.DeepCopy()
		newClass.Name = "valid-class-2"
		newClass.ResourceVersion = "4"

		Strategy.PrepareForUpdate(ctx, newClass, resourceClass)
		errs := Strategy.ValidateUpdate(ctx, newClass, resourceClass)
		if len(errs) == 0 {
			t.Errorf("expected a validation error")
		}
	})

import japicmp.filter.ClassFilter
import javassist.CtClass

import java.util.regex.Pattern

/**
 * Matches JVM anonymous classes.
 */
class AnonymousClassesFilter implements ClassFilter {

    private static final Pattern PATTERN = Pattern.compile('.*\\$[0-9]+$')

    @Override
    boolean matches(CtClass ctClass) {
        return ctClass.name.matches(PATTERN)
    }

    fun isKotlinFileFacadeClass(ctClass: CtClass): Boolean =
        if (Modifier.isPrivate(ctClass.modifiers)) false
        else queryKotlinMetadata(ctClass, false) { metadata ->
            when (metadata) {
                is KotlinClassMetadata.FileFacade -> true
                else -> false
            }
        }

    fun isKotlinInternal(ctClass: CtClass): Boolean =

        assertEquals(BooleanQuery.class, query.getClass());
        clauses = ((BooleanQuery) query).clauses();
        assertEquals(TermQuery.class, clauses.get(0).getQuery().getClass());
        assertEquals("_default:fess", clauses.get(0).getQuery().toString());
        assertEquals(Occur.MUST, clauses.get(0).getOccur());
        assertEquals(TermQuery.class, clauses.get(1).getQuery().getClass());

     */
    public fun getDirectKotlinInheritors(
        ktClass: KtClass,
        scope: GlobalSearchScope,
        includeLocalInheritors: Boolean
    ): Iterable<KtClassOrObject>

    public companion object {
        public fun getInstance(project: Project): KotlinDirectInheritorsProvider =
            project.getService(KotlinDirectInheritorsProvider::class.java)
    }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/resolver/singleByPsi/arrayAccess")
  @TestDataPath("$PROJECT_ROOT")
  public class ArrayAccess {
    @Test
    public void testAllFilesPresentInArrayAccess() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/resolver/singleByPsi/arrayAccess"), Pattern.compile("^(.+)\\.kts$"), null, true);
    }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/resolver/singleByPsi/arrayAccess")
  @TestDataPath("$PROJECT_ROOT")
  public class ArrayAccess {
    @Test
    public void testAllFilesPresentInArrayAccess() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/resolver/singleByPsi/arrayAccess"), Pattern.compile("^(.+)\\.kts$"), null, true);
    }

            getClass().classLoader.loadClass('${plugin2ClassName}')
            println "buildSrc settings: plugin 2 visible"
        """

        file("buildSrc/build.gradle") << """
            getClass().classLoader.loadClass('${plugin1ClassName}')
            println "buildSrc: plugin 1 visible"
            getClass().classLoader.loadClass('${plugin2ClassName}')
            println "buildSrc: plugin 2 visible"
        """

    }

    protected Violation checkSuperClassChanges(JApiClass c, CtClass oldClass, CtClass newClass) {
        Set<CtMethod> oldMethods = collectAllPublicApiMethods(oldClass.superclass)
        Set<CtMethod> newMethods = collectAllPublicApiMethods(newClass.superclass)

        oldMethods.removeAll(newMethods)

        if (oldMethods.isEmpty()) {
            return null
        }