this.subject = Preconditions.checkNotNull(subject, "subject");
        this.descriptor = Preconditions.checkNotNull(descriptor, "descriptor");
        Preconditions.checkNotNull(inputs, "inputs");
        this.inputs = inputs.isEmpty() ? EMPTY_MODEL_REF_LIST : inputs;
    }

    @Override

  MyPlugin.Rules#mutateThing2(MyPlugin.MyThing2, MyPlugin.MyThing3, String, Integer)
    subject:
      - <no path> MyPlugin.MyThing2 (parameter 1) [*]
    inputs:
      - <no path> MyPlugin.MyThing3 (parameter 2) [*]
      - <no path> String (parameter 3) [*]
      - <no path> Integer (parameter 4) [*]

  MyPlugin.Rules#subjectOnly(MyPlugin.MyThing2)
    subject:
      - <no path> MyPlugin.MyThing2 (parameter 1) [*]

    private final Subject subject;

    LoggingExcludeFactory(ExcludeFactory delegate) {
        super(delegate);
        this.subject = computeWhatToLog();
    }

    private static Subject computeWhatToLog() {
        String subjectString = System.getProperty("org.gradle.internal.dm.trace.excludes", Subject.all.toString());
        return Subject.valueOf(subjectString.toLowerCase());
    }

// ValidateFlowSchemaSubject validates flow-schema's subject object.
func ValidateFlowSchemaSubject(subject *flowcontrol.Subject, fldPath *field.Path) field.ErrorList {
	var allErrs field.ErrorList
	switch subject.Kind {
	case flowcontrol.SubjectKindServiceAccount:
		allErrs = append(allErrs, ValidateServiceAccountSubject(subject.ServiceAccount, fldPath.Child("serviceAccount"))...)
		if subject.User != nil {

    private AddProjectionsAction(ModelReference<T> subject, ModelRuleDescriptor descriptor, Iterable<ModelProjection> projections) {
        super(subject, descriptor);
        this.projections = projections;
    }

    public static <T> AddProjectionsAction<T> of(ModelReference<T> subject, ModelRuleDescriptor descriptor, ModelProjection... projections) {
        return of(subject, descriptor, Arrays.asList(projections));
    }

        ModelRuleDescriptor descriptor = sourceDescriptor.append("named(%s)", name);
        ModelReference<T> subject = ModelReference.of(modelNode.getPath().child(name), elementType);
        modelNode.applyToLink(ModelActionRole.Mutate, new FilteringActionWrapper<T>(elementFilter, subject, NoInputsModelAction.of(subject, descriptor, configAction)));
    }

    @Override

    private final ModelReference<T> subject;
    private final ModelRuleDescriptor descriptor;

    public AbstractMethodRuleAction(ModelReference<T> subject, ModelRuleDescriptor descriptor) {
        this.subject = subject;
        this.descriptor = descriptor;
    }

    @Override
    public ModelReference<T> getSubject() {
        return subject;
    }

    public ModelRuleDescriptor getDescriptor() {

	tests := []struct {
		subjects  []rbacv1.Subject
		user      user.Info
		namespace string
		appliesTo bool
		index     int
		testCase  string
	}{
		{
			subjects: []rbacv1.Subject{
				{Kind: rbacv1.UserKind, Name: "foobar"},
			},
			user:      &user.DefaultInfo{Name: "foobar"},
			appliesTo: true,
			index:     0,
			testCase:  "single subject that matches username",
		},
		{

        then:
        called
    }

    def "multiple arg closure called with correct subject and correct inputs"() {
        given:
        def called = false
        String thing = "1"
        def closure = { String subject, Integer other, String another ->
            called = true
            assert subject.is(thing)
            assert delegate.is(thing)
        }

        when:

        onPropertyMissingSet.execute(name, value)
    }
}

class ActionsTester {

    Object subject = "subject"
    String lastMethod
    List lastArgs

    void oneAction(Action action) {
        lastMethod = "oneAction"
        lastArgs = [action]
        action.execute(subject)
    }

    void twoArgs(String first, Action action) {
        lastMethod = "twoArgs"