def "test Scala Includes"() {
        expect:
        scalaDoc.include(TEST_PATTERN_1, TEST_PATTERN_2) == scalaDoc
        scalaDoc.getIncludes().equals(WrapUtil.toLinkedSet(TEST_PATTERN_1, TEST_PATTERN_2))

        scalaDoc.include(TEST_PATTERN_3) == scalaDoc
        scalaDoc.getIncludes().equals(WrapUtil.toLinkedSet(TEST_PATTERN_1, TEST_PATTERN_2, TEST_PATTERN_3))
    }

    def "test Scala Excludes"() {
        expect:

        id.getName() == "some-name"
    }

    def "hashCode and equals determine equality" () {
        given:
        NamespaceId id1 = new NamespaceId("some-namespace", "some-name")
        NamespaceId id2 = new NamespaceId("some-namespace", "some-name")

        expect:
        id1 Matchers.strictlyEqual(id2)
    }

    def "hashCode and equals determine inequality" () {
        given:

        createModuleLibraryWithScope(null).equals(createModuleLibraryWithScope("COMPILE"))
        createModuleLibraryWithScope("").equals(createModuleLibraryWithScope("COMPILE"))
        createModuleLibraryWithScope("COMPILE").equals(createModuleLibraryWithScope(null))
        createModuleLibraryWithScope("COMPILE").equals(createModuleLibraryWithScope(""))
        createModuleLibraryWithScope("").equals(createModuleLibraryWithScope(""))

        then:
        a !== b
        a.equals(a)
        a.equals(b)
        b.equals(a)
    }

    def "can compare null-holding try with non-null"() {
        when:
        def a = Try.successful(null as String)
        def b = Try.successful("value")

        then:
        !a.equals(b)
        !b.equals(a)
    }

    def "null try has a hashcode"() {
        when:

import spock.lang.Specification

class DefaultEarModuleTest extends Specification {

    def "equals works correctly"(lhs, rhs, equals) {

        expect:
        lhs.equals(rhs) == equals
        rhs.equals(lhs) == equals

        where:
        lhs || rhs || equals
        new DefaultEarModule("some.jar") | new DefaultEarModule("some-other.jar") | false

        expect:
        new ModuleDependency("a", null).equals(new ModuleDependency("a", "COMPILE"))
        new ModuleDependency("a", "").equals(new ModuleDependency("a", "COMPILE"))
        new ModuleDependency("a", "COMPILE").equals(new ModuleDependency("a", ""))
        new ModuleDependency("a", "COMPILE").equals(new ModuleDependency("a", null))
        new ModuleDependency("a", "").equals(new ModuleDependency("a", ""))

        !listener1.equals(differentListener)
        !listener1.equals(null)
    }

    /**
     * covered by {@code org.gradle.testing.testng.TestNGIntegrationTest}
     */
    def "adapts to internal IConfigurationListener interface if available on class path"() {}

    def "adapter forwards all IConfigurationListener calls"() {
        IConfigurationListener adapter = factory.createAdapter(listener)

        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || obj.getClass() != getClass()) {
            return false;
        }
        GroovyClass other = (GroovyClass) obj;
        return files.equals(other.files);
    }

    @Override
    public int hashCode() {

        1     | Fruit.apples     | Fruit.oranges    | 0.333333
    }

    def "amounts are equal when normalised values are the same"() {
        expect:
        def a = Amount.valueOf(valueA, unitsA)
        def b = Amount.valueOf(valueB, unitsB)
        a.equals(b)
        b.equals(a)
        a.hashCode() == b.hashCode()
        a.compareTo(b) == 0
        b.compareTo(a) == 0

        where:

    }

    def "#a == #b: #equals"() {
        def hashA = HashCode.fromString(a)
        def hashB = HashCode.fromString(b)

        expect:
        (hashA == hashB) == equals
        (hashB == hashA) == equals

        where:
        a                                  | b                                  | equals