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:

                        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;
                         }

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

                    System.out.println("allow unusable daemons = " + allowUnusable);
                    try {
                        if (action.equals("help")) {
                            runHelp(projectDir, gradleVersion, javaHome, gradleUserHome);
                        } else if (action.equals("action")) {
                            buildAction(projectDir, gradleVersion, javaHome, gradleUserHome);
                        }

                    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;
                    }

        file("build/reports/pmd/test.xml").assertContents(containsClass("org.gradle.Class1Test"))
        output.contains "\tUsing multiple unary operators may be a bug"
        output.contains "\tEnsure you override both equals() and hashCode()"
    }

    void "can configure number of threads on good code"() {
        goodCode()
        buildFile << """
            pmd {
                threads = 2
            }
        """