feed {
  id { node_name: "y_const" }
  shape {
    dim { size: 1 }
  }
}
feed {
  id { node_name: "z" output_index: 1}
  shape {
    dim { size: 1 }
  }
  type: DT_INT32
}
fetch {
  id { node_name: "x_y_sum" }
}
fetch {
  id { node_name: "x_z_sum" }

        assertNotNull(new Organization().toString());
    }

    public void testToStringNotNonsense11() {
        Organization org = new Organization();
        org.setName("Testing Maven Unit");
        org.setUrl("https://maven.localdomain");

        assertEquals("Organization {name=Testing Maven Unit, url=https://maven.localdomain}", org.toString());
    }

    public void testToStringNotNonsense10() {

	}

	ret := &caProvider{
		caLoader: caLoader,
	}
	if err := ret.setCA(); err != nil {
		return nil, err
	}

	return ret, nil
}

type caProvider struct {
	caValue  atomic.Value
	caLoader *dynamiccertificates.DynamicCertKeyPairContent
}

// setCA unconditionally stores the current cert/key content
func (p *caProvider) setCA() error {
	certPEM, keyPEM := p.caLoader.CurrentCertKeyContent()

        label = "Istio Agent"
        color="orange"
        sds
        SecretManager -> caClient [label="Sign CSR"]
        caClient -> grpc
        grpc -> TokenProvider [dir=none,label="Fetch JWT",color=purple]
        grpc -> cfiles [dir=none,label="Fetch Cert",color=purple]

        sds -> SecretManager [label="Generate certificate"]
        SecretManager -> cfiles [label="Write certs to file"]
        cfiles [label="Certificate Files"]

    }
    tf_executor.fetch %island : !tf_executor.control
    // expected-remark@above {{ID: 4}}
    // expected-remark@above {{Predecessors: {3}}}
  }
  func.return
  // expected-remark@above {{ID: 6}}
  // expected-remark@above {{Sinks: {5}}}
}

// -----

// Tests that we create dependencies to a fetch op, even if the fetch op has

        when:
        def result = withConnection {
            action(new NoOpBuildAction()).run()
        }

        then:
        result == "result"
    }

    def "Can fetch build scoped models from included builds"() {
        given:
        singleProjectBuildInRootFolder("root") {
            settingsFile << """
                includeBuild 'includedBuild'
            """
        }

// CHECK-NEXT:        "tf_executor.yield"(%{{.*}}) : (tensor<f32>) -> () loc("identity@some_function")
// CHECK-NEXT:      }) : () -> (tensor<f32>, !tf_executor.control) loc("identity@some_function")
// CHECK-NEXT:      "tf_executor.fetch"(%{{.*}}) : (tensor<f32>) -> () loc(unknown)
// CHECK-NEXT:    }) : () -> tensor<f32> loc(unknown)
// CHECK-NEXT:    "func.return"(%{{.*}}) : (tensor<f32>) -> () loc(unknown)

plugins {
    `java-library`
}

repositories {
    maven {
        setUrl(uri("../repo"))
    }
    mavenCentral()
}

// tag::consumer[]
dependencies {
    // This project requires the main producer component
    implementation("org.gradle.demo:producer:1.0")

    // But we also want to use its MongoDB support
    runtimeOnly("org.gradle.demo:producer:1.0") {
        capabilities {

  }

  Operation &fetch = graph.GetBody().back();
  if (!isa<FetchOp>(fetch))
    return fetch.emitOpError()
           << "invalid tf_executor.graph terminator, fetch expected";

  // Ensure that the fetch terminator operands matches the graph result type.
  // All the non-control operands of the fetch operation must match the graph
  // returned value.
  if (fetch.getNumOperands() < graph.getNumResults())

      tf_executor.fetch
    }
    func.return
  }

  func.func private @indexed_case_branch0_40(%arg0: tensor<i32>) -> tensor<*xi32> {
    %0 = tf_executor.graph {