for (IvyArtifactName artifactDescriptor : artifactDescriptors) {
            if (artifactDescriptor.getName().equals(dependencyArtifact.getName())) {
                return artifactDescriptor
            }
        }
        throw new RuntimeException("Descriptor could not be found")
    }

    }

    def "uses charset specified in content type"() {
        def html = """
        <a href="\u00c1\u00d2">directory1</a>
        """
        def encodedHtml = html.getBytes('ISO-8859-1')
        assert !Arrays.equals(encodedHtml, html.getBytes("utf-8"))

        expect:
        def uris = parser.parse(baseUrl, new ByteArrayInputStream(encodedHtml), 'text/html;charset=ISO-8859-1')
        uris.collect { it.toString() } == ["\u00c1\u00d2"]

        result.testClass("LoggingTest").assertStdout(equalTo("This is stdout.\n"))
        result.testClass("LoggingTest").assertStderr(equalTo("This is stderr.\n"))

        when:
        executer.withArguments("-DLogLessStuff=true")
        run "test"

        then:
        result.testClass("LoggingTest").assertStdout(equalTo("stdout.\n"))
        result.testClass("LoggingTest").assertStderr(equalTo("stderr.\n"))
    }

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

        TimeFormatting.formatDurationVeryTerse(60 * 1000 + 12 * 1000 + 309) == '1m12.31s'
    }

    def "shows #output when elapsed time is greater or equals than #lowerBoundInclusive but lower than #upperBoundExclusive"() {
        when:
        def result = TimeFormatting.formatDurationTerse(input)

        then:
        result == output

        where:

                    byte[] relocated = ivy.getResourceAsStream('/org/gradle/internal/impldep/org/apache/ivy/plugins/parser/m2/m2-entities.ent').bytes
                    assert original.length > 0
                    assert Arrays.equals(original, relocated)
                }
            }
        '''
        file('src/test/groovy/MyPluginTest.groovy') << pluginTest()

        then:
        succeeds 'test'
    }

    @Issue("GRADLE-3525")

        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
            }

        return registration
    }

    MethodRuleDefinition<?, ?> ruleDefinitionForMethod(String methodName) {
        for (Method candidate : ruleClass.getDeclaredMethods()) {
            if (candidate.getName().equals(methodName)) {
                return DefaultMethodRuleDefinition.create(ruleClass, candidate)
            }
        }
        throw new IllegalArgumentException("Not a test method name")
    }

    }

    interface Person extends Named {}

    static abstract class AbstractPerson implements Person {
        String name

        String toString() { name }


        boolean equals(DefaultPerson other) {
            name == other.name
        }

        int hashCode() {
            name.hashCode()
        }
    }

    static class DefaultPerson extends AbstractPerson {
    }

        // Verify some assumptions: that we've got the correct characters in there, and that we're not using the system encoding
        assert code.contains(new String(Character.toChars(0x3b1)))
        assert !Arrays.equals(code.bytes, file.bytes)
    }

    def badCode() {
        file("src/main/scala/compile/test/Person.scala") << """package compile.test

class Person(val name: String, val age: Int) {