/**
 * Used to validate mutation of an object and its sub-parts.
 */
public interface MutationValidator {
    enum MutationType {
        /**
         * The mutation of the resolution strategy of the configuration, i.e. caching, resolution rules etc.
         */
        STRATEGY("resolution strategy"),

        /**

 */
public interface MutationGuard {
    /**
     * Wraps the specified action with mutation disabling code.
     *

}
// end::type-declaration[]

// tag::type-registration[]
// tag::internal-view-mutation[]
class MyPlugin extends RuleSource {
// end::internal-view-mutation[]
    @ComponentType
    void registerMyComponent(TypeBuilder<MyComponent> builder) {
        builder.internalView(MyComponentInternal)
    }
// end::type-registration[]
// tag::internal-view-mutation[]
    @Mutate
    void mutateMyComponents(ModelMap<MyComponentInternal> components) {

if [ "$foundMutation" -gt "1" ]; then
  echo "${mutationOutput}"
  echo "It looks like an assignment of a value using the old object.  This is a heuristic check.  If a mutation is happening in validation please fix it."
  echo "If a mutation of arguments is not happening, you can exempt a line using '// +k8s:verify-mutation:reason=clone'."
  exit 1
fi

            recorder.mutations << "a"
        }
    }

    def "mutation rules from the same plugin are applied in the order specified by their signatures"() {
        when:
        modelRegistry.getRoot().applyToSelf(ByPathRules)

        then:
        modelRegistry.get("recorder", MutationRecorder).mutations == ["a", "b"]
    }

    static class MixedRules extends RuleSource {
        @Model

    Initialize(ModelNode.State.Initialized, true), // Mutation action provided when an element is defined
    Mutate(ModelNode.State.Mutated, true), // Customisations
    Finalize(ModelNode.State.Finalized, true), // Post customisation default values
    Validate(ModelNode.State.SelfClosed, true); // Post mutation validations

}

// DurationTest is webhook duration test case, used both in mutating and
// validating plugin test cases.
type DurationTest struct {
	Name                string
	Webhooks            []registrationv1.ValidatingWebhook
	InitContext         bool
	IsDryRun            bool
	ExpectedDurationSum time.Duration
	ExpectedDurationMax time.Duration
}

@Subject(MutationGuards)
class MutationGuardsTest extends Specification {
    def "can get mutation guard of guard aware instance"() {
        given:
        def subject = Mock(WithMutationGuard)

        when:
        MutationGuards.of(subject)

        then:
        1 * subject.getMutationGuard()
        0 * subject._
    }

    def "doesn't get mutation guard of guard unaware instance"() {
        given:

        }
    };

    /**
     * Returns the identity mutation guard. It protect and do nothing.
     */
    public static MutationGuard identity() {
        return IDENTITY_MUTATION_GUARD;
    }

    /**
     * Retrieves the {@code MutationGuard} of the target if it implements {@code WithMutationGuard}, else returns an identity mutation guard performing no guard operations.
     */

    }
    def nagger = new TaskMutator(task)

    def "executes mutation action when in configurable state"() {
        def action = Mock(Runnable)

        given:
        state.configurable >> true

        when:
        nagger.mutate("Task.thing()", action)

        then:
        1 * action.run()
    }

    def "mutation action fails when not in configurable state"() {
        def action = Mock(Runnable)