val subject = ConfigurationCacheProblemsSummary(maxCollectedProblems = 2)
        assertTrue(
            "1st problem",
            subject.onProblem(buildLogicProblem("build.gradle", "failure"), ProblemSeverity.Failure)
        )
        assertTrue(
            "2nd problem (same message as 1st but different location)",

        )
    }

    def "creates unbound rules for multiple binders"() {
        binder {
            descriptor("firstRule")
            subjectReference("path.subject.first", String)
        }
        binder {
            descriptor("secondRule")
            subjectReference("path.subject.second", Number)
        }

        expect:

        @Mutate
        void theRule(List subject, String input1, Integer input2, Set input3) {
            subject.add(input1)
            subject.add(input2)
            subject.addAll(input3)
        }
    }

    static class ArrayListRuleSource {
        @Mutate
        void theRule(ArrayList subject, String input1, Integer input2, Set input3) {
            subject.add(input1)
            subject.add(input2)

	for _, subject := range subjects {
		if matchesSubject(user, subject) {
			return true
		}
	}
	return false
}

func matchesSubject(user user.Info, subject flowcontrol.Subject) bool {
	switch subject.Kind {
	case flowcontrol.SubjectKindUser:
		return subject.User != nil && (subject.User.Name == flowcontrol.NameAll || subject.User.Name == user.GetName())

import java.util.List;
import java.util.Set;

import javax.security.auth.Subject;
import javax.security.auth.kerberos.KerberosKey;
import javax.security.auth.kerberos.KeyTab;
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;


@SuppressWarnings ( "javadoc" )
public class KerberosCredentials {

    private Subject subject;


    public KerberosCredentials () throws LoginException {

                fun classToKClass(subject: ClassToKClass) {

                    subject.rawClass(type = String::class)
                    subject.unknownClass(type = String::class)
                    subject.invariantClass(type = Number::class)
                    subject.covariantClass(type = Int::class)
                    subject.contravariantClass(type = Number::class)

    private final String initialSubjectType;
    private final String subject;
    private final String transformer;

    public GroupedTransformOutputFixture(String initialSubjectType, String subject, String transformer) {
        this.initialSubjectType = initialSubjectType;
        this.subject = subject;
        this.transformer = transformer;
    }

    public String getInitialSubjectType() {

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