if (state.iterations() >= state.max_iterations && async) {
      TFE_Executor* executor = TFE_ContextGetExecutorForThread(ctx);
      TFE_ExecutorWaitForAllPendingNodes(executor, status);
      ASSERT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
      TFE_DeleteExecutor(executor);
    }
  }
  TFE_DeleteOp(matmul);
  TFE_DeleteTensorHandle(m);
  TFE_DeleteContext(ctx);

        when: "publish a new integration version"
        resetExpectations()
        repository {
            'group:projectB:2.3'()
        }
        executer.withArgument('-PrefreshDynamicVersions')

        then:
        repositoryInteractions {
            'group:projectA' {
                expectHeadVersionListing()
            }
            'group:projectB' {

    /**
     * Executes a Java main class. The closure configures a {@link org.gradle.process.JavaExecSpec}.
     *
     * @param closure The closure for configuring the execution.
     * @return the result of the execution
     */
    ExecResult javaexec(@DelegatesTo(JavaExecSpec.class) Closure closure);

    /**
     * Executes an external Java process.
     * <p>

[[communicating_test_results_to_CI_servers_and_other_tools_via_xml_files]]
=== Communicating test results to CI servers and other tools via XML files

        private final ConcurrentMap<String, Object> parentCache;
        private final ModelTransformerContextBuilder transformerContextBuilder;
        private final ExecutorService executor;
        private final ModelCache modelCache;
        private final ModelResolver modelResolver;

        BuildSession(ProjectBuildingRequest request, boolean localProjects) {
            this.request = request;

This is a strictly sequential and formally correct fallback option for the
embedding pipelining pass intended for debugging during pipelining
development.
### `-tf-executor-break-up-islands`

_Transform from TF control dialect to TF executor dialect._

### `-tf-executor-check-control-dependencies`

_Checks control dependencies_

This pass analyzes control dependencies between islands and warns about

    def "virtual platform missing modules are cached across builds"() {
        // Disable daemon, so that the second run executes with the file cache
        // and therefore make sure that we read the "missing" status from disk
        executer.withArgument('--no-daemon')

        repository {
            path 'xml -> core'
            path 'json -> core'
            path 'xml:1.1 -> core:1.1'

    }
}
"""
    }

    def "transform can access artifact dependencies as a set of files when using ArtifactView"() {
        given:
        setupBuildWithSingleStep()

        when:
        executer.withArgument("--parallel")
        run ":app:resolveGreen"

        then:
        output.count('Transforming') == 5

        given:
        serviceImplementation()
        adhocTaskUsingUndeclaredService(1)
        enableStableConfigurationCache()
        executer.expectDocumentedDeprecationWarning(
            "Build service 'counter' is being used by task ':broken' without the corresponding declaration via 'Task#usesService'. " +
                "This behavior has been deprecated. " +

		startTime:                 us.clk.Now(),
		execSeatsIntegrators:      make([]fq.Integrator, len(us.clients)),
		seatDemandIntegratorCheck: fq.NewNamedIntegrator(us.clk, us.name+"-seatDemandCheck"),
		executions:                make([]int32, len(us.clients)),
		rejects:                   make([]int32, len(us.clients)),
	}
	for _, uc := range us.clients {
		uss.doSplit = uss.doSplit || uc.split
	}
	uss.exercise()
}