moduleIdSet(["g1", "m1"], ["g2", "m2"])                             | moduleSet("m1", "m2")                       | moduleSet("m1", "m2")
        moduleIdSet(["g1", "m1"], ["g2", "m2"], ["g3", "m3"])               | moduleSet("m1", "m2")                       | anyOf(moduleId("g3", "m3"), moduleSet("m1", "m2"))

        module("foo")                                                                                                  | moduleSet("bar", "baz")                                                                                               | factory.nothing()...

    }

    @Override
    public GroupSetExclude groupSet(Set<String> groups) {
        return delegate.groupSet(groups);
    }

    @Override
    public ModuleSetExclude moduleSet(Set<String> modules) {
        return delegate.moduleSet(modules);
    }

    ExcludeSpec group(String group) {
        factory.group(group)
    }

    ExcludeSpec module(String name) {
        factory.module(name)
    }

    ExcludeSpec moduleSet(String... names) {
        factory.moduleSet(RandomizedIteratorHashSet.of(names as Set<String>))
    }

    ExcludeSpec groupSet(String... groups) {
        factory.groupSet(RandomizedIteratorHashSet.of(groups as Set<String>))
    }

                def (group, name) = value.split(':')
                return "moduleId('${anonymize(group)}', '${anonymize(name)}')"
            case "module names":
                return "moduleSet(${value.collect { "'${anonymize(it)}'" }.join(', ')})"
            case "module ids":
                return "moduleIdSet(${value.collect { "'${anonymize(it)}'" }.join(', ')})"
            case "groups":

        parent2.collectAncestorsStrictVersions([parent2Edge])
        child.collectAncestorsStrictVersions([edge1, edge2])

        then:
        child.ancestorsStrictVersionConstraints.getModules() == moduleSet('a', 'b')
        parent1.ancestorsStrictVersionConstraints == root.ownStrictVersionConstraints
        parent2.ancestorsStrictVersionConstraints == root.ownStrictVersionConstraints
    }

    }

    @Override
    public GroupSetExclude groupSet(Set<String> groups) {
        return new DefaultGroupSetExclude(groups);
    }

    @Override
    public ModuleSetExclude moduleSet(Set<String> modules) {
        return new DefaultModuleSetExclude(modules);
    }

    ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules);

    GroupSetExclude groupSet(Set<String> groups);

    ModuleSetExclude moduleSet(Set<String> modules);

    default ExcludeSpec fromUnion(Set<ExcludeSpec> remainder) {
        if (remainder.isEmpty()) {
            // It's an intersection, and this method is always called on the remainder

            // If there's more than one module, merge them into a module set
            if (moduleExcludes.size() > 1 || !moduleSetExcludes.isEmpty()) {
                ModuleSetExclude excludeSpec = delegate.moduleSet(moduleExcludes.stream().map(ModuleExclude::getModule).collect(toSet()));
                if (moduleSetExcludes.isEmpty()) {
                    moduleSetExcludes = ImmutableList.of(excludeSpec);
                } else {

        FACTORY.group(randomGroupName())
    }

    ModuleIdExclude nextModuleId() {
        FACTORY.moduleId(randomModuleId())
    }

    ModuleSetExclude nextModuleSet() {
        FACTORY.moduleSet((0..(1 + random.nextInt(5))).collect { randomModuleName() } as Set<String>)
    }

    GroupSetExclude nextGroupSet() {
        FACTORY.groupSet((0..(1 + random.nextInt(5))).collect { randomGroupName() } as Set<String>)