}

    def "new hierarchy in ModuleDependency is added to equals and hashcode"() {
        when:
        // If this test fails, you added a type hierarchy to GradleModuleMetadataParser.ModuleDependency, update this test _after_ making sure it is considered by hashcode and equals
        def modDepClass = GradleModuleMetadataParser.ModuleDependency.class

        then:

    }

    @BeforeEach
    void init(TestInfo testInfo) {
        String displayName = testInfo.getDisplayName();
        assertTrue(displayName.equals("TEST 1") || displayName.equals("test2()"));
    }

    @Test
    @DisplayName("TEST 1")
    @Tag("my-tag")
    void test1(TestInfo testInfo) {
        assertEquals("TEST 1", testInfo.getDisplayName());

        1 * listener2.doSomething("param") >> { throw failure2 }
        1 * listener3.dispatch(invocation)
        0 * _
    }

    def "can remove listener implemented using Proxy that does not implement equals()"() {
        TestListener other1 = Stub(TestListener)
        TestListener other2 = Stub(TestListener)

        } else {
            return CacheVersion.parse("0.1");
        }
    }

    @Override
    boolean wrapperCanExecute(GradleVersion version) {
        if (version.equals(GradleVersion.version("0.8")) || isVersion("0.8")) {
            // There was a breaking change after 0.8
            return false;
        }
        if (isVersion("0.9.1")) {

            import java.security.Permission;

            public class MySecurityManager extends SecurityManager {
                public MySecurityManager() {
                    assert getClass().getName().equals(System.getProperty("java.security.manager"));
                }

                @Override
                public void checkPermission(Permission permission) {
                }
            }

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

        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)

        "list(PrintWriter)"                       | call(p -> p.list(new PrintWriter(ByteStreams.nullOutputStream())))
        "equals(Object)"                          | call(p -> Objects.equals(p, new Properties()))  // Ensure that a real equals is invoked and not a Groovy helper
        "stringPropertyNames().iterator()"        | call(p -> p.stringPropertyNames().iterator())

        NodeType getNodeType() {
            return nodeType
        }

        @Override
        String toString() {
            return name
        }

        @Override
        boolean equals(o) {
            if (this.is(o)) {
                return true
            }
            if (!(o instanceof TestNodeIdentity)) {
                return false
            }

                doLast {
                    assert(testCompileClasspathFiles.map { it.name }.equals(listOf("commons-lang3-3.11.jar"))) { "commons-lang3 is an implementation dependency for the default test suite" }
                    assert(testRuntimeClasspathFiles.map { it.name }.equals(listOf("commons-lang3-3.11.jar"))) { "commons-lang3 is an implementation dependency for the default test suite" }