assert maxPriority2Violations == 0
                    assert maxPriority3Violations == 0
                    assert reports.enabled*.name == ["html"]
                    assert reports.html.outputLocation.asFile.get() == project.file("build/reports/codenarc/${sourceSet.name}.html")
                    assert ignoreFailures == false
                }
            }

        def transitiveIntegTestResults = new HtmlTestExecutionResult(testDirectory.file('transitive'), 'build/reports/tests/integTest')
        transitiveIntegTestResults.assertTestClassesExecuted('transitive.ModTest')

        def applicationIntegTestResults = new HtmlTestExecutionResult(testDirectory.file('application'), 'build/reports/tests/integTest')
        applicationIntegTestResults.assertTestClassesExecuted('application.DivTest')

}}
{{- range $dep, $replace := $deps }}
{{- /* Complex logic to turn the string above into a null-safe traversal like ((.Values.global).certificates */}}
{{- $res := tpl (print "{{" (repeat (split "." $dep | len) "(")  ".Values." (replace "." ")." $dep) ")}}") $}}
{{- if not (eq $res "")}}
WARNING: {{$dep|quote}} is deprecated; use {{$replace|quote}} instead.
{{- end }}
{{- end }}
{{-
  $failDeps := dict

    def setup() {
        expectReindentedValidationMessage()
        executer.beforeExecute {
            withStacktraceEnabled()
        }
    }

    def "reports task action execution fails with error"() {
        buildFile << """
            task('do-stuff').doFirst {
                throw new ArithmeticException('broken')
            }
        """
        expect:

import org.gradle.tooling.model.UnsupportedMethodException

@TargetGradleVersion('>=5.1')
class TaskDependenciesCrossVersionSpec extends ToolingApiSpecification {

    def events = ProgressEvents.create()

    def "reports task dependencies when target version supports it"() {
        given:
        buildFile << """
            task a { enabled = false }
            task b { dependsOn(a) }
            task c { dependsOn(b) }

 * limitations under the License.
 */

package org.gradle.internal.cc.impl.isolated

class IsolatedProjectsToolingApiInvocationValidationIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {
    def "reports cross project access from build script when fetching custom tooling model"() {
        given:
        settingsFile << """
            include('a')
            include('b')
        """

}

// Run generates and uploads reports
func (u *uploader) Run() error {
	if telemetry.DisabledOnPlatform {
		return nil
	}
	todo := u.findWork()
	ready, err := u.reports(&todo)
	if err != nil {
		u.logger.Printf("Error building reports: %v", err)
		return fmt.Errorf("reports failed: %v", err)
	}
	u.logger.Printf("Uploading %d reports", len(ready))
	for _, f := range ready {

import org.gradle.api.provider.Property
import org.gradle.util.internal.ToBeImplemented
import spock.lang.Issue

class IsolatedProjectsAccessFromGroovyDslIntegrationTest extends AbstractIsolatedProjectsIntegrationTest {
    def "reports problem when build script uses #block block to apply plugins to another project"() {
        createDirs("a", "b")
        settingsFile << """
            include("a")
            include("b")
        """

}

// IsInterface reports whether t is an interface type.
func IsInterface(t Type) bool {
	_, ok := under(t).(*Interface)
	return ok
}

// isNonTypeParamInterface reports whether t is an interface type but not a type parameter.
func isNonTypeParamInterface(t Type) bool {
	return !isTypeParam(t) && IsInterface(t)
}

// isTypeParam reports whether t is a type parameter.

import org.gradle.internal.declarativedsl.plugins.PluginsTopLevelReceiver
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test


class SettingsBlockCheckTest {
    @Test
    fun `reports all duplicate plugins blocks`() {
        val result = pluginsSchema.runChecks(
            """
            plugins { }
            plugins { }
            rootProject.name = "foo"
            plugins { }