r, ok, err := g.Authenticator.AuthenticateRequest(req)
	if err != nil || !ok {
		return nil, ok, err
	}

	newGroups := make([]string, 0, len(r.User.GetGroups())+len(g.Groups))
	newGroups = append(newGroups, r.User.GetGroups()...)
	newGroups = append(newGroups, g.Groups...)

	ret := *r // shallow copy
	ret.User = &user.DefaultInfo{
		Name:   r.User.GetName(),
		UID:    r.User.GetUID(),

                return parent1.compareTo(parent2);
            }
        };
        final SetMultimap<String, TaskDetails> groups = TreeMultimap.create(keyComparator, taskComparator);
        for (String group : model.getGroups()) {
            groups.putAll(group, model.getTasksForGroup(group));
        }
        String otherGroupName = findOtherGroup(groups.keySet());
        if (otherGroupName != null && groups.keySet().contains(DEFAULT_GROUP)) {

			}),
			[]string{"added"},
		),
	)

	r, _, _ := adder.AuthenticateRequest(nil)
	if want := []string{"original", "added"}; !reflect.DeepEqual(r.User.GetGroups(), want) {
		t.Errorf("Unexpected groups\ngot:\t%#v\nwant:\t%#v", r.User.GetGroups(), want)
	}

	if got := toJson(response); got != orig {
		t.Errorf("Expected response from delegate to be unmodified: orig=%v got=%v", orig, got)
	}
}

})(nil)

// The user info accessors known to cache key construction. If this fails to compile, the cache
// implementation may need to be updated.
var _ user.Info = (interface {
	GetName() string
	GetUID() string
	GetGroups() []string
	GetExtra() map[string][]string
})(nil)

// Authorize returns an authorization decision by delegating to another Authorizer. If an equivalent

    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) {

        for (Task task : tasks) {
            String group = GUtil.isTrue(task.getGroup()) ? task.getGroup() : DEFAULT_GROUP;
            groups.put(group, factory.create(task));
        }
        return new SingleProjectTaskReportModel(groups);
    }

    private final SetMultimap<String, TaskDetails> groups;

        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();