ruleManager.addRule(rule1);
        ruleManager.addRule(rule2);
        ruleManager.addRule(rule3);

        assertTrue(ruleManager.hasRule(rule1));
        assertTrue(ruleManager.hasRule(rule2));
        assertTrue(ruleManager.hasRule(rule3));
        assertEquals(3, ruleManager.getRuleCount());
    }

    /**
     * Test adding null rule
     */
    public void test_addRule_null() {

            }
        }

        @Override
        public boolean removeRule(Rule rule) {
            return rules.remove(rule);
        }

        @Override
        public boolean hasRule(Rule rule) {
            return rules.contains(rule);
        }

        public List<Rule> getRules() {
            return new ArrayList<>(rules);
        }

        public void clearRules() {

        public void addRule(int index, Rule rule) {
        }

        @Override
        public boolean removeRule(Rule rule) {
            return false;
        }

        @Override
        public boolean hasRule(Rule rule) {
            return false;
        }
    }

    /**
     * Test implementation of IntervalController for testing
     */

			if err != nil {
				return err
			}
		}
		var (
			ruleID  = fmt.Sprintf("site-repl-%s", d)
			hasRule bool
		)
		var ruleARN string
		for _, r := range replicationConfig.Rules {
			if r.ID == ruleID {
				hasRule = true
				ruleARN = r.Destination.Bucket
			}
		}

		ep, _ := url.Parse(peer.Endpoint)
		var targets []madmin.BucketTarget

        assertTrue(fessUserBean.hasRole("admin"));
        assertTrue(fessUserBean.hasRole("user"));
        assertTrue(fessUserBean.hasRole("manager"));
        assertFalse(fessUserBean.hasRole("guest"));

        // Test with null check
        assertFalse(fessUserBean.hasRole(null));
    }

    public void test_hasRoles() {
        // Test with no roles

    }

    public String[] getGroups() {
        return user.getGroupNames();
    }

    public boolean isEditable() {
        return user.isEditable();
    }

    public boolean hasRole(final String role) {
        return stream(user.getRoleNames()).get(stream -> stream.anyMatch(s -> s.equals(role)));
    }

    public boolean hasRoles(final String[] acceptedRoles) {

        boolean hasWeb = false;
        boolean hasFile = false;
        for (final ProtocolType type : values) {
            if (type == ProtocolType.WEB) {
                hasWeb = true;
            } else if (type == ProtocolType.FILE) {
                hasFile = true;
            }
        }

        assertTrue("Should have WEB protocol type", hasWeb);

// license that can be found in the LICENSE file.

package tar

import (
	"bytes"
	"fmt"
	"strconv"
	"strings"
	"time"
)

// hasNUL reports whether the NUL character exists within s.
func hasNUL(s string) bool {
	return strings.Contains(s, "\x00")
}

// isASCII reports whether the input is an ASCII C-style string.
func isASCII(s string) bool {
	for _, c := range s {

// If data is not xlv2, it is returned in full.
func readXLMetaNoData(r io.Reader, size int64) ([]byte, error) {
	initial := size
	hasFull := true
	if initial > metaDataReadDefault {
		initial = metaDataReadDefault
		hasFull = false
	}

	buf := metaDataPoolGet()[:initial]
	_, err := io.ReadFull(r, buf)
	if err != nil {
		return nil, fmt.Errorf("readXLMetaNoData(io.ReadFull): %w", err)