groupSet("org", "org2")                                                                                        | groupSet("org2", "org3")                                                                                              | group("org2")

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

    ExcludeSpec ivyPatternExclude(ModuleIdentifier moduleId, IvyArtifactName artifact, String matcher);

    ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules);

    GroupSetExclude groupSet(Set<String> groups);

    ModuleSetExclude moduleSet(Set<String> modules);

    default ExcludeSpec fromUnion(Set<ExcludeSpec> remainder) {
        if (remainder.isEmpty()) {

    @Override
    public ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules) {
        return delegate.moduleIdSet(modules);
    }

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

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

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

    ExcludeSpec moduleId(String group, String name) {
        factory.moduleId(newId(group, name))
    }

    }

    @Override
    public ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules) {
        return DefaultModuleIdSetExclude.of(modules);
    }

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

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

            case "module ids":
                return "moduleIdSet(${value.collect { "'${anonymize(it)}'" }.join(', ')})"
            case "groups":
                return "groupSet(${value.collect { "'${anonymize(it)}'" }.join(', ')})"
            default:
                throw new UnsupportedOperationException("Not yet implemented for $opType")
        }
    }

    }

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

    ModuleIdSetExclude nextModuleIdSet() {

            // If there's more than group, merge them into a group set
            if (groupExcludes.size() > 1 || !groupSetExcludes.isEmpty()) {
                GroupSetExclude excludeSpec = delegate.groupSet(groupExcludes.stream().map(GroupExclude::getGroup).collect(toSet()));
                if (groupSetExcludes.isEmpty()) {
                    groupSetExcludes = ImmutableList.of(excludeSpec);
                } else {

    private final Grouper<K> grouper;
    private final Namer<K> namer;
    private final FileAccessTracker checksumDirAccessTracker;
    private final File baseDir;
    private final ChecksumService checksumService;

    public GroupedAndNamedUniqueFileStore(File baseDir, TemporaryFileProvider temporaryFileProvider, FileAccessTimeJournal fileAccessTimeJournal, Grouper<K> grouper, Namer<K> namer, ChecksumService checksumService) {