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() {

        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'
            """
        }

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 {

// 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)

        profile.setId("pro");
        settings.addProfile(profile);
        Repository repo1 = new Repository();
        repo1.setUrl("http://apache.org/");
        repo1.setId("test");
        profile.addRepository(repo1);
        Repository repo2 = new Repository();
        repo2.setUrl("http://apache.org/");
        repo2.setId("test");
        profile.addRepository(repo2);

  }

  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())

tasks.withType<PublishToMavenRepository>().configureEach {
    notCompatibleWithConfigurationCache("Configures repository at execution time")
    doFirst {
        val address = com.example.MavenRepositoryStub.start()
        getRepository().setUrl(address)
    }
    doLast {
        com.example.MavenRepositoryStub.stop()
    }

        accessResult1.setParentUrl("http://www.parent.com/");
        accessResult1.setRuleId("htmlRule");
        accessResult1.setSessionId("id1");
        accessResult1.setStatus(200);
        accessResult1.setUrl("http://www.id1.com/");

        dataService.store(accessResult1);

        final EsAccessResult accessResult2 = dataService.getAccessResult("id1", "http://www.id1.com/");
        assertNotNull(accessResult2);