// `implementation` dependencies are accessible
                    assert new com.fasterxml.jackson.databind.ObjectMapper().readTree("{\\\"hello\\\": \\\"test\\\"}").get("hello").asText().equals("test");

                    // `compileOnly` dependencies are accessible at compile-time
                    try {
                        assert org.apache.commons.lang3.StringUtils.length("Hello, Gradle!") == 14;

            connection.getModel(GradleProject.class)
        }

        then:
        gradleProject != null
        gradleProject.tasks.find { it.name.equals('publicTask') }.isPublic()
        !gradleProject.tasks.find { it.name.equals('privateTask') }.isPublic()
    }

class DefaultIsolatedProjectSpec extends Specification {

    def "delegates equals and hashCode to project"() {
        given:
        def project = Mock(ProjectInternal)
        def subject = new DefaultIsolatedProject(project, project)

        when:
        def hashCode = subject.hashCode()
        def equality = subject.equals(new DefaultIsolatedProject(project, project))

        then:
        hashCode == 42

        expect:
        def targetMachines = [windows1, windows2, linux1, linux2] as Set
        targetMachines.size() == 2
        targetMachines == [windows1, linux1] as Set
    }

    def "same target machine are equals"() {
        expect:
        factory.windows == factory.windows
        factory.linux == factory.linux
        factory.macOS == factory.macOS
        factory.windows.x86 == factory.windows.x86

            assert entry.path.toString() == "a.class"
            assert Arrays.equals(entry.content, "a".bytes)
        }
        1 * visitor.visit({ it.name == "a/b/c.class" }) >> { ClasspathEntryVisitor.Entry entry ->
            assert entry.path.toString() == "a/b/c.class"
            assert Arrays.equals(entry.content, "c".bytes)
        }
        0 * visitor._
    }

    def "visits files of zip"() {

        "size()"              | call(s -> s.size())
        "isEmpty()"           | call(s -> s.isEmpty())
        "hashCode()"          | call(s -> s.hashCode())
        "equals(Object)"      | call(s -> Objects.equals(s, Collections.emptySet()))  // Ensure that a real equals is invoked and not a Groovy helper
        "removeIf(Predicate)" | call(s -> s.removeIf(e -> false))
    }

    def "method clear is reported"() {
        when:

        def n2 = factory.named(Named, "b")

        n1.is(n1)
        !n1.is(n2)

        n1.name == "a"
        n2.name == "b"

        Matchers.strictlyEquals(n1, n1)
        n2 != n1
        !n2.equals(n1)

        n1.hashCode() == n1.hashCode()
        n1.hashCode() != n2.hashCode()

        n1.toString() == "a"
        n2.toString() == "b"

        n1.is(factory.named(Named, "a"))

        // Have to use reference check because owner's equals is broken
        ex.evaluationCycle[0] === owner
        ex.evaluationCycle[1] === owner

        where:
        evaluator << [evaluateInLambda(), evaluateInBlock()]
    }

    def "can handle owner with broken equals in tryEvaluate"() {
        given:
        owner.equals(_) >> { false }

        when:

        DefaultSerializer rhsSerializer = new DefaultSerializer(getClass().classLoader)
        DefaultSerializer lhsSerializer = new DefaultSerializer(getClass().classLoader)

        when:
        def areEquals = rhsSerializer.equals(lhsSerializer);

        then:
        areEquals
    }

        "isEmpty()"             | call(m -> m.isEmpty())
        "size()"                | call(m -> m.size())
        "hashCode()"            | call(m -> m.hashCode())
        "equals()"              | call(m -> Objects.equals(m, Collections.emptyMap()))  // Ensure that a real equals is invoked and not a Groovy helper
        "entrySet().size()"     | call(m -> m.entrySet().size())
        "entrySet().iterator()" | call(m -> m.entrySet().iterator())