}

            project.extensions.create('thing', ProjectModel.class)
            thing.prop.disallowUnsafeRead()

            task show {
                def thing = thing
                dependsOn {
                    thing.prop.set("123")
                    println("value = " + thing.prop.get())
                    try {
                        thing.prop.set("ignore me")

        outerBuild.file('buildSrc/src/main/java/Thing.java') << """
            class Thing {
                Thing() { System.out.println("outer thing"); }
            }
        """
        outerBuild.buildFile << "new Thing()"

        childBuild.settingsFile << "rootProject.name = 'someBuild'"
        childBuild.file('buildSrc/src/main/java/Thing.java') << """
            class Thing {

        and:
        1 * index.lookup("thing") >> null
        1 * localCandidates.isNone() >> false
        1 * repository.resource(location, true) >> remoteResource
        1 * remoteResource.metaData >> null
        0 * _._
    }

    def "downloads resource and moves it into the cache when it is not cached"() {
        def location = new ExternalResourceName("thing")

            .withImplementation(ModelType.of(DefaultThingSpec))
        instanceFactory.register(ModelType.of(OtherThingSpec), new SimpleModelRuleDescriptor("thing"))
            .withImplementation(ModelType.of(DefaultOtherThingSpec))
        instanceFactory.register(ModelType.of(MultiplePathsToRoot), new SimpleModelRuleDescriptor("thing"))

        when:

{"DocLinkBaseURL": "https://pkg.go.dev"}
-- input --
Cool things:

  - Foo
  - [Go] is great
    
    [Go]: https://go.dev/
  - Bar

-- text --
Cool things:

  - Foo

  - Go is great

  - Bar

[Go]: https://go.dev/
-- markdown --
Cool things:

  - Foo

  - [Go](https://go.dev/) is great

  - Bar

-- html --
<p>Cool things:
<ul>
<li><p>Foo

                output = layout.buildDir.dir("dir.out")
            }

            def thing = project.extensions.create("thing", ProjectModel)

            thing.prop.disallowUnsafeRead()
            thing.prop.set(producer.output)
            def prop = thing.prop

            try {
                prop.get()
            } catch(IllegalStateException e) {

        classFile.isFile()
        new ZipTestFixture(jarFile).hasDescendants("META-INF/MANIFEST.MF", "Thing.class")

        when:
        file("src/main/java/thing/NewThing.java") << """
            package thing;

            public class NewThing { }
        """
        configurationCacheRun "build"

        then:
        assertStateLoaded()

        obj2.tryInvokeMethod(_, _) >> DynamicInvokeResult.notFound()
        obj1.tryGetProperty("things") >> DynamicInvokeResult.notFound()
        obj2.tryGetProperty("things") >> DynamicInvokeResult.found(container)

        when:
        obj.invokeMethod("things", [cl] as Object[])

        then:
        1 * container.configure(cl)
    }

            apply plugin: LoggingPlugin
            task thing {
                dependsOn gradle.includedBuilds*.task(':thing')
            }
        """
        file("a/build.gradle") << """
            task thing
        """
        file("b/build.gradle") << """
            task thing
        """

        when:
        run("thing")

        then:
        output.count("EVENT:") == 3

        given:
        buildFile << """
    class Thing implements Named, Serializable {
        String name
    }
    def attr = Attribute.of(List)

    configurations {
        ok
    }
    def value = [new Thing(name: 'a'), new Thing(name: 'b')]
    configurations.ok.attributes.attribute(attr, value)

    value[0].name = 'other'
    value.add(new Thing(name: 'c'))