}

class FallbackAsync_Op<string mnemonic, list<Trait> traits = []> :
    Op<FallbackAsync_Dialect, mnemonic, !listconcat(traits, [IsolatedFromAbove])> {
}

def SetResourceOp : FallbackAsync_Op<"set_resource", [CoreRT_TypedAttributeTrait]> {
  let summary = "Set a tensor in resource array";

  let description = [{
    Set a tensor in resource array.

    arg: the tensor to be set in the resource array.

    Variadic<MlrtFutureType>:$results
  );

  let assemblyFormat = "`(` $device`)` `(` $args `)` attr-dict `:` functional-type($args, $results)";
}

def SetResourceOp : TensorflowMlrt_Op<"set_resource", []> {
  let summary = "Set a tensor in resource array";

  let description = [{
    Set a tensor in resource array.

    arg: the tensor to be set in the resource array.

      container_name, plugin_resource_name, &tf_plugin_resource,
      [plugin_resource_name, create_func, create_func_args,
       delete_func](tensorflow::PluginResource** new_resource) {
        void* opaque_plugin_resource = create_func(create_func_args);
        *new_resource = new tensorflow::PluginResource(
            opaque_plugin_resource, plugin_resource_name, delete_func);
        return absl::OkStatus();
      });

        assertNull(source.getResource().getCharset());
        assertThat(source.getResource().getLocation().getFile(), equalTo(scriptFile));
        assertThat(source.getResource().getLocation().getURI(), equalTo(scriptFileUri));
        assertThat(source.getResource().getText(), equalTo(""));
        assertTrue(source.getResource().isContentCached());
        assertTrue(source.getResource().getHasEmptyContent());

  {
    // Function for While's "body".
    // "arg0" (T=DT_RESOURCE), "arg1" (T=DT_RESOURCE), "arg2" (T=DT_INT32)
    // "ret0" = "arg1"
    // "ret1" = "arg0"
    tensorflow::Scope s = tensorflow::Scope::NewRootScope();
    Output arg0 = ops::_Arg(s.WithOpName("arg0"), DT_RESOURCE, 0);
    Output arg1 = ops::_Arg(s.WithOpName("arg1"), DT_RESOURCE, 1);
    Output arg2 = ops::_Arg(s.WithOpName("arg2"), DT_INT32, 2);

        then:
        child.localClassLoader.getResource("root").text == "root"
        child.localClassLoader.getResource("export").text == "bar"
        child.localClassLoader.getResource("local") == null
        child.exportClassLoader.getResource("root").text == "root"
        child.exportClassLoader.getResource("export").text == "bar"
        child.exportClassLoader.getResource("local") == null
    }

        def url = writePluginProperties(TestPlugin1)

        given:
        classLoader.getResource("META-INF/gradle-plugins/org.gradle.somePlugin.properties") >> url
        classLoader.getResource("META-INF/gradle-plugins/somePlugin.properties") >> { throw new RuntimeException() }
        classLoader.loadClass(TestPlugin1.name) >> TestPlugin1

        expect:

  auto d = ops::Placeholder(scope.WithOpName("D"), DT_FLOAT);
  auto u = ops::Placeholder(scope.WithOpName("U"), DT_RESOURCE);
  auto v = ops::Placeholder(scope.WithOpName("V"), DT_RESOURCE);
  auto w = ops::Placeholder(scope.WithOpName("W"), DT_RESOURCE);

  NodeDef def;
  TF_CHECK_OK(NodeDefBuilder("launch0", function, &flib_def)
                  .Input(a.node()->name(), 0, DT_INT32)

                        return new FileModelSource(new File(getClass()
                                .getResource("/poms/depmgmt/import.xml")
                                .getFile()));
                    case "test:other:pom":
                        return new FileModelSource(new File(getClass()
                                .getResource("/poms/depmgmt/other-import.xml")
                                .getFile()));

        def resource = Mock(ExternalResource)
        def localCandidates = Mock(LocallyAvailableResourceCandidates)

        when:
        def result = cache.getResource(location, null, fileStore, localCandidates)

        then:
        result == null

        and:
        1 * index.lookup("thing") >> null
        1 * localCandidates.isNone() >> true