String[] roles1 = secured.value();
        String[] roles2 = secured.value();

        // Different array instances should be returned
        assertNotSame(roles1, roles2);

        // But values should be the same
        assertEquals(roles1.length, roles2.length);
        for (int i = 0; i < roles1.length; i++) {
            assertEquals(roles1[i], roles2[i]);
        }
    }

        assertTrue(roleSet.contains("role2"));

        encrypted = false;
        value = "role1,role2,role3";
        roleSet = decodedRoleList(roleQueryHelperImpl, value, encrypted);
        assertEquals(3, roleSet.size());
        assertTrue(roleSet.contains("role1"));
        assertTrue(roleSet.contains("role2"));
        assertTrue(roleSet.contains("role3"));
    }

    @Test

        String[] tags = { "tag2", "tag1" };
        String[] roles = { "role2", "role1" };
        String[] fields = { "field2", "field1" };
        String[] excludes = { "exclude2", "exclude1" };

        String result1 = popularWordHelper.getCacheKey(seed, tags, roles, fields, excludes);
        String result2 = popularWordHelper.getCacheKey(seed, tags, roles, fields, excludes);

        assertEquals(result1, result2);
    }

                final String[] roles = values[1].split(roleSeparator);
                for (final String role : roles) {
                    if (StringUtil.isNotEmpty(role)) {
                        roleSet.add(role);
                    }
                }
            }
        } else {
            final String[] roles = rolesStr.split(roleSeparator);
            for (final String role : roles) {

                // Return roles with duplicates
                String[] roles = new String[] { "role1", "role2", "role1", "Uuser", "role2" };
                callback.accept(roles);
                return roles;
            }

            @Override
            public String normalizePermissionName(String name) {

        // Test with multiple roles
        String[] roles = { "admin", "user", "manager" };
        FessUser user = new TestFessUser("testuser", roles, new String[] {}, new String[] {});
        assertArrayEquals(roles, user.getRoleNames());

        // Test with single role
        roles = new String[] { "user" };
        user = new TestFessUser("testuser", roles, new String[] {}, new String[] {});

    }

    public void test_clear() {
        UserPager userPager = new UserPager();
        userPager.id = "testId";
        userPager.name = "testName";
        userPager.roles = new String[] { "role1", "role2" };
        userPager.groups = new String[] { "group1" };
        userPager.versionNo = "1";
        userPager.setAllRecordCount(100);
        userPager.setAllPageCount(10);

        });
    }

    /**
     * Updates the role set with search roles based on the entry DN and name.
     *
     * @param roleSet the set of roles to update
     * @param entryDn the entry DN to check
     * @param name the role name
     * @return the role type prefix if successful, null otherwise
     */
    protected String updateSearchRoles(final Set<String> roleSet, final String entryDn, final String name) {

        testUser.setRoleNames(new String[] { "admin", "user", "manager" });
        roles = fessUserBean.getRoles();
        assertEquals(3, roles.length);
        assertEquals("admin", roles[0]);
        assertEquals("user", roles[1]);
        assertEquals("manager", roles[2]);
    }

    @Test
    public void test_getGroups() {
        // Test with empty groups
        testUser.setGroupNames(new String[] {});

            this.groups = groups;
        }

        /**
         * Sets the user's role assignments.
         * @param roles Array of role names.
         */
        public synchronized void setRoles(final String[] roles) {
            this.roles = roles;
        }

        /**
         * Resets permissions to force recalculation on next getPermissions() call.