}

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

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

    ExcludeSpec moduleIdSet(List<String>... ids) {
        factory.moduleIdSet(RandomizedIteratorHashSet.of(ids.collect { newId(it[0], it[1]) } as Set<ModuleIdentifier>))

        def moduleFixture = parseIml(file ( 'root.iml'))
        def sources = moduleFixture.getContent().getProperty("sources")
        def integTestSource = sources.find { s -> s.url == 'file://$MODULE_DIR$/src/integTest/java' }
        assert integTestSource.isTestSource
    }

        List<SourceFolder> sources
        List<ExcludeFolder> excludes

        void assertContainsSourcePaths(String... paths) {
            def sourceRoots = sources.collect {
                it.url - 'file://$MODULE_DIR$/'
            } as Set

            def setDiff = CollectionUtils.diffSetsBy(sourceRoots, CollectionUtils.toSet(paths as List), InternalTransformers.noOpTransformer())
            assert setDiff.leftOnly.empty

            return Collections.emptySet();
        }

        ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) module.getId();
        IvyArtifactName ivyArtifactName = new DefaultIvyArtifactName(moduleId.getModule(), type, "jar", classifier);

        ModuleComponentArtifactMetadata artifact = new DefaultModuleComponentArtifactMetadata(moduleId, ivyArtifactName);

        def ivyName = new DefaultIvyArtifactName("projectA", "pom", "pom")
        def moduleId = DefaultModuleIdentifier.newId(group, module)

        expect:
        pattern.toVersionListPattern(moduleId, ivyName).path == expectedPath

        where:
        group       | module     | expectedPath

        operationShouldNotHaveBeenCalled();
    }

    @Override
    public void cacheModuleVersionList(ModuleComponentRepository<?> repository, ModuleIdentifier moduleId, Set<String> listedVersions) {
        throw operationShouldNotHaveBeenCalled();
    }

    private static UnsupportedOperationException operationShouldNotHaveBeenCalled() {

        for (RenderableDependency childDependency : dependency.getChildren()) {
            ModuleIdentifier moduleId = getModuleIdentifier(childDependency);
            if (moduleId == null) {
                continue;
            }
            modules.add(moduleId);
            boolean alreadyVisited = !visited.add((ComponentIdentifier) childDependency.getId());
            if (!alreadyVisited) {

            ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) artifact.getId().getComponentIdentifier();
            SingleEntryModuleLibrary library = new SingleEntryModuleLibrary(toPath(ideaModule, artifact.getFile()), scope);
            library.setModuleVersion(DefaultModuleVersionIdentifier.newId(moduleId.getModuleIdentifier(), moduleId.getVersion()));
            Set<Path> sourcePaths = new LinkedHashSet<>();

            } else {
                // we need to make sure the variants we consider provide the implicit capability
                result = containsImplicitCapability(capabilities, moduleId.getGroup(), moduleId.getName());
            }
            if (result.matches) {
                if (lenient || result == MatchResult.EXACT_MATCH) {
                    builder.add(variant);
                }
            }

        moduleDescriptor.status == 'release'
        moduleDescriptor.publicationDate != null
        moduleDescriptor.moduleRevisionId.organisation == 'myorg'
        moduleDescriptor.moduleRevisionId.moduleId.name == 'parentMod'
        moduleDescriptor.moduleRevisionId.revision == 'parentRev'
    }