}

  @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() {

        assign_group->getLoc(), assign_group.getResult(0).getType(),
        group_size);
    auto const_group_key = rewriter.create<TF::ConstOp>(
        assign_group->getLoc(), assign_group.getResult(1).getType(), group_key);
    rewriter.replaceAllUsesWith(assign_group.getResult(0), const_group_size);
    rewriter.replaceAllUsesWith(assign_group.getResult(1), const_group_key);
    rewriter.eraseOp(assign_group);

        _ * skippedEvent.getEventTime() >> 999
        _ * skippedEvent.getDisplayName() >> 'test suite skipped'
        _ * skippedEvent.getDescriptor() >> testDescriptor
        _ * skippedEvent.getResult() >> testResult

        adapter.onEvent(startEvent) // skippedEvent always assumes a previous startEvent
        adapter.onEvent(skippedEvent)

        then:

    // Introduce a transpose to the result to match the shapes of `op`'s uses.
    TransposeOp result_transpose_op = CreateTransposeOp(
        /*input=*/new_reduce_window_op.getResult(0), kNhwcToNchwPermutation,
        rewriter);

    rewriter.replaceAllUsesWith(op.getResult(0), result_transpose_op);
  }

 private:
  // Permutes `array_attr` with `permutation`. The number of elements in

      Operation* duplicated_dq_op = builder->clone(*dq);
      // Rewire the inputs.
      duplicated_dq_op->setOperand(0, duplicated_input_op->getResult(0));
      op->setOperand(index, duplicated_dq_op->getResult(0));
    } else {
      op->emitError()
          << "We cannot duplicate the value since it's not constant.\n";
      return failure();
    }
  }
  return success();
}

                    throw new SmbException("Server chose an unsupported mechanism " + targ.getMechanism());
                }
                this.selectedMech = targ.getMechanism();
                if ( targ.getResult() == NegTokenTarg.REQUEST_MIC ) {
                    this.requireMic = true;
                }
                this.firstResponse = false;
            }
            else {

            def snapshot = new StringValueSnapshot(it.toString())
            snapshot
        }
        1 * store.getIfPresent(_) >> Stub(CrossBuildCachingRuleExecutor.CachedEntry) {
            getResult() >> new Result(length: 123)
        }
        1 * validator.isValid(_, _) >> true
        0 * _
        result.length == 123
    }

    void "if cache expired, re-executes the rule"() {

  Value tensor_list = tensor_list_op.getResult();
  std::vector<OpOperand*> uses;
  for (auto& use : tensor_list.getUses()) {
    uses.emplace_back(&use);
  }
  OpBuilder builder(tensor_list_op.getOperation());
  for (OpOperand* operand : uses) {
    auto new_op = builder.clone(*tensor_list_op.getOperation());
    operand->set(new_op->getResult(0));
  }
}

        @Nullable
        Object getBuildFinishedAction();

        void collectActionResult(SerializedPayload serializedResult, PhasedActionResult.Phase phase);

        @Nullable
        SerializedPayload getResult();

        boolean isRunTasks();
    }

    private class ActionAdapter implements BuildTreeModelAction<SerializedPayload> {
        private final ClientAction clientAction;

  LogicalResult match(quantfork::DequantizeCastOp op) const final {
    // Match only when there is one user of the dequantize op.
    if (!op.getResult().hasOneUse()) {
      return failure();
    }

    for (Operation* op_with_region : op.getResult().getUsers()) {
      // Among the ops with regions, only reduce_window op is supported for now.
      if (!isa<mlir::stablehlo::ReduceWindowOp>(op_with_region)) {