from configurations.things
                into buildDir
            }
        """

        when:
        run "resolveIt"

        then:
        output.count("before :things") == 1
        output.count("after :things") == 1
    }

    @Issue("https://issues.gradle.org/browse/GRADLE-2047")
    def "can access resolved files from afterResolve hook"() {
        given:

        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)
    }

                parent { }
                things.extendsFrom parent
                all {
                    incoming.beforeResolve { throw new RuntimeException() }
                    incoming.afterResolve { throw new RuntimeException() }
                }
            }
            dependencies {
                parent files("parent.txt")
                things files("thing.txt")
            }

        when:
        registry.registerInstance("things", []).mutate {
            it.path("things").action(reference.path, reference.type, { things, set ->
                set."$method" {

                }
            })
        }

        registry.get("things")

        then:
        def e = thrown ModelRuleExecutionException

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.

        when:
        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"() {

            }
        }

        then:
        def transformer = new XmlTransformer()
        transformer.addAction(publication.descriptor.xmlAction)
        transformer.transform("<things/>").contains('things foo="bar"')
    }

    def "creates publish tasks for all publications in a repository"() {
        when:
        publishing.publications.create("test", IvyPublication)

import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * To be implemented by test generators of things that can contain elements. Such things include
 * both {@link Collection} and {@link Map}; since there isn't an established collective noun that
 * encompasses both of these, 'container' is used.
 *
 * @author George van den Driessche
 */

import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * To be implemented by test generators of things that can contain elements. Such things include
 * both {@link Collection} and {@link Map}; since there isn't an established collective noun that
 * encompasses both of these, 'container' is used.
 *
 * @author George van den Driessche
 */

            final int[] fints = parseTime(from);
            fromHours = fints[0];
            fromMinutes = fints[1];
            final int[] tints = parseTime(to);
            toHours = tints[0];
            toMinutes = tints[1];
            final String[] values = days.split(",");
            final List<Integer> list = new ArrayList<>();
            for (final String value : values) {