DefaultExcludeRuleContainer defaultExcludeRuleContainer = new DefaultExcludeRuleContainer(sourceExcludeRules);
        assertThat(defaultExcludeRuleContainer.getRules(), equalTo(sourceExcludeRules));
        assertThat(defaultExcludeRuleContainer.getRules(), not(sameInstance(sourceExcludeRules)));
    }

    @Test
    public void testAdd() {
        DefaultExcludeRuleContainer excludeRuleContainer = new DefaultExcludeRuleContainer();

            if (form instanceof EditForm) {
                return ComponentUtil.getComponent(RoleService.class).getRole(((EditForm) form).id);
            }
            break;
        default:
            break;
        }
        return OptionalEntity.empty();
    }

    public static OptionalEntity<Role> getRole(final CreateForm form) {
        return getEntity(form).map(entity -> {

		for _, fc := range parsed.filterChains {
			for _, rbacHTTP := range fc.rbacHTTP {
				action := rbacHTTP.GetRules().GetAction()
				for name := range rbacHTTP.GetRules().GetPolicies() {
					nameOfPolicy, indexOfRule := extractName(name)
					addPolicy(action, nameOfPolicy, indexOfRule)
				}
				if len(rbacHTTP.GetRules().GetPolicies()) == 0 {
					addPolicy(action, anonymousName, "0")
				}
			}

 */
package org.codelibs.fess.crawler.rule;

import org.codelibs.fess.crawler.entity.ResponseData;

/**
 * @author shinsuke
 *
 */
public interface RuleManager {

    Rule getRule(ResponseData responseData);

    void addRule(Rule rule);

    void addRule(int index, Rule rule);

    boolean removeRule(Rule rule);

    boolean hasRule(Rule rule);

interface MetadataRuleWrapper {
    DisplayName getDisplayName();

    boolean isClassBased();

    Collection<SpecConfigurableRule> getClassRules();

    SpecRuleAction<? super ComponentMetadataDetails> getRule();

    void addClassRule(SpecConfigurableRule ruleAction);

var viewEscalatingNamespaceResources = []rbacv1.PolicyRule{
	rbacv1helpers.NewRule(bootstrappolicy.Read...).Groups("").Resources("pods/attach").RuleOrDie(),
	rbacv1helpers.NewRule(bootstrappolicy.Read...).Groups("").Resources("pods/proxy").RuleOrDie(),
	rbacv1helpers.NewRule(bootstrappolicy.Read...).Groups("").Resources("pods/exec").RuleOrDie(),
	rbacv1helpers.NewRule(bootstrappolicy.Read...).Groups("").Resources("pods/portforward").RuleOrDie(),

        throw new UnsupportedOperationException("This operation is not supported by this implementation");
    }

    @Override
    public SpecRuleAction<? super ComponentMetadataDetails> getRule() {
        return ruleAction;
    }

	role := &rbac.Role{
		Rules: []rbac.PolicyRule{
			rbac.NewRule("verb").Groups("g").Resources("foo").RuleOrDie(),
			rbac.NewRule("verb").URLs("/foo").RuleOrDie(),
		},
	}
	clusterRole := &rbac.ClusterRole{
		Rules: []rbac.PolicyRule{
			rbac.NewRule("verb").Groups("g").Resources("foo").RuleOrDie(),
			rbac.NewRule("verb").URLs("/foo").RuleOrDie(),
		},
	}

    }

    @Override
    public void addClassRule(SpecConfigurableRule classRule) {
        classRules.add(classRule);
    }

    @Override
    public SpecRuleAction<? super ComponentMetadataDetails> getRule() {
        throw new UnsupportedOperationException("This operation is not supported by this implementation");
    }

    @Override
    public DisplayName getDisplayName() {

    }

    @Override
    public SortedSet<String> getNames() {
        return getDelegate().getNames();
    }

    @Override
    public List<Rule> getRules() {
        return getDelegate().getRules();
    }