throw new PluginResolutionException(
                    plugin, e.getResult().getExceptions(), logger.isDebugEnabled() ? e : null);
        } catch (DependencyResolutionException e) {
            throw new PluginResolutionException(
                    plugin, e.getResult().getCollectExceptions(), logger.isDebugEnabled() ? e : null);
        }
    }

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

  /**

      return;
    }

    const Type expressed_type = op->getResult(0).getType();
    const Type quantized_type =
        quant_type.castFromExpressedType(expressed_type);

    rewriter.setInsertionPointAfter(op);
    auto q = rewriter.create<quantfork::QuantizeCastOp>(
        op->getLoc(), quantized_type, op->getResult(0));
    auto dq = rewriter.create<quantfork::DequantizeCastOp>(op->getLoc(),

    // Insert quantize ops for every outputs and rewrite.
    for (int i = 0; i < op->getNumResults(); ++i) {
      auto result = op->getResult(i);
      auto result_type = result.getType();

      Value new_result = new_op->getResult(i);
      if (IsQI8Type(result_type) || IsQUI8Type(result_type)) {
        builder->setInsertionPoint(op);
        TFL::QuantizeOp quant_op = builder->create<TFL::QuantizeOp>(

    auto it =
        shared_name_to_arg_idx.insert({shared_name, block.getNumArguments()});
    if (it.second) {
      auto resource_type = op.getResult(0).getType();
      op.getResult(0).replaceAllUsesWith(
          block.addArgument(resource_type, op.getLoc()));
      AddEntryFunctionInput(
          absl::StrCat("hash_table_", it.first->getValue(), ":0"), target_func);

        1 * phasedActionResultListener.onResult({
            it.getPhase() == PhasedActionResult.Phase.PROJECTS_LOADED &&
                it.getResult() == result1
        })
        1 * phasedActionResultListener.onResult({
            it.getPhase() == PhasedActionResult.Phase.BUILD_FINISHED &&
                it.getResult() == result2
        })
        0 * delegateEventConsumer.dispatch(_)
    }

namespace mlir {
namespace TFL {

// For add/mul/div/sub and other broadcastable ops.
class ArithmeticCountUtilHelper {
 public:
  static bool GetFirstOutputCount(mlir::Operation* op, int64_t* count) {
    auto output = op->getResult(0);
    auto output_type =
        mlir::dyn_cast_or_null<mlir::RankedTensorType>(output.getType());
    if (!output_type || !output_type.hasStaticShape()) return false;

    *count = output_type.getNumElements();

  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveAllPropagatesToGet() {
    Collection<V> getResult = multimap().get(k0());

    multimap().removeAll(k0());

    assertEmpty(getResult);
    expectMissing(e0());
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveAllMultipleValues() {

                                        new_op->getResult(0), dump_attributes);

      if (debugger_type_ == DebuggerConfig::DEBUGGER_TYPE_FLOAT_PER_LAYER) {
        // Swap all uses between call_op and ref_call_op, except for the
        // particular use that owns DumpTensor.
        rewriter.replaceUsesWithIf(
            op.getResult(0), new_op->getResult(0), [](OpOperand &use) -> bool {

          auto result = graph.getResult(arg.getOperandNumber());
          this->join(getLatticeElement(result), *getLatticeElement(arg.get()));
        }
      }
    } else if (auto island = dyn_cast<tf_executor::IslandOp>(op)) {
      for (auto &arg : island.GetYield()->getOpOperands()) {
        auto result = island.getResult(arg.getOperandNumber());