import org.gradle.util.GradleVersion

class AcceptedApiChanges {

    GradleVersion baseVersion
    Map<ApiChange, String> acceptedChanges

    static AcceptedApiChanges parse(String jsonText) {
        def acceptedApiChanges = new AcceptedApiChanges()
        def json = new Gson().fromJson(jsonText, new TypeToken<Map<String, List<AcceptedApiChange>>>() {}.type)

                    acceptedApiChanges: acceptedChangesMap,
                    publicApiPatterns: includedClasses.get(),
                    apiChangesJsonFile: apiChangesJsonFilePath,
                    projectRootDir: projectRootDirPath
                ])
                addRule(MethodsRemovedInInternalSuperClassRule, [
                    acceptedApiChanges: acceptedChangesMap,

import spock.lang.Specification

class AcceptedApiChangesTest extends Specification {

    def "parses accepted change"() {
        when:
        def changes = AcceptedApiChanges.parse("""
            {
                "acceptedApiChanges": [
                    {
                        "type": "org.gradle.api.initialization.ConfigurableIncludedBuild",

import java.util.Set;

public class AcceptedRegressionsRuleSetup implements SetupRule {

    private final Set<ApiChange> acceptedApiChanges;

    public AcceptedRegressionsRuleSetup(Map<String, String> acceptedApiChanges) {
        this.acceptedApiChanges = AcceptedApiChanges.fromAcceptedChangesMap(acceptedApiChanges).keySet();
    }

    @Override
    @SuppressWarnings("unchecked")
    public void execute(ViolationCheckContext context) {

    private final Map<ApiChange, String> acceptedApiChanges
    private final File apiChangesJsonFile
    private final File projectRootDir

    AbstractGradleViolationRule(Map<String, Object> params) {
        Map<String, String> acceptedApiChanges = (Map<String, String>)params.get("acceptedApiChanges")
        this.acceptedApiChanges = acceptedApiChanges ? AcceptedApiChanges.fromAcceptedChangesMap(acceptedApiChanges) : [:]

    @Test
    fun `verify misordered changes can be sorted`() {
        //language=JSON
        acceptedApiChangesFile.writeText(
            """
                {
                    "acceptedApiChanges": [
                        {
                            "type": "org.gradle.api.file.SourceDirectorySet",
                            "member": "Method org.gradle.api.file.SourceDirectorySet.getOutputDir()",

    public void execute(ViolationCheckContextWithViolations context) {
        Set<ApiChange> acceptedApiChanges = (Set<ApiChange>) context.getUserData().get("acceptedApiChanges");
        Set<ApiChange> seenApiChanges = (Set<ApiChange>) context.getUserData().get("seenApiChanges");
        Set<ApiChange> left = new HashSet<>(acceptedApiChanges);
        left.removeAll(seenApiChanges);
        if (!left.isEmpty()) {

    protected
    fun loadChanges(): List<AcceptedApiChange> {
        val jsonString = apiChangesFile.get().asFile.readText()
        val json = Gson().fromJson(jsonString, AcceptedApiChanges::class.java)
        return json.acceptedApiChanges!!
    }

    /**
     * Sorts the given list of [AcceptedApiChange]s by type and member.
     * <p>

                    // Filtering an array is NOT in place
                    result.acceptedApiChanges = result.acceptedApiChanges.filter((item, pos, ary) => (!pos || (JSON.stringify(item) != JSON.stringify(ary[pos - 1]))));
                    return result;
                }

                function acceptAllErrorCorrections() {

        then:
        jsonFile.text == nonExistentAcceptedApiChanges()
    }

    static String existingAcceptedApiChanges() {
        """
            {
                "acceptedApiChanges": [
                    {
                        "type": "org.gradle.api.plugins.quality.Checkstyle",
                        "member": "Method org.gradle.api.plugins.quality.Checkstyle.getInstantiator()",