->cast<mlir::MLIRContext*>();

  // Load the saved model into MLIR TF dialect.
  absl::Span<std::string> exported_names(nullptr, 0);
  auto module_or =
      tensorflow::ConvertSavedModelToMlir(&bundle, context, exported_names);
  if (!module_or.status().ok()) {
    return None();
  }

  // Make a module to wrap MLIR module and allow getting strings and running
  // transforms.

    }

    def "remote access fails directly for module id #moduleId with layout #layoutPattern"() {
        given:
        def overrideMetadata = DefaultComponentOverrideMetadata.EMPTY
        def result = new DefaultBuildableModuleComponentMetaDataResolveResult()

        when:
        resolver(layoutPattern).getRemoteAccess().resolveComponentMetaData(moduleId, overrideMetadata, result)

        then:

"""

        when:
        parsePom()

        then:
        def dep = firstDependency(metadata.dependencies)
        dep.selector == moduleId('group-two', 'artifact-two', '1.2')
        dep.scope == MavenScope.Test
        def exclude = single(dep.allExcludes)
        exclude.moduleId == moduleIdentifierFactory.module('group-three', 'artifact-three')
        hasDefaultDependencyArtifact(dep)
    }

        def ivyName = new DefaultIvyArtifactName("ivy", "ivy", "xml")
        def moduleId = new DefaultModuleIdentifier(group, module)

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

        where:
        group       | module     | expectedPath

    private def assertId(ModuleVersionIdentifier moduleId, String group, String name, String version) {
        assert moduleId.group == group
        assert moduleId.name == name
        assert moduleId.version == version
    }

    private def assertId(ModuleComponentIdentifier moduleId, String group, String name, String version) {
        assert moduleId.group == group
        assert moduleId.module == name

            if (includeLast) {
                sb.append(" --> ");
                SelectorState selector = edge.getSelector();
                ModuleIdentifier moduleId = selector.getTargetModule().getId();
                sb.append('\'').append(moduleId.getGroup()).append(':').append(moduleId.getName()).append('\'');
                if (variantDetails != null) {
                    sb.append(variantDetails);
                }
            }

        ModuleVersionIdentifier moduleId = DefaultModuleVersionIdentifier.newId(project.getDependencyMetaDataProvider().getModule());
        LOGGER.info("Registering {} in composite build. Will substitute for module '{}'.", project, moduleId.getModule());
        availableModules.add(Pair.of(moduleId, projectIdentifier));
    }

    @Override

        given:
        File libJar = new File("lib.jar")
        File moduleJar = new File("module.jar")
        JavaModuleDetector moduleDetector = Mock(JavaModuleDetector) {
            inferModulePath(_, _) >> new AbstractFileCollection() {
                String getDisplayName() { '' }

                Set<File> getFiles() { [moduleJar] }
            }
            inferClasspath(_, _) >> new AbstractFileCollection() {

            return ModuleRevisionId.newInstance(org, name, branch, revConstraint, extraAttributes, replaceNullBranchWithDefault);
        }
    }

    public static ModuleId createModuleId(String org, String name) {
        synchronized (MODULE_ID_LOCK) {
            return ModuleId.newInstance(org, name);
        }
    }

        return DefaultExcludeAllOf.of(ImmutableSet.copyOf(specs));
    }

    @Override
    public ExcludeSpec ivyPatternExclude(ModuleIdentifier moduleId, IvyArtifactName artifact, String matcher) {
        return DefaultIvyPatternMatcherExcludeRuleSpec.of(moduleId, artifact, matcher);
    }

    @Override
    public ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules) {