if (componentId instanceof ModuleComponentIdentifier) {
                ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) componentId;
                resolvedComponentVersions.put(moduleId.getModuleIdentifier(), moduleId.getVersion());
            }

        }, Actions.doNothing(), new HashSet<>());

        return resolvedComponentVersions;
    }

  }
  auto module_out = std::move(module_or_status).value();

  // We cannot replace the module in a ModulePass. So we simply copy the
  // operation list from module_out to module_in.
  auto& module_in_ops = module_in.getBody()->getOperations();
  module_in_ops.clear();
  module_in_ops.splice(module_in_ops.end(),
                       module_out->getBody()->getOperations());
}

        MutableIvyModuleResolveMetadata metadata = parseIvyFile(publication);
        ModuleVersionIdentifier moduleId = metadata.getModuleVersionId();
        organisation.matches(moduleId.getGroup());
        moduleName.matches(moduleId.getName());
        revision.matches(moduleId.getVersion());

        field(publication, "branch", metadata.getBranch())
                .optionalNotEmpty()

        return replacements.get(sourceModule);
    }

    @Override
    public boolean participatesInReplacements(ModuleIdentifier moduleId) {
        return targets.contains(moduleId) || replacements.containsKey(moduleId);
    }

    private static void detectCycles(Map<ModuleIdentifier, Replacement> replacements, ModuleIdentifier source, ModuleIdentifier target) {
        if (source.equals(target)) {

        }

        @Override
        public void onChangingModuleResolve(ModuleComponentIdentifier moduleId, Expiry expiry) {
        }
    };

    /**
     * Called when a dynamic version is selected using the set of candidate versions queried from a repository.
     */

import org.gradle.test.preconditions.UnitTestPreconditions

import static org.gradle.test.fixtures.jpms.ModuleJarFixture.autoModuleJar
import static org.gradle.test.fixtures.jpms.ModuleJarFixture.moduleJar
import static org.gradle.test.fixtures.jpms.ModuleJarFixture.traditionalJar

@Requires(UnitTestPreconditions.Jdk9OrLater)
abstract class AbstractJavaModuleIntegrationTest extends AbstractIntegrationSpec {

import java.util.Set;

public interface ModuleVersionsCache {

    void cacheModuleVersionList(ModuleComponentRepository<?> repository, ModuleIdentifier moduleId, Set<String> listedVersions);

    CachedModuleVersionList getCachedModuleResolution(ModuleComponentRepository<?> repository, ModuleIdentifier moduleId);

    interface CachedModuleVersionList {
        Set<String> getModuleVersions();

        Duration getAge();
    }

            } else {
                String version = acceptor.getSelector();
                ModuleIdentifier moduleId = module.getModuleIdentifier();
                ModuleComponentIdentifier id = DefaultModuleComponentIdentifier.newId(moduleId, version);
                ModuleVersionIdentifier mvId = DefaultModuleVersionIdentifier.newId(moduleId, version);
                if (rejector != null && rejector.accept(version)) {

    }

    protected static ModuleComponentSelector moduleId(String group, String name, String version) {
        DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId(group, name), new DefaultMutableVersionConstraint(version))
    }

    protected ArtifactRevisionId artifactId(ModuleRevisionId moduleId, String name, String type, String ext) {
        ArtifactRevisionId.newInstance(moduleId, name, type, ext)
    }

 * limitations under the License.
 */

package org.gradle.test.fixtures.ivy

import org.apache.ivy.core.IvyPatternHelper
import org.apache.ivy.core.module.id.ModuleId
import org.apache.ivy.core.module.id.ModuleRevisionId

class M2CompatibleIvyPatternHelper {

    static String substitute(String pattern, String organisation, String module, String revision, boolean m2Compatible) {