@Mutate
                void mutateEcho(Task echo, String message) {
                    echo.message = message
                }
            }

            class Rules extends RuleSource {
                @Model
                String message() {
                    "foo"
                }

                @Mutate
                void addTasks(ModelMap<Task> tasks) {

		configLayer, err := random.Layer(1000, "application/vnd.module.wasm.config.v1+json")
		if err != nil {
			t.Fatal(err)
		}
		img, err := mutate.Append(empty.Image, mutate.Addendum{Layer: wasmLayer}, mutate.Addendum{Layer: configLayer})
		if err != nil {
			t.Fatal(err)
		}
		img = mutate.MediaType(img, types.OCIManifestSchema1)

		// Push image to the registry.
		err = crane.Push(img, ref)
		if err != nil {
			t.Fatal(err)

                for ( String mutate : applyMutations ) {
                    if ( excludes.contains(mutate) || shouldSkip(excludes, mutate) ) {
                        continue;
                    }
                    if ( MUTATIONS.containsKey(mutate) ) {
                        configs.put(cfgname + "-" + mutate, MUTATIONS.get(mutate).mutate(new HashMap<>(map)));
                    }
                }

	errs = Strategy.ValidateUpdate(ctx, invalidRc, rc)
	if len(errs) == 0 {
		t.Errorf("Expected a validation error")
	}
	if invalidRc.ResourceVersion != "4" {
		t.Errorf("Incoming resource version on update should not be mutated")
	}
}

func TestControllerStatusStrategy(t *testing.T) {
	ctx := genericapirequest.NewDefaultContext()
	if !StatusStrategy.NamespaceScoped() {
		t.Errorf("ReplicationController must be namespace scoped")
	}

            class MyPlugin extends RuleSource {
                @Mutate
                void tasks(ModelMap<EchoTask> tasks) {
                    tasks.create("test")
                }
                @Mutate
                void applyMessages(@Path("tasks.test") Task task) {
                    println "as task: \$task"
                }
                @Mutate
                void applyMessages(@Path("tasks.test") EchoTask task) {

                @Model List<String> m3() { [] }

                @Mutate void m2ToM1(@Path("m1") m1, @Path("m2") m2) {
                    if (!m1.empty) {
                        throw new IllegalStateException("m2ToM1 has executed twice")
                    }
                    m1 << "executed"
                }

                // in cycle…
                @Mutate void m3ToM1(@Path("m1") m1, @Path("m3") m3) {}

        when:
        registry
            .mutate(NativeToolChainRegistry) { it.add toolChain("tc") }
            .mutate(PlatformContainer) { it.add named(NativePlatformInternal, "platform") }
            .mutate(BuildTypeContainer) { it.add named(BuildType, "bt") }
            .mutate(FlavorContainer) { it.add named(Flavor, "flavor1") }

        then:

                }

                @Mutate
                void addTasks1(ModelMap<Task> tasks, MyModel myModel) {
                    myModel.tasks.each { n ->
                        tasks.create(n) {
                          description = "task \$n"
                        }
                    }
                }

                @Mutate

                .build()
        )
    }

    void mutate(@DelegatesTo(ModelSet) Closure<?> action) {
        registry.mutate(reference, new ClosureBackedAction<>(action))
        registry.realizeNode(collectionPath)
    }

    def "can define and query elements"() {
        when:
        mutate {
            create { name = '1' }
            create { name = '2' }
        }

    def "rule can mutate a managed type with a #type of scalar read-only property"() {
        given:
        buildScript """

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

        class Rules extends RuleSource {
            @Model
            void createContainer(Container c) {}

            @Mutate
            void addItems(Container c) {