"""
                {
                    "acceptedApiChanges": [
                        {
                            "type": "org.gradle.api.tasks.AbstractExecTask",
                            "member": "Method org.gradle.api.tasks.AbstractExecTask.getExecResult()",
                            "acceptation": "Removed for Gradle 8.0",
                            "changes": [
                                "Method has been removed"

            $publicMembers
        }
    """

    @Test
    fun `added internal members are filtered from the comparison`() {

        checkBinaryCompatibleKotlin(
            v1 = existingSource,
            v2 = internalSource
        ).assertEmptyReport()
    }

    @Test
    fun `existing internal members made public appear as added`() {

        checkNotBinaryCompatibleKotlin(

# Disable sign-off checking for members of the Gradle GitHub organization
require:

                        "member": "Implemented interface org.gradle.api.initialization.IncludedBuild",
                        "changes": ["Interface has been removed"],
                        "acceptation": "@Incubating interface has been removed"
                    },
                    {
                        "type": "other.Type",
                        "member": "Method other.Type.someMethod",

        }

    fun isSince(version: String, member: JApiCompatibility): Boolean =
        apiSourceFileFor(member).let { apiSourceFile ->
            when (apiSourceFile) {
                is ApiSourceFile.Java -> sources.executeQuery(apiSourceFile, JavaSourceQueries.isSince(version, member))
                is ApiSourceFile.Kotlin -> sources.executeQuery(apiSourceFile, KotlinSourceQueries.isSince(version, member))
            }
        }

    private

import groovy.transform.Immutable

@Immutable
class ApiChange {
    String type
    String member
    List<String> changes

    static ApiChange parse(Object json) {
        new ApiChange(json.type, json.member, json.changes ?: [])
    }

    String toString() {
        def formattedMember = member - "$type."
        "$type - $formattedMember - $changes"
    }

        val member: String?,
        val acceptation: String?,
        val changes: List<String>?
    ) {
        override fun toString(): String = "Type: '$type', Member: '$member'"
    }

    @VisibleForTesting
    data class AcceptedApiChanges(
        val acceptedApiChanges: List<AcceptedApiChange>?
    )

  }

  @J2ktIncompatible
  @GwtIncompatible // Only used by @GwtIncompatible code
  private static class MultisetHolder implements Serializable {
    public Multiset<?> member;

    MultisetHolder(Multiset<?> multiset) {
      this.member = multiset;
    }

    private static final long serialVersionUID = 1L;
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester

    fun isSince(version: String, member: JApiCompatibility): JavaSourceQuery<Boolean> =
        member.jApiClass.simpleName.let { declaringClassSimpleName ->
            JavaSourceQuery(
                false,
                when (member) {
                    is JApiClass -> isSinceJavaClassVisitorFor(declaringClassSimpleName, version)
                    is JApiField -> isSinceJavaFieldVisitorFor(member, version)

    @Override
    public Violation maybeViolation(final JApiCompatibility member) {
        if (member instanceof JApiMethod || member instanceof JApiField || member instanceof JApiClass) {
            if (!isIncubating((JApiHasAnnotations) member)) {
                return null;
            }
            if (member instanceof JApiMethod && isOverride((JApiMethod) member)) {
                return null;
            }