/**
     * Declares that an entire group should be searched for in this repository.
     *
     * @param group the group name
     */
    void includeGroup(String group);

    /**
     * Declares that an entire group and its subgroups should be searched for in this repository.
     *
     * <p>
     * A subgroup is a group that starts with the given prefix and has a dot immediately after the prefix.

        if (group != null ? !group.equals(that.group) : that.group != null) {
            return false;
        }
        if (module != null ? !module.equals(that.module) : that.module != null) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int result = group != null ? group.hashCode() : 0;

			if label != "" {
				// add phase to existing group, or start a new group
				l := commonPrefix(group.label, label)
				if group.size == 1 && l != "" || group.size > 1 && l == group.label {
					// add to existing group
					group.label = l
					group.tot += dt
					group.size++
				} else {
					// start a new group
					if group.size > 1 {
						lines.add(prefix+group.label+"subtotal", 1, group.tot, tot, nil)
					}

        def repo1MetaData = repo1.getModuleMetaData("group", "projectA")
        def repo1DirList = repo1.directory("group", "projectA")
        def repo1Module = repo1.module("group", "projectA", "1.1")
        def repo2MetaData = repo2.getModuleMetaData("group", "projectA")
        def repo2Module = repo2.module("group", "projectA", "1.0").publish()
        def repo2Module2 = repo2.module("group", "projectA", "1.1")

								Storage: true,
							},
						},
					},
				},
			},
			version: schema.GroupVersion{Group: "group.com", Version: "v1"},

			expectedAdded: []*apiregistration.APIService{
				{
					ObjectMeta: metav1.ObjectMeta{Name: "v1.group.com"},
					Spec: apiregistration.APIServiceSpec{
						Group:                "group.com",
						Version:              "v1",
						GroupPriorityMinimum: 1000,
						VersionPriority:      100,

        keys*.keyId == [KEY_1]
        keys[0].group == 'org'
        keys[0].name == null
        keys[0].version == null
        keys[0].fileName == null
    }

    def "groups entries which have a common group prefix"() {
        grouper {
            entry("org.group.a", "foo", "1.0", "foo-1.0.jar").addVerifiedKey(KEY_1)
            entry("org.group.a", "foo", "1.0", "foo-1.0.pom").addVerifiedKey(KEY_1)

    }

    private final String group;
    private final String name;
    private final String version;

    public DefaultModuleDependencySpec(String group, String name, String version) {
        if (group == null || name == null) {
            throw new IllegalDependencyNotation("A module dependency must have at least a group and a module name specified.");
        }
        this.group = group;
        this.name = name;

        when:
        container.module("m1").group("g1")
        container.group("g2").module("m2")

        then:
        container.dependencies*.displayName == ["g1:m1:+", "g2:m2:+"]
    }

    def "filters duplicate module dependency specs"() {
        when:
        container.module("m1").group("g1")
        container.group("g1").module("m1")

        then:

//
// [errgroup.Group] is related to [sync.WaitGroup] but adds handling of tasks
// returning errors.
package errgroup

import (
	"context"
	"fmt"
	"sync"
)

type token struct{}

// A Group is a collection of goroutines working on subtasks that are part of
// the same overall task.
//
// A zero Group is valid, has no limit on the number of active goroutines,

        'non-matching group'     | [group: 'other']  | []
        'child name of sibling'  | [module: 'e']     | []
        'child group of sibling' | [group: 'e']      | []
        'all child modules'      | [module: '*']     | ['d']
        'all child groups'       | [group: '*']      | ['d']
        'name child module'      | [module: 'd']     | ['d']
        'name child group'       | [group: 'd']      | ['d']
    }