sb.append("ERROR: " + file.getName() + ":" + error.lineNumber + " " + error.message + "\n    " + error.line + "\n");
                }
                String message = sb.toString();
                getLogger().error(message);
                fw.println(message);
            }
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }

        assertFalse(richReport.toAssertionMessage("Expected to be breaking but the check passed"), isBinaryCompatible)
    }

    private
    fun RichReport.toAssertionMessage(message: String) =
        if (isEmpty) "$message with an empty report"
        else "$message\n${toText().prependIndent("    ")}"

    private
    fun runKotlinBinaryCompatibilityCheck(v1: String, v2: String, block: CheckResult.() -> Unit = {}): CheckResult =

package gradlebuild.docs.dsl.docbook;

import gradlebuild.docs.DocGenerationException;

public class ClassDocGenerationException extends DocGenerationException {
    public ClassDocGenerationException(String message, Throwable throwable) {
        super(message, throwable);
    }

          days-before-issue-stale: 14
          stale-issue-label: to-triage
          stale-issue-message: ""
          days-before-issue-close: -1

          only-pr-labels: 'from:contributor'
          exempt-all-pr-milestones: true
          days-before-pr-stale: 14
          stale-pr-label: to-triage
          stale-pr-message: ""

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

import java.util.Map;

public class SinceAnnotationMissingRule extends AbstractGradleViolationRule {

    public static final String SINCE_ERROR_MESSAGE = "Is not annotated with @since ";

    public SinceAnnotationMissingRule(Map<String, Object> params) {
        super(params);
    }

    @Override
    public Violation maybeViolation(final JApiCompatibility member) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gradlebuild.docs.dsl.docbook;

public interface GenerationListener {
    void warning(String message);

    void start(String context);

    void finish();

# Development best practices

This is a collection of best practices for Gradle implementation.
Should and should not do's.

## Error messages and suggestions

Traditionally, if an error occurred, the error message and the possible solution were provided to the console via a single String in the corresponding exception.
That meant possible solutions for Problems could be scattered all over the console output.

 * limitations under the License.
 */

package gradlebuild.basics.classanalysis

import org.gradle.internal.exceptions.Contextual


@Contextual

import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoots
import org.jetbrains.kotlin.cli.common.messages.MessageCollector
import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment

                .text().substringBefore(" If you did this intentionally"),
            entry.select("ul li")
                .map { it.text() }

        )
    }


internal
data class ReportMessage(
    val message: String,
    val details: List<String>
)


internal
data class RichReport(
    val errors: List<ReportMessage>,
    val warnings: List<ReportMessage>,
    val information: List<ReportMessage>,