auto module_or = GraphdefToMlirImport(
      input, input_arrays, input_dtypes, input_shapes, output_arrays,
      control_output_arrays, import_options, context);
  if (!module_or.status().ok()) {
    LOG(ERROR) << "Graph import failed: " << module_or.status();
    return module_or.status();
  }
  auto& module = module_or.value();
  std::srand(0);

        moduleId("org", "foo")                                                                                         | moduleId("org2", "baz")                                                                                               | nothing()

        when:
        def action = descriptor.toContentFilter()
        details.moduleId >> fooMod
        details.componentId >> DefaultModuleComponentIdentifier.newId(fooMod, '1.0')
        action.execute(details)

        then:
        0 * details.notFound()

        when:
        details.moduleId >> barMod
        details.componentId >> DefaultModuleComponentIdentifier.newId(barMod, '1.0')

                resolvedOrRejected(id, rejector, result)
                return
            }

            def resolved = findDynamicVersion(acceptor, rejector)
            if (resolved) {
                def id = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(moduleId.group, moduleId.name), resolved as String)

        then:
        def depA = metadata.dependencies.find { it.selector.group == 'group-a'}
        depA.selector == moduleId('group-a', 'module-a', '1.0')
        !depA.optional
        depA.transitive
        def depB = metadata.dependencies.find { it.selector.group == 'group-b'}
        depB.selector == moduleId('group-b', 'module-b', '2.0')
        depB.constraint
        !depB.transitive
    }

  mlir::MLIRContext context(registry);
  auto module_or = ConvertSavedModelToMlir(
      &bundle, &context, absl::Span<std::string>(exported_names));
  if (!module_or.status().ok()) {
    tsl::Set_TF_Status_from_Status(status, module_or.status());
    return "// error";
  }

  return MlirModuleToString(*std::move(module_or).value(), show_debug_info);
}

    }

    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:

    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 (saved_model_version == 2) {
    auto module_or = SavedModelObjectGraphToMlirImport(
        input_filename, tags, exported_names, context,
        /*unconditionally_use_set_output_shapes=*/true);
    if (!module_or.status().ok()) return module_or.status();
    return std::move(module_or).value();
  } else if (saved_model_version == 1) {
    MLIRImportOptions options;

                    final ModuleIdentifier moduleId = ((UnversionedModuleComponentSelector) substituted).getModuleIdentifier();
                    if (notation instanceof ModuleComponentSelector) {
                        if (((ModuleComponentSelector) notation).getModuleIdentifier().equals(moduleId)) {
                            // This substitution is effectively a force