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:

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

                    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
        }

}

class TestDomainObject implements Attachable<TestDomainObject>, Serializable {
    def value

    TestDomainObject(String value) {
        this.value = value
    }

    @Override
    boolean equals(Object o) {
        return o.value == value
    }

    @Override
    int hashCode() {
        return value.hashCode()
    }

    void attach(ClassMetaDataRepository<TestDomainObject> repository) {

        return new SystemPropertyRead() {
            @Override
            String getJavaExpression() {
                return "(String)System.getProperties().entrySet().stream().filter(e -> e.getKey().equals(\"$name\")).findFirst().get().getValue()";
            }

            @Override
            String getGroovyExpression() {
                return "System.properties.entrySet().find { it.key == '$name'}.value"

                def response = NtlmPasswordAuthentication.getLMv2Response(authentication.domain, authentication.username, credentials, challenge, clientChallenge)
                return Arrays.equals(hash, response)
            }

            return false
        }
    }

    private static class NtlmConnectionAuthentication {
        byte[] challenge
        Authentication.User user