buildFile """
        class Thing {
            String value
            Thing(String value) {
                this.value = value
            }
        }

        class MyExtensible {}

        def myExtensible = project.objects.newInstance(MyExtensible)
        assert myExtensible instanceof ExtensionAware

        myExtensible.extensions.create("thing", Thing, "bar")

            assert it.is(thing)
            assert delegate.is(thing)
        }

        when:
        action(closure).execute(thing, [])

        then:
        called
    }

    def "can construct with untyped single arg closure"() {
        given:
        def called = false
        String thing = "1"
        def closure = { subject ->
            called = true
            assert subject.is(thing)

This is the basic idea. But you will probably want to take care of some additional things, like:

* Security - HTTPS
* Running on startup
* Restarts
* Replication (the number of processes running)
* Memory
* Previous steps before starting

                }
            }

            tasks.create("thing", MyTask) {
                println("property = \$count")
            }
        """

        when:
        fails("thing")

        then:
        outputContains("property = task ':thing' property 'count'")
        failure.assertHasCause("Cannot query the value of task ':thing' property 'count' because it has no value available.")
    }

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

            task show {
                def thing = project.thing
                dependsOn {
                    thing.prop.from("some-file")
                    println("value = " + thing.prop.files)
                    try {
                        thing.prop.from("ignore me")

	
	for i := 0; i < 10000; i++ {
		s := string(buf)
		t := &T{ptr: new(*int)}
		runtime.SetFinalizer(t.ptr, func(**int) { panic("*int freed too early") })
		Ts = append(Ts, t)
		things = append(things, s[len(s):])
	}
	
	things = append(things, Ts...)

        outputContains("test-thing-1.2.thing {artifactType=thing, org.gradle.status=release}")
        outputContains("test-1.2.jar {artifactType=jar, org.gradle.status=release}")
        outputContains("test-1.2.aar {artifactType=aar, org.gradle.status=release}")
        outputContains("test-1.2.thing {artifactType=thing, org.gradle.status=release}")

    @Override
    public String determineName(Object thing) {
        Object name;
        try {
            if (thing instanceof Named) {
                name = ((Named) thing).getName();
            } else if (thing instanceof Map) {
                name = ((Map) thing).get("name");
            } else if (thing instanceof GroovyObject) {
                name = ((GroovyObject) thing).getProperty("name");
            } else {

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

  - Foo
  - [Go]
  - Bar

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

  - Foo
  - Go
  - Bar

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

  - Foo
  - [Go](https://go.dev/)
  - Bar

-- html --
<p>Cool things:
<ul>
<li>Foo
<li><a href="https://go.dev/">Go</a>
<li>Bar

    private static String join(Collection<?> things, String separator) {
        StringBuilder builder = new StringBuilder();
        boolean first = true;

        if (separator == null) {
            separator = "";
        }

        for (Object thing : things) {
            if (!first) {
                builder.append(separator);
            }
            builder.append(thing.toString());
            first = false;