keep = orig.createFile('keep')

        subject = testDirectory.createDir('test/subject')
        remove = subject.createFile("remove")
        link = subject.file('link')
        createSymbolicLink(link, orig)

        assert orig.isDirectory()
        assert orig.exists()
        assert subject.isDirectory()
        assert subject.exists()
        assert keep.exists()
        assert remove.exists()

func ValidateRoleBindingSubject(subject rbac.Subject, isNamespaced bool, fldPath *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}

	if len(subject.Name) == 0 {
		allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
	}

	switch subject.Kind {
	case rbac.ServiceAccountKind:
		if len(subject.Name) > 0 {

import spock.lang.Specification
import spock.lang.Subject

@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._
    }

        given:
        def subject = new OrdinalGroupFactory()

        when:
        def g2 = subject.group(2)
        def g0 = subject.group(0)
        def g1 = subject.group(1)

        then:
        subject.allGroups == [g0, g1, g2]
    }

    def 'returns the same group for the same ordinal'() {
        given:
        def subject = new OrdinalGroupFactory()

        when:

        )
    }

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

./mc cp /etc/issue myminio1/test-bucket
ret=$?
if [ $ret -ne 0 ]; then
	echo "BUG: PutObject to bucket: test-bucket should succeed. Failed"
	exit 1
fi

./mc cp /etc/issue myminio1/multi-key-poc | grep -q "Insufficient permissions to access this path"
ret=$?
if [ $ret -eq 0 ]; then
	echo "BUG: PutObject to bucket: multi-key-poc without sse-kms should fail. Succedded"
	exit 1
fi

                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)

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 {