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

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

import javax.inject.Inject

allprojects {
    apply plugin: CustomPlugin
}

class CustomModel implements Serializable {
    List<CustomThing> things = new ArrayList()

    CustomModel(int heapSizeMb) {
        for(int i = 0; i < heapSizeMb; i++) {
            things.add(new CustomThing())
        }
    }
}

class CustomThing implements Serializable {
    byte[] payload = new byte[1024 * 1024]
}

Note: an empty list (`[]`) matches nothing, and an empty string (`""`) is a
prefix of everything.

### What are InverseRules?

In contrast to rules, which are defined in terms of "things this package
depends on", inverse rules are defined in terms of "things which import this
package".  This allows for fine-grained import restrictions for "semi-private
packages" which are more sophisticated than Go's `internal` convention.

    The new logic runs with no external dependencies, and will attempt to continue if errors are encountered (which could be caused by things like SELinux rules).

plugins {
    `kotlin-dsl`
}

description = "Provides plugins for configuring miscellaneous things (repositories, reproducibility, minify)"

group = "gradlebuild"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.ADOPTIUM
    }
}

dependencies {
    api("gradlebuild:build-environment")
    api(platform(project(":build-platform")))

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Defines tools that can build things that run on the JVM.
 */