!spec.isSatisfiedBy(GradleVersion.version("1.5"))
        !spec.isSatisfiedBy(GradleVersion.version("1.5-rc-1"))
        !spec.isSatisfiedBy(GradleVersion.version("12.45"))
    }

    def "equals version constraint matches versions with same base version"() {
        def spec = new GradleVersionSpec().toSpec("=1.4")

        expect:
        spec.isSatisfiedBy(GradleVersion.version("1.4"))

                .assertTestFailed("encodesAttributeValues", equalTo('java.lang.RuntimeException: html: <> cdata: ]]>'))
                .assertStdout(containsString(
                    "< html allowed, cdata closing token ]]> encoded!\n" +
                    "no EOL, non-asci char: ż\n" +
                    "xml entity: &amp;"
                ))
                .assertStderr(equalTo("< html allowed, cdata closing token ]]> encoded!\n"))
    }

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()

        obj.empty
    }

    def canConfigureObjectUsingClosure() {
        given:
        List obj = []
        def cl = {
            add('a');
            assertThat(size(), equalTo(1));
            assertThat(obj, equalTo(['a']))
        }

        when:
        ConfigureUtil.configure(cl, obj)

        then:
        obj == ['a']
    }

    def passesConfiguredObjectToClosureAsParameter() {

import org.apache.commons.compress.archivers.zip.ZipFile
import org.gradle.test.fixtures.file.TestFile

import java.nio.charset.Charset

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

class ZipTestFixture extends ArchiveTestFixture {
    protected final String metadataCharset
    protected final String contentCharset

        def windowsLineEndings = scriptText.split(TextUtil.windowsLineSeparator).length

        // Windows line endings are made up of two characters,
        // we should see an equal number of lines unless
        // the generator is using the wrong line ending entirely
        // or has generated some lines with one or the other character
        carriageLineEndings == newlineEndings

        and:
        files == conf.allArtifacts.files as Set
    }

    void "knows when content is equal"() {
        def d1 = createProjectDependency()
        def d2 = createProjectDependency()

        expect:
        d1.contentEquals(d2)
    }

    void "knows when content is not equal"() {
        def d1 = createProjectDependency()
        def d2 = createProjectDependency()

        1 * client2.stop()
        0 * client3.stop()

        and:
        reserveIdleClient(oneGbOptions) == client3
    }

    def "expires all idle daemons when requested memory is equal than what all daemons consume"() {
        given:
        def client1 = reserveNewClient(oneGbOptions)
        def client2 = reserveNewClient(threeGbOptions)

        and:
        clientsManager.release(client1)

                }

                static void mirror(IvyArtifactRepository repo) {
                    ${mirrorConditions}
                }

                // We see them as equal:
                // https://repo.maven.apache.org/maven2/ and http://repo.maven.apache.org/maven2
                static String normalizeUrl(Object url) {

import org.gradle.internal.deprecation.Documentation
import org.gradle.internal.operations.OperationIdentifier
import spock.lang.Specification

class DefaultProblemTest extends Specification {
    def "unbound builder result is equal to original"() {
        def additionalData = Mock(AdditionalData)
        def problem = createTestProblem(severity, additionalData)

        def newProblem = problem.toBuilder().build()
        expect: