outputContains("processing thing1-1.2.jar using []")
        outputContains("processing thing2-1.2.jar using []")
        outputContains("processing thing3-1.2.jar using [thing1-1.2.jar, thing2-1.2.jar]")
        outputContains("files = [thing3-1.2.jar.green, thing1-1.2.jar.green, thing2-1.2.jar.green]")

        def dir = testDir.file("thing.dir")
        classesDir(dir)
        def file = testDir.file("thing.jar")
        jar(file)
        def dir2 = testDir.file("thing2.dir")
        classesDir(dir2)
        def file2 = testDir.file("thing2.jar")
        jar(file2)
        def dir3 = testDir.file("thing3.dir")
        classesDir(dir3)
        def file3 = testDir.file("thing3.jar")
        jar(file3)

    }

    public static <T> List<T> toList(T[] things) {
        if (things == null || things.length == 0) {
            return new ArrayList<T>(0);
        }

        List<T> list = new ArrayList<T>(things.length);
        Collections.addAll(list, things);
        return list;
    }

    public static <T> Set<T> toSet(Iterable<? extends T> things) {
        if (things == null) {
            return new HashSet<T>(0);

            }
            extensions.add('things', SomeThing)
            things {
                letter = 'a'
                withLetter('b')
            }
            assert things.letter == Letter.B
            things.other('ABC')
            assert things.letter == Letter.A
            things.other(Letter.C)
            assert things.letter == Letter.C
            things.other('A', 'ignore')

        def model = withConnection { connection ->
            connection.model(CustomModel).get()
        }

        then:
        model.thing.is(model.thing)
        model.things[0].is(model.thing)
        model.thingsByName.child.is(model.thing)
        model.findThing("child").is(model.thing)
    }

    def "retains underlying object identity in model returned to client via build action"() {
        settingsFile << "include 'a', 'b'"

* A particular program while it is **running** on the operating system.
    * This doesn't refer to the file, nor to the code, it refers **specifically** to the thing that is being **executed** and managed by the operating system.

        }
        2.times {
            fails "thing", "-PfinalizerDep.broken"
            result.assertTasksExecutedInOrder ":thing", ":finalizerDep"
        }
        2.times {
            fails "thing", "-PfinalizerDep.broken", "--continue"
            result.assertTasksExecutedInOrder ":thing", ":finalizerDep"
        }
        2.times {
            fails "thing", "-Pfinalizer.broken"

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

	stop         <-chan struct{}
}

// dependency is a specific thing that can be depended on
type dependency struct {
	id             collectionUID
	collectionName string
	// Filter over the collection
	filter *filter
}

type erasedEventHandler = func(o []Event[any], initialSync bool)

// registerDependency is an internal interface for things that can register dependencies.

                mavenRepo.module("thing", "lib1", "2.0-SNAPSHOT").dependsOn(dep).publish()
            }
        }

        @Override
        void publishNewSnapshot(AbstractIntegrationSpec owner) {
            owner.with {
                def dep = mavenRepo.module("thing", "lib2", "4.1").publish()
                def module = mavenRepo.module("thing", "lib1", "2.0-SNAPSHOT").dependsOn(dep)