'one/ignore',
            'one/sub/ignore',
            'two/ignore'
        )
        def it = file('dest/root.renamed_twice').readLines().iterator()
        it.next().equals('[prefix: line 1]')
        it.next().equals('[prefix: line 2]')
    }

    def "copy from location specified lazily using Groovy closure"() {
        given:
        file('files/a.txt').createFile()

- Method foo() is not a valid method: Default interface methods are only supported for getters and setters."""
    }

    def "two views of the same element are equal"() {
        when:
        buildScript '''
            @Managed
            interface Address {
                String getCity()
                void setCity(String name)
            }

        IllegalStateException e = thrown(IllegalStateException)
        e.message == "Cycles between nested beans are not allowed. Cycle detected between: '<root>' and 'nested.left'."
    }

    def "nested beans can be equal"() {
        def task = project.tasks.create("myTask", TaskWithNestedObject)
        task.nested = new Tree(value: "root", right: new Tree(value: "right", right: new Tree(value: "right")))

        when:

import spock.lang.Specification

class DefaultProblemDefinitionReport extends Specification {
    def "equal objects are equal"() {
        when:
        def pd1 = createProblemDefinition()
        def pd2 = createProblemDefinition()

        then:
        pd1 == pd2
        pd1 == pd1
    }

    def "Changed label causes equal to be false"() {

        when:
        def pd1 = createProblemDefinition()

    }

    def "method and property scopes with the same name are not equal"() {
        when:
        InterceptScope methodScope = InterceptScope.methodsNamed("name")
        InterceptScope propertyScope = InterceptScope.readsOfPropertiesNamed("name")

        then:
        methodScope != propertyScope
    }

    def "constructor scopes of the same class are equal"() {
        expect:

    def "has useful string representation"() {
        expect:
        new OpaqueComponentArtifactIdentifier(new File("thing")).toString() == "thing"
    }

    def "identifiers are equal when display names are equal"() {
        def id = new OpaqueComponentArtifactIdentifier(new File("one"))
        def sameId = new OpaqueComponentArtifactIdentifier(new File("one"))

            mixedMethods
                    .assertTestCaseStdout("passing", equalTo("out.pass\n"))
                    .assertTestCaseStderr("passing", equalTo("err.pass\n"))
                    .assertTestCaseStdout("failing", equalTo("out.fail\n"))
                    .assertTestCaseStderr("failing", equalTo("err.fail\n"))
                    .assertTestCaseStdout("passing2", equalTo("out.pass2\n"))

        expect:
        address.displayName == "[${uuid} port:1234, addresses:[/1.1.1.1]]"
        address.toString() == address.displayName
    }

    def "addresses are equal when their canonical id and port and candidate addresses are equal"() {
        InetAddress address1 = InetAddress.getByName("1.1.1.1")
        InetAddress address2 = InetAddress.getByName("1.0.0.1")
        UUID id = UUID.randomUUID()

            assertThat(******@****.***(), CoreMatchers.not(CoreMatchers.equalTo('')))
            assertThat(******@****.***(), CoreMatchers.not(CoreMatchers.equalTo('')))
            assertThat(******@****.***(), CoreMatchers.not(CoreMatchers.equalTo('')))
            assertThat(******@****.***(), CoreMatchers.not(CoreMatchers.equalTo('')))

import org.junit.Test

import static org.hamcrest.CoreMatchers.equalTo
import static org.hamcrest.MatcherAssert.assertThat

class LineFilterTest {
    @Test void testEmptyInput() {
        def input = new StringReader("")
        def lineCount = 1
        def filter = new LineFilter(input, { "${lineCount++} - $it" as String })

        assertThat(filter.text, equalTo(""))
    }

    @Test void testEmptyLinesWithTrailingEOL() {