public String @Nullable [] foo() { return new String[] {"some", null}; }
                }
            """
        ) {
            assertHasErrors(
                "Field nonFinalField: Nullability breaking change.",
                "Field finalField: From non-nullable to nullable breaking change.",

                    @Nullable public final String finalField = null;
                    @Nullable public String foo() { return "bar"; }
                }
            """
        ) {
            assertHasErrors(
                "Field nonFinalField: Nullability breaking change.",
                "Field finalField: From non-nullable to nullable breaking change.",

                    public @$nullUnmarkedAnnotationName String[] baz() { return new String[] {"some", null}; }
                }
            """
        ) {
            assertHasErrors(
                "Method com.example.Source.foo(): From non-null returning to null-unmarked returning breaking change.",

           $publicKotlinMembers

            const val cathedral = "cathedral"

            """
        ) {

            assertHasNoInformation()
            assertHasNoWarning()
            assertHasErrors(

                // Kotlin file-facade classes are ignored by the @since rule
                listOf("Class com.example.SourceKt: Is not annotated with @Incubating."),

                added("Field", "cathedral"),

        }

        fun assertHasErrors(vararg errors: List<String>) {
            assertHasErrors(*errors.toList().flatten().toTypedArray())
        }

        fun assertHasErrors(vararg errorWithDetail: Pair<String, List<String>>) {

                    val someVal: String? = null
                    var someVar: String? = null
                    fun foo(): String? = null
                }
            """
        ) {
            assertHasErrors(
                "Method com.example.Source.foo(): From non-null returning to null returning breaking change.",
                "Method com.example.Source.getSomeVal(): From non-null returning to null returning breaking change.",

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

        checkNotBinaryCompatibleKotlin(
            v1 = internalSource,
            v2 = publicSource
        ).apply {
            assertHasErrors(
                *reportedMembers.map {
                    added(it.first, it.second)
                }.toTypedArray()
            )
            assertHasNoWarning()
            assertHasNoInformation()

                    operator fun String.plus(some: List<Int>): String
                    infix fun Int.plus(some: List<Int>): Int
                }
            """
        ) {
            assertHasErrors(
                "Method com.example.Source.plus(java.lang.String,java.util.List): Breaking Kotlin modifier change.",
                "Method com.example.Source.plus(int,java.util.List): Breaking Kotlin modifier change.",

                            public abstract Property<String> getSourceCompatibility();
                        }
                    """
                )
            }
        ) {
            assertHasErrors(
                "Method com.example.Task.getSourceCompatibility(): Is not binary compatible." to listOf("Method return type has changed", "Method is now abstract"),