}

    static class OldSub extends OldBase {
        OldSub returnTypeOverridenMethod() { return null }
    }

    static class NewSuperInternal {}

    static class NewBase extends NewSuperInternal {}

    static class NewSub extends NewBase {}

    Map classes = [:]

    def setup() {
        rule = new MethodsRemovedInInternalSuperClassRule(getInitializationParams())
        rule.context = context

import java.util.regex.Pattern;

import static gradlebuild.binarycompatibility.rules.SinceAnnotationRule.SINCE_ERROR_MESSAGE;
import static japicmp.model.JApiCompatibilityChangeType.METHOD_ADDED_TO_INTERFACE;
import static japicmp.model.JApiCompatibilityChangeType.METHOD_ADDED_TO_PUBLIC_CLASS;
import static japicmp.model.JApiCompatibilityChangeType.METHOD_NEW_DEFAULT;
import static japicmp.model.JApiCompatibilityChangeType.METHOD_REMOVED;

    }

    private static boolean isAnnotatedWithDeprecated(JApiHasAnnotations member) {
        member.annotations*.fullyQualifiedName.any { it == Deprecated.name || it == kotlin.Deprecated.name }
    }

    private static boolean isAnnotatedWithInject(JApiHasAnnotations member) {
        member.annotations*.fullyQualifiedName.any { it == Inject.name }
    }

    protected static boolean isInject(JApiHasAnnotations member) {

    static_dir.rmdir()


def test_static_files(client: TestClient):
    response = client.get("/static/sample.txt")
    assert response.status_code == 200, response.text
    assert response.text == "This is a sample static file."


def test_static_files_not_found(client: TestClient):
    response = client.get("/static/non_existent_file.txt")
    assert response.status_code == 404, response.text

    IncubatingInternalInterfaceAddedRule rule

    static class OldSuper {}

    static class OldBase extends OldSuper {}

    static class NewSuper {}

    static class NewBase extends NewSuper {}

    @Incubating
    static class NewIncubatingBase extends NewSuper {}

    @Incubating
    interface IncubatingInterface {}

import java.util.Map;

public class SinceAnnotationRule extends AbstractGradleViolationRule {

    public static final String SINCE_ERROR_MESSAGE = "Is not annotated with @since ";
    public static final String SINCE_MISMATCH_ERROR_MESSAGE = "Has invalid @since: it should be %s, but currently is %s";
    public static final String SINCE_INCONSISTENT_ERROR_MESSAGE = "Has inconsistent @since: %s";

import me.champeau.gradle.japicmp.report.Violation;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class BinaryBreakingChangesRule extends AbstractGradleViolationRule {

    private static final List<JApiCompatibilityChangeType> IGNORED_CHANGE_TYPES = ImmutableList.of(
        JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS, // the removal of the method will be reported

import japicmp.model.JApiClass
import japicmp.model.JApiCompatibility
import javassist.CtClass
import javassist.CtMethod
import javassist.Modifier
import me.champeau.gradle.japicmp.report.Violation

import static japicmp.model.JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS

class MethodsRemovedInInternalSuperClassRule extends AbstractSuperClassChangesRule {

import org.gradle.api.Action
import org.gradle.api.Project
import org.gradle.api.file.Directory
import org.gradle.api.file.FileCollection

class BinaryCompatibilityHelper {
    static setupJApiCmpRichReportRules(
        JapicmpTask japicmpTask,
        Project project,
        Directory acceptedViolationsDir,
        FileCollection sourceRoots,
        String currentVersion,

    jsonFileDirectory = apiChangesJsonDirectory
}

static List<String> toPatterns(List<String> packages) {
    packages.collect {
        it.replaceAll('\\*\\*', '###')
            .replaceAll('/\\*', '/[A-Z][a-z_A-Z0-9]+')
            .replaceAll('$', '\\$')
            .replaceAll('/', '[.]')
            .replaceAll('###', '.*?')
    }
}

static String writeFilterPreset(Project project) {