print "// tag::notable-breaking-changes[]\n"
        }

        print "[discrete]\n"
        print "[[breaking_${majorMinor}_${ area.toLowerCase().replaceAll("[^a-z0-9]+", "_") }]]\n"
        print "==== ${area}\n"

        for (breaking in breakingChanges) { %>
[[${ breaking.anchor }]]
.${breaking.title}
[%collapsible]
====
*Details* +
${breaking.details.trim()}

*Impact* +

                }
            """
        ) {
            assertHasErrors(
                "Field nonFinalField: Nullability breaking change.",
                "Field finalField: From non-nullable to nullable breaking change.",
                "Method com.example.Source.foo(): From non-null returning to null returning breaking change."
            )
            assertHasNoWarning()
            assertHasNoInformation()
        }
    }

                }
            """
        ) {
            assertHasErrors(
                "Field nonFinalField: Nullability breaking change.",
                "Field finalField: From non-nullable to nullable breaking change.",
                "Method com.example.Source.foo(): From non-null returning to null returning breaking change."
            )
            assertHasNoWarning()
            assertHasNoInformation()
        }
    }

                return false;
            }
            Breaking breaking = (Breaking) o;
            return notable == breaking.notable
                && Objects.equals(area, breaking.area)
                && Objects.equals(title, breaking.title)
                && Objects.equals(details, breaking.details)
                && Objects.equals(impact, breaking.impact);
        }

        @Override

                "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.",
                "Method com.example.Source.getSomeVar(): From non-null returning to null returning breaking change."
            )
            assertHasWarnings(

                "Method com.example.Source.baz(): From non-null returning to null-unmarked returning breaking change.",
            )
            assertHasNoWarning()
            assertHasNoInformation()
        }
    }

    @Test
    fun `from null-unmarked returning to non-null returning is not breaking`() {

        checkBinaryCompatibleJava(

                "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.",
                "Method com.example.SourceKt.invoke(java.lang.String,int): Breaking Kotlin modifier change.",
                "Method com.example.SourceKt.invoke(long,int): Breaking Kotlin modifier change.",

            "TLS",
            "Task Management",
            "Transform"
          ]
        },
        "type": {
          "type": "string",
          "enum": [
            "breaking",
            "breaking-java",
            "bug",
            "deprecation",
            "enhancement",
            "feature",
            "known-issue",
            "new-aggregation",
            "regression",

     */
    private static final Map<String, String> TYPE_LABELS = new HashMap<>();

    static {
        TYPE_LABELS.put("breaking", "Breaking changes");
        TYPE_LABELS.put("breaking-java", "Breaking Java changes");
        TYPE_LABELS.put("bug", "Bug fixes");
        TYPE_LABELS.put("deprecation", "Deprecations");
        TYPE_LABELS.put("enhancement", "Enhancements");

                    );
                }
            }

            if ((type.equals("breaking") || type.equals("breaking-java")) && entry.getBreaking() == null) {
                throw new GradleException(
                    "[" + path + "] has type [" + type + "] and must supply a [breaking] section with further information"
                );
            }