public String[] getRoleNames() {
        return stream(getRoles()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {
        return stream(getGroups()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    private String decode(final String value) {
        return new String(Base64.getDecoder().decode(value), Constants.CHARSET_UTF_8);
    }

        assertEquals(options, options.group(groupTwoName, groupTwoPackages));
        assertEquals(2, options.getGroups().size());
        assertArrayEquals(groupOnePackages, options.getGroups().get(groupOneName).toArray());
        assertArrayEquals(groupTwoPackages, options.getGroups().get(groupTwoName).toArray());
    }

    @Test
    public void testFluentNoDeprecated() {

    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Override
    public Set<String> getGroups() {
        return groups;
    }

    @Override
    public boolean excludes(ModuleIdentifier module) {
        return groups.contains(module.getGroup());
    }

    @Override
    public boolean excludesArtifact(ModuleIdentifier module, IvyArtifactName artifactName) {

        addToGroup(project.getMainGroup(), xcodeProject.getGroups().getSources(), "Sources");
        addToGroup(project.getMainGroup(), xcodeProject.getGroups().getHeaders(), "Headers");
        addToGroup(project.getMainGroup(), xcodeProject.getGroups().getTests(), "Tests");
        addToGroup(project.getMainGroup(), xcodeProject.getGroups().getRoot());

        for (XcodeTarget xcodeTarget : xcodeProject.getTargets()) {

 * limitations under the License.
 */
package org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs;

import java.util.Set;

public interface GroupSetExclude extends ExcludeSpec {
    Set<String> getGroups();

                FileCollection sources = component.getCppSource();
                xcodeProject.getGroups().getSources().from(sources);

                FileCollection headers = component.getHeaderFiles();
                xcodeProject.getGroups().getHeaders().from(headers);

                // TODO - should use the _install_ task for an executable

            op.setRefreshPolicy(Constants.TRUE);
        });

        userBhv.selectCursor(cb -> cb.query().setGroups_Equal(group.getId()), entity -> {
            entity.setGroups(
                    stream(entity.getGroups()).get(stream -> stream.filter(s -> !s.equals(group.getId())).toArray(n -> new String[n])));
            userBhv.insertOrUpdate(entity);
        });

    }

        given: "a managed type that uses a read-write Set of strings"
        buildScript '''
            @Managed
            interface User {
                Set<String> getGroups()
                void setGroups(Set<String> groups)
            }

            model {
                user(User) {
                    def sortedSet = new TreeSet(['users', 'general'])
                    groups = sortedSet

	n := clen(buf[:])
	if n < 1 {
		return "", EINVAL
	}
	return string(buf[:n]), nil
}

/*
 * Wrapped
 */

//sysnb	getgroups(ngid int, gid *_Gid_t) (n int, err error)
//sysnb	setgroups(ngid int, gid *_Gid_t) (err error)

func Getgroups() (gids []int, err error) {
	n, err := getgroups(0, nil)
	if err != nil {
		return nil, err
	}
	if n == 0 {
		return nil, nil
	}

    private File locationDir;

    @Inject
    public DefaultXcodeProject(ObjectFactory objectFactory) {
        this.groups = objectFactory.newInstance(Groups.class);
    }

    public Groups getGroups() {
        return groups;
    }

    public List<XcodeTarget> getTargets() {
        return targets;
    }

    public Callable<List<TaskDependency>> getTaskDependencies() {