transformer.addAction(new Action<XmlProvider>() {
            void execute(XmlProvider xml) {
                xml.asNode().thing[0].@foo = "bar"
            }
        })
        transformer.transform(writer, generator)

        then:
        looksLike('<things>\n  <thing foo="bar"/>\n</things>', writer.toString())
    }

    private void looksLike(String expected, String actual) {

        super("Thing")
    }

    NonIncrementalProcessorFixture providingNoOriginatingElements() {
        providesNoOriginatingElements = true
        this
    }

    String getGeneratorCode() {
        """
for (Element element : elements) {
    TypeElement typeElement = (TypeElement) element;
    String className = typeElement.getSimpleName().toString() + "Thing";
    try {

        buildScript '''
            @Managed
            interface Thing extends Named {
              void setValue(String value)
              String getValue()
            }

            class Rules extends RuleSource {
              @Model
              void mapThings(ModelSet<ModelMap<Thing>> things) {
                things.create {
                    a(Thing) {
                        value = '1'
                    }

        result.arguments == [1, 2] as Object[]
    }

    interface Thing {
        String doStuff(Thing[] things)
    }

    def "serializes a method invocation with array type parameters"() {
        def method = Thing.class.getMethod("doStuff", Thing[].class)
        def invocation = new MethodInvocation(method, [[] as Thing[]] as Object[])

        when:
        def serialized = serialize(invocation)

        ""      | ""
        "thing" | "thing"
        "a123"  | "a123"
        "_"     | "_"
        "a.b.c" | "a_b_c"
    }

    def "discards invalid identifier characters"() {
        expect:
        NamespaceBuilder.toNamespace(value) == namespace

        where:
        value      | namespace
        "123"      | ""
        "1thing"   | "thing"
        "1a 2b 3c" | "a_b_c"
    }

    def "reports problem when managed type declares a #type of subtype of scalar type"() {
        when:
        buildScript """
        class Thing extends File {
            Thing(String s) { super(s) }
        }

        @Managed
        interface Container {
            $type<Thing> getItems()
        }

        model {
            container(Container)
        }
        """

        then:

// Avoid potential confusion between import paths and symbols
// by rejecting these reserved imports for now. Also, people
// "can do weird things in GOPATH and we'd prefer they didn't
// do _that_ weird thing" (per rsc). See also #4257.
var ReservedImports = map[string]bool{
	"go":   true,
	"type": true,
}

var Ctxt *obj.Link

Often, these handlers are adding something to the queue like `client.AddEventHandler(controllers.ObjectHandler(queue.AddObject))`.
Construction should NOT actually start running all of these things, do I/O, or block in anyway.

Running the controller actually starts processing things.
Normally, this just means running the queue.
All informers created by `kube.Client` are kept track in the client, and started in one go with `RunAndWait` in one centralized call.

        given:
        registry.registerInstance("thing", "value")
        registry.configure(ModelActionRole.Validate) { it.path "thing" type Object node action }
        action.execute(_) >> { MutableModelNode node -> node.addLink("thing.child") { it.descriptor("create thing.child as String").unmanaged("value") } }

        when:
        registry.realize("thing")

        then:

* 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.