import junit.framework.*;

            public class FooTest extends TestCase {
                public void testFail() {
                    assertEquals("String are not equal:", "foo", "bar");
                }
            }
        """

        when:
        runTestTaskWithFailureCollection()

        then:
        thrown(BuildException)

        1 * factory.create() >> null
    }

    def "is unchanged if everything is equal"() {
        given:
        configureMetadata(local)
        configureMetadataForEtagMatch(remote)

        when:
        compare(local, remote)

        then:
        unchanged
    }

    def "matching etags are enough to be considered equal"() {
        given:
        configureMetadata(local, "abc", null, -1)

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:

        requiresMetadata("latest.123")
    }

    def "accepts any fixed version"() {
        expect:
        accept("latest.integration", "1.0")
    }

    def "accepts a candidate version if its status is equal to or higher than the selector's status"() {
        def metadata = Stub(ComponentMetadata) {
            getStatus() >> "silver"
            getStatusScheme() >> ["bronze", "silver", "gold"]
        }

        expect:

        where:
        version    | jreDirName    | jdkDirName
        '1.6.0'    | 'jre6'        | 'jdk1.6.0'
        '1.5.0_22' | 'jre1.5.0_22' | 'jdk1.5.0_22'
    }

    def "JVM are equal when their Java home dirs are the same"() {
        given:
        TestFile installDir = tmpDir.createDir('software')
        installDir.create {
            lib {
                file 'tools.jar'
            }

    }

    def "identical versions are equal"() {
        expect:
        compare(v1, v2) == 0
        compare(v2, v1) == 0

        where:
        v1        | v2
        ""        | ""
        "1"       | "1"
        "1.0.0"   | "1.0.0"
        "!@#%"    | "!@#%"
        "hey joe" | "hey joe"
    }

    def "versions that differ only in separators are equal"() {
        expect:

        then:
        originalClasspath.asFiles == [a, b]
        newClasspath.is(originalClasspath)
    }

    def "classpaths are equal when the contain the same sequence of files"() {
        def file1 = new File("a.jar")
        def file2 = new File("b.jar")
        def file3 = new File("c.jar")
        def cp = DefaultClassPath.of(file1, file2)

}
"""

        when:
        succeeds 'dependencies'

        then:
        lockfileFixture.expectLockStateMissing('unlockedConf')
    }

    def "version selector combinations are resolved equally for locked and unlocked configurations"() {
        ['foo', 'foz', 'bar', 'baz'].each { artifact ->
            mavenRepo.module('org', artifact, '1.0').publish()
            mavenRepo.module('org', artifact, '1.1').publish()

        init.getJavaLanguageVersion(userQuestions, buildInitializer)

        then:
        def e = thrown(GradleException)
        e.message == "Target Java version: '5' is not a supported target version. It must be equal to or greater than 7"
    }

    def "should reject invalid package name: #invalidPackageName"() {
        given:
        projectLayoutRegistry.get("java-library") >> defaultGenerator