}

    @Override
    public void visitEdges(DependencyGraphNode node) {
        resolutionResultBuilder.visitOutgoingEdges(node.getOwner().getResultId(), node.getOutgoingEdges());
    }

    @Override
    public void finish(RootGraphNode root) {
        Long resultId = root.getOwner().getResultId();
        this.root = resolutionResultBuilder.getRoot(resultId);
        this.requestAttributes = root.getResolveState().getAttributes();
    }

      auto tf_reduce_op = rewriter.create<BooleanReduce>(
          reduce_op.getLoc(), reduce_op->getResult(0).getType(), operand,
          reduction_indices,
          /*keep_dim=*/rewriter.getBoolAttr(false));
      auto tf_argreduce_op = rewriter.create<ArgReduce>(
          reduce_op.getLoc(), reduce_op->getResult(1).getType(), operand,
          reduction_indices);

                try {
                    // probe if the artifact exists
                    result.getResult().getFile();
                } catch (Exception e) {
                    // Optional artifact is not available
                    continue;
                }
            }
            resolvedArtifacts.add(result.getResult());
        }
        return resolvedArtifacts.build();
    }

    }

    @Override
    public void report(CrossVersionPerformanceResults results) {
        if (!testIds.add(results.getTestId())) {
            throw new IllegalArgumentException(String.format("Multiple performance test executions with id '%s' found.", results.getTestId()));
        }
        for (DataReporter<CrossVersionPerformanceResults> reporter : reporters) {
            reporter.report(results);
        }

    public DefaultExecOutput(Provider<ExecOutputData> dataProvider) {
        this.dataProvider = dataProvider;
    }

    @Override
    public Provider<ExecResult> getResult() {
        return dataProvider.map(transformer(ExecOutputData::getResult));
    }

    @Override
    public StandardStreamContent getStandardOutput() {
        return new DefaultStandardStreamContent(dataProvider.map(transformer(ExecOutputData::getOutput)));

    assertEquals(null, getResponse(methodName).getResult());
  }

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned the
   * expected boolean value.
   */
  public void assertPriorCallReturns(boolean expected, @Nullable String methodName)
      throws Exception {
    assertEquals(expected, getResponse(methodName).getResult());
  }

  /**

package org.gradle.tooling.events.test;

import org.gradle.tooling.events.FinishEvent;

/**
 * An event that informs about a test having finished its execution. You can query the result of the
 * test using {@link #getResult()}.
 *
 * @since 2.4
 */
public interface TestFinishEvent extends TestProgressEvent, FinishEvent {

    /**
     * Returns the result of the finished test operation. Currently, the result will be one of the following

            @Override
            void visit(NodeAccess value) {
                currentValue = visitor.apply(currentValue, value.getNode());
            }

            @Override
            T getResult() {
                return currentValue;
            }
        });
    }

    /**
     * Returns all nodes which access the location, taking into account the filter.
     *

              QuantizedType::getQuantizedElementType(q.getArg().getType())) {
        rewriter.setInsertionPoint(op);
        rewriter.replaceOpWithNewOp<quantfork::DequantizeCastOp>(
            op, op.getResult().getType(), q.getArg());
        return success();
      }

      op.replaceAllUsesWith(q.getArg());
      return success();
    }
    return failure();
  }
};

            if (extractionContext.hasProblems()) {
                throw new InvalidManagedModelElementTypeException(extractionContext);
            }
            if (extractionContext.getResult() != null) {
                cache.set(type, extractionContext.getResult());
                return;
            }
        }

        // Should never get here, the last strategy should be a catch all