return null
        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {
            // breaking change would be reported
            return null
        }

        return checkSuperClassChanges(member, oldClass.get(), newClass.get())
    }

    }

    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
        }

    @Incubating
    static class NewIncubatingBase extends NewSuper {}

    @Incubating
    interface IncubatingInterface {}

    interface InternalInterface {}

    interface StablePublicInterface {}

    CtClass oldBase
    CtClass newBase
    CtClass newSuper
    CtClass newIncubatingBase
    CtClass internalInterface
    CtClass incubatingInterface
    CtClass stablePublicInterface

    Map interfaces

    }

    protected Violation checkSuperClassChanges(JApiClass c, CtClass oldClass, CtClass newClass) {
        Map<String, CtClass> oldInterfaces = collectImplementedInterfaces(oldClass)
        Map<String, CtClass> newInterfaces = collectImplementedInterfaces(newClass)

        newInterfaces.keySet().removeAll(oldInterfaces.keySet())

        if (newInterfaces.isEmpty()) {

import japicmp.util.Optional
import javassist.CtClass
import me.champeau.gradle.japicmp.report.Violation

class MethodsRemovedInInternalSuperClassRuleTest extends AbstractContextAwareRuleSpecification {
    MethodsRemovedInInternalSuperClassRule rule

    static class OldSuperInternal {
        void publicMethod() {}

        private void privateMethod() {}
    }

    static class OldBase extends OldSuperInternal {

    }

    @Override
    protected Violation checkSuperClassChanges(JApiClass apiClass, CtClass oldClass, CtClass newClass) {
        return acceptOrReject(apiClass.superclass, Violation.notBinaryCompatible(apiClass.superclass))
    }

      runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/listType.kt");
    }

    @Test
    @TestMetadata("onClass.kt")
    public void testOnClass() {
      runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/onClass.kt");
    }

    @Test
    @TestMetadata("onFunction.kt")
    public void testOnFunction() {

private
val CtClassOrCtMember.declaringClass: CtClass
    get() = when (this) {
        is CtClass -> declaringClass ?: this
        is CtMember -> declaringClass
        else -> throw IllegalStateException("Unsupported javassist member type '${this::class}'")
    }


private
val CtClass.baseQualifiedKotlinName: String
    get() =
        if (isKotlinFileFacadeClass) packageName
        else name


private

	// Standard storage class environment variable
	StandardEnv = "MINIO_STORAGE_CLASS_STANDARD"
	// Optimize storage class environment variable
	OptimizeEnv = "MINIO_STORAGE_CLASS_OPTIMIZE"
	// Inline block indicates the size of the shard
	// that is considered for inlining, remember this
	// shard value is the value per drive shard it
	// will vary based on the parity that is configured
	// for the STANDARD storage_class.

Sebastián Ramírez <******@****.***> 1652485102 -0500