executer.commandLine = "build/install/test/bin/test"
        def result = executer.run()
        then:
        result.assertNormalExitValue()
        out.toString() == TextUtil.toPlatformLineSeparators("all good\n")
    }

    @Requires(UnitTestPreconditions.Jdk9OrLater)
    def "can configure using project extension for main class and main module"() {
        settingsFile << """

        when:
        realizeNodeOfType(ManagedWithInvalidModelMap)

        then:
        def ex = thrown(ModelRuleExecutionException)
        ex.cause.message == TextUtil.toPlatformLineSeparators("""A model element of type: '${fullyQualifiedNameOf(ManagedWithInvalidModelMap)}' can not be constructed.
Its property 'org.gradle.model.ModelMap<java.io.FileInputStream> map' is not a valid managed collection

import org.gradle.util.AttributeTestUtil
import spock.lang.Specification

import static org.gradle.api.artifacts.type.ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE
import static org.gradle.util.internal.TextUtil.toPlatformLineSeparators

class DefaultArtifactVariantSelectorFactoryTest extends Specification {
    def matchingCache = Mock(ConsumerProvidedVariantFinder)
    def producerSchema = Mock(AttributesSchemaInternal)

        "none"                            | "none"
        "one\rtwo\nthree\r\nfour\n\rfive" | "one${sep}two${sep}three${sep}four${sep}${sep}five"
    }

    def toPlatformLineSeparators() {
        expect:
        TextUtil.toPlatformLineSeparators(original) == converted

        where:
        original                          | converted
        ""                                | ""

import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Issue
import spock.lang.Specification

import static org.gradle.util.internal.TextUtil.toPlatformLineSeparators

class FileOrUriNotationConverterTest extends Specification {

    @Rule public TestNameTestDirectoryProvider folder = new TestNameTestDirectoryProvider(getClass());

    def "with File returns this File"() {

        }
        def locations = ["http://somewhere", "sftp://elsewhere"]
        def exception = new ArtifactNotFoundException(artifactId, locations)

        expect:
        exception.message == TextUtil.toPlatformLineSeparators("""Could not find <artifact>.
Searched in the following locations:
    http://somewhere
    sftp://elsewhere""")
    }

    def "formats message when no locations attempted"() {

import org.gradle.util.TestUtil
import spock.lang.Specification
import spock.lang.Unroll

import static com.google.common.collect.ImmutableList.copyOf
import static org.gradle.util.internal.TextUtil.toPlatformLineSeparators

class LocalComponentDependencyMetadataTest extends Specification {
    AttributesSchemaInternal attributesSchema = new DefaultAttributesSchema(TestUtil.instantiatorFactory(), SnapshotTestUtil.isolatableFactory())

        loggingSystem.restore(snapshot)
        capturing.println("info-1")
        stream.println('info-2')

        then:
        stream == originalStream
        original.toString() == TextUtil.toPlatformLineSeparators('''info-1
info-2
''')
        0 * listener._
    }

    def restoreStopsCapturingWhenCapturingWasOffWhenSnapshotTaken() {
        def off = loggingSystem.snapshot()

        registry.add(generator("desc3"))

        when:
        registry.get("unknown")

        then:
        def e = thrown(GradleException)
        e.message == TextUtil.toPlatformLineSeparators("""The requested build type 'unknown' is not supported. Supported types:
  - 'default'
  - 'desc1'
  - 'desc2'
  - 'desc3'
  - 'maven'""")
    }

    BuildGenerator generator(String id) {

                        .immutableInput(UnboundRuleInput.type(Number).bound().path("parent.p6")).build()
        ])

        then:
        output.toString() == TextUtil.toPlatformLineSeparators("""> r1
>   subject:
>     - parent.p1 String [*]
>     - <no path> String [*]
>         scope: some.scope
>     - parent.p3 Integer
>   inputs:
>     - parent.p4 Number [*]