import java.lang.annotation.Target;

/**
 * Denotes that the {@link RuleSource} method rule carrying this annotation validates the rule subject.
 * <p>
 * Validate rules execute after {@link Finalize} rules, but before rule subject is used as an input.
 * The first parameter of the rule is the rule subject, which is <b>immutable</b>.
 * <p>
 * Please see {@link RuleSource} for more information on method rules.
 */

						},
					},
				},
				RequireClientCertificate: proto.BoolFalse,
			},
		},
		{ // Credential name and subject alternative names are specified, generate SDS configs for
			// key/cert and static validation context config.
			name: "credential name subject alternative name no key no cert tls SIMPLE",
			server: &networking.Server{
				Hosts: []string{"httpbin.example.com", "bookinfo.example.com"},

	rbacregistryvalidation "k8s.io/kubernetes/pkg/registry/rbac/validation"
)

func TestSubjectLocator(t *testing.T) {
	type actionToSubjects struct {
		action   authorizer.Attributes
		subjects []rbacv1.Subject
	}

	tests := []struct {
		name                string
		roles               []*rbacv1.Role
		roleBindings        []*rbacv1.RoleBinding
		clusterRoles        []*rbacv1.ClusterRole

/**
 * Denotes that the {@link RuleSource} method rule carrying this annotation initializes the rule subject with default values.
 * <p>
 * Default rules execute first for a given subject, just after the subject has been created but before {@link Model} rules and {@link Mutate} rules.
 * The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.
 * <p>

    private final SubjectDescriptor subject;
    private final Set<OperationDescriptor> dependencies;

    public DefaultTransformOperationDescriptor(InternalTransformDescriptor descriptor, OperationDescriptor parent, Set<OperationDescriptor> dependencies) {
        super(descriptor, parent);
        this.transformer = new DefaultTransformerDescriptor(descriptor.getTransformerName());

				},
				RoleRef: rbac.RoleRef{
					APIGroup: rbac.GroupName,
					Kind:     "ClusterRole",
					Name:     constants.NodeBootstrapperClusterRoleName,
				},
				Subjects: []rbac.Subject{
					{
						Kind: rbac.GroupKind,
						Name: constants.NodeBootstrapTokenAuthGroup,
					},
				},
			}),
		},
		{
			name: "Create new ClusterRoleBindings",

	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*rbac.Subject)(nil), (*v1alpha1.Subject)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_rbac_Subject_To_v1alpha1_Subject(a.(*rbac.Subject), b.(*v1alpha1.Subject), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1alpha1.Subject)(nil), (*rbac.Subject)(nil), func(a, b interface{}, scope conversion.Scope) error {

	}

	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
	if err != nil {
		return nil, fmt.Errorf("unable to generate a serial number for %s: %v", cr.Subject.CommonName, err)
	}

	tmpl := &x509.Certificate{
		SerialNumber:       serialNumber,
		Subject:            cr.Subject,
		DNSNames:           cr.DNSNames,
		IPAddresses:        cr.IPAddresses,
		EmailAddresses:     cr.EmailAddresses,
		URIs:               cr.URIs,

		if target.args.Streaming.Async {
			_, err = target.stanConn.PublishAsync(target.args.Subject, data, nil)
		} else {
			err = target.stanConn.Publish(target.args.Subject, data)
		}
	} else {
		if target.jstream != nil {
			_, err = target.jstream.Publish(target.args.Subject, data)
		} else {
			err = target.natsConn.Publish(target.args.Subject, data)
		}
	}
	return err
}

         */
        String getDisplayName();

    }

    /**
     * Describes the subject (artifact or file) of a transform operation.
     *
     * @since 5.1
     */
    interface SubjectDescriptor {

        /**
         * Returns the display name of this subject.
         */
        String getDisplayName();

    }