def "can configure logging output inclusion in xml reports"() {
        given:
        buildFile.text = buildFile.text.replace("reports.junitXml.outputPerTestCase = true", """reports.junitXml {
            outputPerTestCase = true
            $includeSystemOutConf
            $includeSystemErrConf
        }""".stripIndent())

        if (failureCount) {
            def message = "$failureCount PMD rule violations were found."
            def report = reports.isEmpty() ? null : reports.get(0)
            if (report) {
                def reportUrl = new ConsoleRenderer().asClickableFileUrl(report.outputLocation.asFile.get())
                message += " See the report at: $reportUrl"
            }

        result.assertTaskExecuted(":core:test")
        result.assertTaskExecuted(":util:test")

        and: "an aggregate report is created"
        dslDir.file("build/reports/allTests/index.html").assertExists()

        and: "no test reports in the subprojects are created"
        getStandardTestReportDir(dslDir, "core", "").file("index.html").assertDoesNotExist()

package alias

// This is the Google App Engine standard variant based on reflect
// because the unsafe package and cgo are disallowed.

import "reflect"

// AnyOverlap reports whether x and y share memory at any (not necessarily
// corresponding) index. The memory beyond the slice length is ignored.
func AnyOverlap(x, y []byte) bool {
	return len(x) > 0 && len(y) > 0 &&

func AlgType(t *Type) AlgKind {
	CalcSize(t)
	return t.alg
}

// TypeHasNoAlg reports whether t does not have any associated hash/eq
// algorithms because t, or some component of t, is marked Noalg.
func TypeHasNoAlg(t *Type) bool {
	return AlgType(t) == ANOALG
}

// IsComparable reports whether t is a comparable type.
func IsComparable(t *Type) bool {
	a := AlgType(t)
	return a != ANOEQ && a != ANOALG

            </tr>
            <tr>
                <td>reports</td>
                <td></td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>reports</td>
            </tr>
        </table>

//go:build unix

package modload

import (
	"io/fs"
	"os"
	"syscall"
)

// hasWritePerm reports whether the current user has permission to write to the
// file with the given info.
//
// Although the root user on most Unix systems can write to files even without
// permission, hasWritePerm reports false if no appropriate permission bit is
// set even if the current user is root.

        then:
        thrown(UnsupportedNotationException)
    }

    def "reports missing keys for map notation"() {
        when:
        multiParser().parseNotation([name: "bar", version: "1.0"])

        then:
        thrown(InvalidUserDataException)
    }

    def "reports wrong keys for map notation"() {
        when:

            </tr>
            <tr>
                <td>checkstyleClasspath</td>
                <td><literal>project.configurations.checkstyle</literal></td>
            </tr>
            <tr>
                <td>reports</td>
                <td></td>
            </tr>
            <tr>
                <td>javaLauncher</td>
                <td></td>
            </tr>
            <tr>
                <td>minHeapSize</td>

    def "accept error reports task path"() {
        when:
        changes.accept(Mock(ChangeVisitor))
        then:
        def ex = thrown GradleException
        ex.message == "Cannot determine changes for task ':test'"
        ex.cause.message == "Error!"
        1 * delegate.accept(_) >> { throw new RuntimeException("Error!") }
    }

    def "visitor error reports task path"() {