@Override
        public MapCollector<K, V> absentIgnoring() {
            // always present
            return this;
        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
            collector.add(key, value, dest);
            return Value.present();
        }

        @Override

     *
     * @param o
     *            object to be removed from this set, if present.
     * @return true if the set contained the specified element.
     */
    @Override
    public boolean remove(final Object o) {
        return map.remove(o) == PRESENT;
    }

    /**
     * Removes all of the elements from this set.
     */
    @Override
    public void clear() {
        map.clear();
    }

    ExecutionFailure assertHasFileName(String filename);

    /**
     * Asserts that the given number of failures are present.
     */
    ExecutionFailure assertHasFailures(int count);

    /**
     * Assert that there is a failure present with the given description and invokes the given action on the failure.
     *
     * <p>Error messages are normalized to use new-line char as line separator.
     *

        plots[chartId] = chart;
        function zoomFunction(plot, reset) {
            reset = reset || false;
            return function (event, ranges) {
                $.each(plot.getXAxes(), function(_, axis) {
                    const opts = axis.options;
                    opts.min = reset ? null : ranges.xaxis.from;
                    opts.max = reset ? null : ranges.xaxis.to;
                });

  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPut_unsupportedPresentExistingValue() {
    try {
      assertEquals("put(present, existingValue) should return present or throw", v0(), put(e0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)

  }
  output->reset(
      reinterpret_cast<ImmediateExecutionTensorHandle*>(owned_value.release()));
  return Status();
}

Status DestroyResource(ImmediateExecutionContext* ctx,
                       ImmediateExecutionTensorHandle* handle) {
  ImmediateOpPtr destroy_op(ctx->CreateOperation());
  TF_RETURN_IF_ERROR(destroy_op->Reset("DestroyResourceOp", nullptr));

     *
     * This implementation is more optimal than the one with `nameFilter` and  should be used when the candidate name set is known.
     */
    public fun getCallableSymbols(names: Collection<Name>): Sequence<KaCallableSymbol>

    /**
     * Return a sequence of [KaCallableSymbol] which current scope contain, if declaration name present in [names]
     *

		namespace + "_" + subsystem + "_automatic_reload_failures_total",
		namespace + "_" + subsystem + "_automatic_reloads_total",
	}

	deprecatedEncryptionConfigAutomaticReloadFailureTotal.Reset()
	encryptionConfigAutomaticReloadsTotal.Reset()
	RegisterMetrics()

	RecordEncryptionConfigAutomaticReloadFailure(testAPIServerID)
	if err := testutil.GatherAndCompare(registry, strings.NewReader(expectedValue), metricNames...); err != nil {

  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    int initialSize = collection.size();
    assertTrue("remove(present) should return true", collection.remove(e0()));
    assertEquals(
        "remove(present) should decrease a collection's size by one.",
        initialSize - 1,
        collection.size());
    expectMissing(e0());
  }

 * Some hackery to get JUL output redirected to test output
 */
public class JULRedirector extends DefaultStandardOutputRedirector {
    private boolean reset;

    @Override
    public void start() {
        super.start();
        if (!reset) {
            LogManager.getLogManager().reset();
            try {
                LogManager.getLogManager().readConfiguration();
            } catch (IOException error) {