"""
        }

        when:
        executer.withConsole(consoleType)
        succeeds(TEST_TASK_NAME)

        then:
        if (result.groupedOutput.hasTask(TEST_TASK_PATH)) {
            def taskOutput = getTaskOutput(result).readLines().findAll { !it.isBlank() }.join('\n')
            assert !taskOutput.contains("""MyTest > testExpectation ${TestLogEvent.STANDARD_OUT.consoleMarker}
    standard output""")

            exec.setIgnoreExitValue(true);
            ExecResult result = exec.build().start().waitForFinish();
            int exitValue = result.getExitValue();
            if (exitValue == 0) {
                return parseExecOutput(jdkPath, out.toString());
            }
            String errorMessage = "Command returned unexpected result code: " + exitValue + "\nError output:\n" + errorOutput;

        if (result.hasOneUse() && isa<QuantizeOpT>(*result.user_begin())) {
          auto user = cast<QuantizeOpT>(*result.user_begin());
          outputs_replaced.insert(
              {user.getResult(), enumerated_result.index()});
          output_types.push_back(user.getType());
        } else if (!result_ele_type.isF32()) {
          // If the result is an integer tensor, then it doesn't require the
          // D op in the pattern.

    op_to_update = op_to_update->getParentOp();

  for (Value result : op_to_update->getResults()) {
    if (mlir::isa<tf_executor::TokenType>(result.getType())) continue;
    if (mlir::isa<tf_executor::ControlType>(result.getType())) break;

    value_to_device.insert({result, device});
  }
}

// Checks if an operation can have TPU devices propagated through.
bool IsSupportedOpToSetDevice(Operation& op) {

					errChan <- err
					return
				}
				resultChan <- result
			}(resultChan, errChan, parent, c.specifiedConfName, tempDir, c.chainedCNIPlugin)

			select {
			case result := <-resultChan:
				if len(c.delayedConfName) > 0 {
					// Delayed case
					t.Fatalf("did not expect to retrieve a CNI config file %s", result)
				} else if result != expectedFilepath {
					if len(expectedFilepath) > 0 {

import org.gradle.api.internal.artifacts.result.DefaultArtifactResolutionResult;
import org.gradle.api.internal.artifacts.result.DefaultComponentArtifactsResult;
import org.gradle.api.internal.artifacts.result.DefaultResolvedArtifactResult;
import org.gradle.api.internal.artifacts.result.DefaultUnresolvedArtifactResult;
import org.gradle.api.internal.artifacts.result.DefaultUnresolvedComponentResult;

        StringBuilder result = new StringBuilder();
        Iterator<String> iterator = strings.iterator();

        while (iterator.hasNext()) {
            result.append(iterator.next());
            if (iterator.hasNext()) {
                result.append(delimiter);
            }
        }

        return result.toString();
    }

    private final transient DependencyResolutionResult result;
    private final transient String detailMessage;

    public DependencyResolutionException(DependencyResolutionResult result, String message, Throwable cause) {
        super(message, cause);
        this.result = result;
        this.detailMessage = prepareDetailMessage(message, result);
    }

            throws ArtifactResolutionException {
        List<ArtifactResult> results = new ArrayList<>();

        for (ArtifactRequest request : requests) {
            ArtifactResult result = new ArtifactResult(request);
            results.add(result);

            Artifact artifact = request.getArtifact();
            if ("maven-test".equals(artifact.getGroupId())) {

        List<SomeToolingModel> result = new ArrayList<>();
        GradleBuild buildModel = controller.getBuildModel();
        collectModelsForProjects(controller, result, buildModel);
        for (GradleBuild build : buildModel.getEditableBuilds()) {
            collectModelsForProjects(controller, result, build);
        }
        return result;
    }