assertNull(user.getGroups());

        final String[] groups = new String[] { "group1", "group2" };
        user.setGroups(groups);
        assertNotNull(user.getGroups());
        assertEquals(2, user.getGroups().length);
        assertEquals("group1", user.getGroups()[0]);
        assertEquals("group2", user.getGroups()[1]);
    }

    @Test
    public void test_user_roles() {

        assertNull(attributes.get("optional_claim"));
    }

    @Test
    public void test_parseJwtClaim_arrayValues() throws IOException {
        final String jwtClaim = "{\"roles\":[\"admin\",\"user\"],\"groups\":[\"group1\",\"group2\"]}";
        final Map<String, Object> attributes = new HashMap<>();

        authenticator.parseJwtClaim(jwtClaim, attributes);

        assertTrue(attributes.get("roles") instanceof List);

        for (int i = 0; i < 5; i++) {
            List<String> groups = new ArrayList<>();
            groups.add("group_" + i);
            List<String> roles = new ArrayList<>();
            List<String> groupIds = new ArrayList<>();
            groupIds.add("id_" + i);

            try {
                method.invoke(authenticator, null, groups, roles, groupIds);
            } catch (Exception e) {

## Configuring AD/LDAP on MinIO

        // Test with multiple groups
        testUser.setGroupNames(new String[] { "developers", "testers", "managers" });
        groups = fessUserBean.getGroups();
        assertEquals(3, groups.length);
        assertEquals("developers", groups[0]);
        assertEquals("testers", groups[1]);
        assertEquals("managers", groups[2]);
    }

    @Test
    public void test_isEditable() {

  }

  // Check for too few groups. We wanted exactly four.
  return b == addressOffset + 4
}

/** Encodes an IPv6 address in canonical form according to RFC 5952. */
internal fun inet6AddressToAscii(address: ByteArray): String {
  // Go through the address looking for the longest run of 0s. Each group is 2-bytes.
  // A run must be longer than one group (section 4.2.2).

	}

	// Bind to the lookup user account again to perform group search.
	if err = l.LDAP.LookupBind(conn); err != nil {
		return nil, nil, err
	}

	// User groups lookup.
	groups, err := l.LDAP.SearchForUserGroups(conn, username, lookupResult.ActualDN)
	if err != nil {
		return nil, nil, err
	}

	return lookupResult, groups, nil
}

// GetExpiryDuration - return parsed expiry duration.

)

// ListLDAPPolicyMappingEntities lists users/groups mapped to given/all policies.
//
// GET <admin-prefix>/idp/ldap/policy-entities?[query-params]
//
// Query params:
//
//	user=... -> repeatable query parameter, specifying users to query for
//	policy mapping
//
//	group=... -> repeatable query parameter, specifying groups to query for
//	policy mapping
//

                        ArrayList groups = (ArrayList) map.get(mem);
                        if (groups == null) {
                            groups = new ArrayList();
                            map.put(mem, groups);
                        }
                        if (!groups.contains(groupSid)) {
                            groups.add(groupSid);
                        }
                    }

        // Validate special group
        violations = validator.validate(bean, SpecialGroup.class);
        assertEquals(1, violations.size());
        assertTrue(violations.iterator().next().getPropertyPath().toString().contains("specialCron"));

        // Validate all groups
        violations = validator.validate(bean);
        assertEquals(1, violations.size()); // Only default group is validated
    }