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"

                        // After, we expect the test runtime classpath.
                        String[] filteredCliClasspath = Arrays.copyOfRange(splitCliClasspath, 1, splitCliClasspath.length);
                        java.util.Arrays.equals(splitTestRuntimeClasspath, filteredCliClasspath);
                    } else {
                        List<URL> systemClasspath = Arrays.asList(((URLClassLoader) ClassLoader.getSystemClassLoader()).getURLs());

        // PMD Lvl 2 Warning BooleanInstantiation
        // PMD Lvl 3 Warning OverrideBothEqualsAndHashcode
        file("src/main/java/org/gradle/BadClass.java") <<
            "package org.gradle; class BadClass { public boolean equals(Object arg) { return java.lang.Boolean.valueOf(true); } }"
    }

    }

    class Thing {
        String name

        Thing(String name) {
            this.name = name
        }

        @Override
        boolean equals(Object obj) {
            return obj.name == name
        }

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

        def expectedSorted = new ArrayList<String>(expected).sort()
        boolean equals = actual.size() == expectedSorted.size()
        if (equals) {
            for (int i = 0; i < actual.size(); i++) {
                equals &= actualSorted.get(i).startsWith(expectedSorted.get(i))
            }
        }
        if (!equals) {
            def actualFormatted = Joiner.on("\n").join(actualSorted)

                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

                    @Test
                    public void failedTest() {
                        System.out.println("Test index " + ${it});
                        if("${it}".equals(System.getProperty("${INDEX_OF_TEST_TO_FAIL}"))) {
                            throw new RuntimeException();
                        }
                    }
                }
            """.stripIndent()
        }

        path.parent == ModelPath.path(["a", "b"])
        path.parent.toString() == "a.b"
        path.rootParent == ModelPath.path("a")
        path == ModelPath.ROOT.child("a").child("b").child("c")
    }

    def "equals and hashcode"() {
        def p1 = ModelPath.path("a")

        expect:
        Matchers.strictlyEquals(p1, ModelPath.path("a"))
        p1 != ModelPath.path(("b"))
        p1 != ModelPath.path(("abc"))

        final String displayName

        TestAddress(String displayName) {
            this.displayName = displayName
        }

        boolean equals(o) {
            displayName == o.displayName
        }

        int hashCode() {
            displayName.hashCode()
        }

        @Override
        int getPort() {
            return 0

        reference.path == null
        reference.type == ModelType.of(String)
        !reference.untyped
        reference.state == ModelNode.State.GraphClosed
    }

    def "equals"() {
        expect:
        def path = ModelReference.of("path")
        def type = ModelReference.of(String)
        def pathAndType = ModelReference.of("path", String)