return ExecutionTimeValue.value(filterValue(context, value.toValue()));
        }
    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context);
            Value<? extends T> value = provider.calculateValue(consumer);
            return filterValue(context, value);
        }
    }

    assertEquals(ImmutableMap.of(), filtered);
  }

  public void testFilteredValuesIllegalPut() {
    Map<String, Integer> unfiltered = createUnfiltered();
    Map<String, Integer> filtered = Maps.filterValues(unfiltered, EVEN);
    filtered.put("a", 2);
    unfiltered.put("b", 4);
    unfiltered.put("c", 5);
    assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered);

    try {
      filtered.put("yyy", 3);

                    putEntries(map, entries);
                    map.putAll(ENTRIES_TO_FILTER);
                    return Maps.filterValues(map, FILTER_VALUES);
                  }
                })
            .named("Maps.filterValues[Map, Predicate]")
            .withFeatures(
                MapFeature.ALLOWS_NULL_KEYS,
                MapFeature.ALLOWS_NULL_VALUES,

    assertEquals(ImmutableMap.of(), filtered);
  }

  public void testFilteredValuesIllegalPut() {
    Map<String, Integer> unfiltered = createUnfiltered();
    Map<String, Integer> filtered = Maps.filterValues(unfiltered, EVEN);
    filtered.put("a", 2);
    unfiltered.put("b", 4);
    unfiltered.put("c", 5);
    assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered);

    try {
      filtered.put("yyy", 3);

    mhlo::ConvolutionOp conv_op;
    Operation *bcast_or_const_op;
    shape::ShapeOfOp shape_of_op;
    mhlo::ConstantOp filter;
    mhlo::ConstantOp multiplier;
    mlir::ElementsAttr filter_value, mul_value;
    mlir::DenseIntElementsAttr broadcast_dims;

    // Match and capture values/attributes.
    Value lhs = mul_op.getLhs();
    Value rhs = mul_op.getRhs();

            sortChanges(it.value)
        }

        val mismatches = originalChanges.mapValues {
            findMismatches(it.value, sortedChanges[it.key]!!)
        }.filterValues {
            it.isNotEmpty()
        }

        if (mismatches.isNotEmpty()) {
            val formattedMismatches = mismatches.mapValues { mismatch ->

        filter_constant_op) {
      // This is i8 values disguised as f32 (due to the upcast trick). Simply
      // cast them to i8.
      ElementsAttr filter_value = filter_constant_op.getValue();
      filter_i8_value_attr =
          mlir::cast<DenseFPElementsAttr>(filter_value)
              .mapValues(rewriter.getI8Type(), [](const APFloat& val) -> APInt {
                APSInt convertedInt(/*BitWidth=*/8, /*isUnsigned=*/false);

        return apiChangesDirectory.get().asFile.listFiles()
            ?.filter {
                it.name.endsWith(".json")
            }?.associate {
                it to it.readAcceptedChanges()
            }?.filterValues {
                it.acceptedApiChanges != null
            }?.mapValues {
                it.value.acceptedApiChanges!!
            } ?: emptyMap()
    }

    private

            .mapValues { (_, functions) -> functions.singleOrNull { fn -> fn.parameters.all { it == fn.instanceParameter } } }
            .filterValues { it != null && includeMemberFilter.shouldIncludeMember(it) }
        return getters.mapNotNull { (name, getter) ->
            checkNotNull(getter)
            val nameAfterGet = name.substringAfter("get")

     * {@literal null} if none
     */
    public Map<Equivalence.Wrapper<Method>, Collection<Method>> overriddenMethodsNamed(String methodName) {
        if (candidates.containsKey(methodName)) {
            return Maps.filterValues(candidates.get(methodName), new Predicate<Collection<Method>>() {
                @Override
                public boolean apply(Collection<Method> equivalentMethods) {
                    return equivalentMethods.size() > 1;