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

    public static void main(String[] args) {
        if (!"value".equals(System.getProperty("testValue"))) {
            throw new RuntimeException("Expected system property not specified");
        }
        if (!"some value".equals(System.getProperty("testValue2"))) {
            throw new RuntimeException("Expected system property not specified");
        }
        if (!"some value".equals(System.getProperty("testValue3"))) {

    public CustomType(String value) { this.value = value; }

    public boolean equals(Object o) {
        CustomType other = (CustomType)o;
        return other.value.equals(value);
    }

    public int hashCode() { return value.hashCode(); }
}
"""
    }

    String customSerializableTypeWithNonDeterministicSerializedForm() {
        // A type where equals() may return true for values where the serialized forms are different

                @org.junit.jupiter.api.Test
                public void checkEnvironment() {
                    assert System.getProperty("projectDir").equals(System.getProperty("user.dir"));
                    assert "value".equals(System.getProperty("testSysProperty"));
                    assert "value".equals(System.getenv("TEST_ENV_VAR"));

                    assert ClassLoader.getSystemClassLoader() == getClass().getClassLoader();

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

                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "custom"))
                    }
                    if (!"${capability}".equals('default')) {
                        outgoing.capability('org.test:sample:1.0')
                    }
                }

                sample2 {
                    canBeResolved = false

                                    assert new BigInteger("4").equals(element.getBigIntegerProperty());
                                    assert new BigDecimal("5.5").equals(element.getBigDecimalProperty());
                                    assert element.getStringProperty().equals("test");
                                    assert "sample.txt".equals(element.getFile().toString());

        boolean isFlag()
    }

    def "equals() returns false for non-compatible types"() {
        def impl = newNodeBackedInstance(SomeType)
        expect:
        !impl.equals(null)
        !impl.equals(1)
    }

    def "Two node backed views are equal when their state objects are equal"() {
        def state1 = Mock(ModelElementState)
        def state2 = Mock(ModelElementState)

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