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:

        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", ""))

                        String descriptor, boolean isInterface, Supplier<MethodNode> readMethodNode) {
                    if (owner.equals("java/io/File")) {
                        if (name.equals("listFiles") && descriptor.equals("()[Ljava/io/File;") && (opcode == Opcodes.INVOKEVIRTUAL || opcode == Opcodes.INVOKEINTERFACE)) {

                         if (name.equals("isIncremental") && descriptor.equals("()Z") && (opcode == Opcodes.INVOKEVIRTUAL || opcode == Opcodes.INVOKEINTERFACE)) {
                             mv._INVOKESTATIC(TASK__ADAPTER_TYPE, "access_get_isIncremental", "(Lorg/gradle/test/Task;)Z");
                             return true;
                         }

        !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: