if (scriptText.contains("repositories")) {
            assertThat(scriptText, containsString("mavenCentral()"))
            assertThat(scriptText, containsString("Use Maven Central for resolving dependencies."))
            assertThat(scriptText, not(containsString("jcenter()")))
            assertThat(scriptText, not(containsString("Use JCenter for resolving dependencies.")))
        }
    }

import org.gradle.integtests.fixtures.DefaultTestExecutionResult
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions

import static org.hamcrest.CoreMatchers.containsString
import static org.hamcrest.CoreMatchers.equalTo

@Requires(IntegTestPreconditions.NotEmbeddedExecutor)
class SuppressedExceptionTestingIntegrationTest extends AbstractIntegrationSpec {
    def setup() {

                    id("my-plugin")
                }
            """
        )

        build("help").run {
            assertThat(output, containsString("base-plugin settings plugin applied"))
            assertThat(output, containsString("my-plugin settings plugin applied"))
        }
    }

    @Test
    @Issue("https://github.com/gradle/gradle/issues/15416")

package org.gradle.kotlin.dsl.fixtures

import org.hamcrest.CoreMatchers.containsString
import org.hamcrest.Matcher


fun containsMultiLineString(string: String): Matcher<String> =

        file("build/reports/pmd/test.xml").
            assertContents(containsClass("org.gradle.Class1Test")).
            assertContents(containsLine(containsString('AvoidMultipleUnaryOperators'))).
            assertContents(not(containsLine(containsString('OverrideBothEqualsAndHashcode'))))
    }

    def "gets reasonable message when priority level threshold is out of range from extension"() {
        goodCode()

package org.gradle.kotlin.dsl.support

import org.gradle.kotlin.dsl.fixtures.AbstractKotlinIntegrationTest
import org.hamcrest.CoreMatchers.containsString
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class ImplicitImportsTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `implicit imports are fully qualified to allow use of the preferred type amongst those with same simple name in different Gradle API packages`() {

    String getAfterClassErrorTestName() {
        return 'executionError'
    }

    @Override
    Matcher<? super String>[] getBrokenBeforeAndAfterMatchers() {
        return [allOf(containsString(failureAssertionError('before failed')), containsString(failureAssertionError('after failed')))]
    }

    @Override
    boolean hasStableInitializationErrors() {
        return true
    }

                containsString("oh noes (2 failures)"))
        result.testClass("example.Issue9487Test")
            .assertTestFailed("allCausesShouldBeCaptured",
                containsString("java.lang.AssertionError: error 1"))
        result.testClass("example.Issue9487Test")
            .assertTestFailed("allCausesShouldBeCaptured",
                containsString("java.lang.RuntimeException: error 2"))
    }

package org.gradle.model.dsl.internal.transform

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.UnsupportedWithConfigurationCache

import static org.hamcrest.CoreMatchers.containsString

@UnsupportedWithConfigurationCache(because = "software model")
class ModelDslRuleDetectionIntegrationSpec extends AbstractIntegrationSpec {

            inputs.expect(allOf(startsWith("Plugin class 'SneakyPluginA': file '${FileUtils.testFileName}'"), containsString(FileUtils.testFileName)))
            /*
            pluginClasses.forEach {
                inputs = inputs.expect(allOf(startsWith("Plugin class '$it':"), containsString(FileUtils.testFileName))))
            }*/
        }

        where:
        accessKind          | inputRead