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:

        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:

                    // `implementation` dependencies are accessible
                    assert new com.fasterxml.jackson.databind.ObjectMapper().readTree("{\\\"hello\\\": \\\"test\\\"}").get("hello").asText().equals("test");

                    // `compileOnly` dependencies are accessible at compile-time
                    try {
                        assert org.apache.commons.lang3.StringUtils.length("Hello, Gradle!") == 14;

class DefaultIsolatedProjectSpec extends Specification {

    def "delegates equals and hashCode to project"() {
        given:
        def project = Mock(ProjectInternal)
        def subject = new DefaultIsolatedProject(project, project)

        when:
        def hashCode = subject.hashCode()
        def equality = subject.equals(new DefaultIsolatedProject(project, project))

        then:
        hashCode == 42

        DefaultSerializer rhsSerializer = new DefaultSerializer(getClass().classLoader)
        DefaultSerializer lhsSerializer = new DefaultSerializer(getClass().classLoader)

        when:
        def areEquals = rhsSerializer.equals(lhsSerializer);

        then:
        areEquals
    }

class DefaultToolchainSpecTest extends Specification {
    JavaToolchainSpec createSpec() {
        TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
    }

    def "spec key implements equals"() {
        given:
        def spec11 = createSpec()
        def spec12 = createSpec()
        def spec11Vendor1 = createSpec()
        def spec11Vendor2 = createSpec()
        def spec11Impl1 = createSpec()

            }

            boolean matches(Object o) {
                FileCopyDetails details = (FileCopyDetails) o
                return details.getRelativePath().getPathString().equals(path)
            }
        }
    }

                    verify(notification.getNotificationOperationResult(), 'Result')
                }

                private void verify(Object obj, String suffix = null) {
                    if (obj.getClass().getName().equals("org.gradle.internal.operations.OperationProgressDetails")) {
                        // This progress notification is emitted by Gradle itself.
                        return;
                    }

            } else {
                return vendorComparison
            }
        } else {
            return gcComparison
        }
    }

    boolean equals(o) {
        if (this.is(o)) {
            return true
        }
        if (getClass() != o.class) {
            return false
        }