*/

package org.gradle.tooling.events.task;

import org.gradle.tooling.events.FinishEvent;

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

    /**

  auto mul_op =
      rewriter.create<TF::MulOp>(squared_diff_op.getLoc(), result_type,
                                 sub_op.getResult(), sub_op.getResult());
  rewriter.replaceOp(squared_diff_op, mul_op.getResult());

  return success();
}

// ================== split ========================

LogicalResult UnrollSplit::matchAndRewrite(TFL::SplitOp split_op,

    }

    @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);

    }

    @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);
        }

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

    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

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