!result.reusedOutputOriginMetadata.present

        when:
        buildId = UniqueId.generate()
        result = outOfDate(builder.build(), "Task has failed previously.")

        then:
        result.execution.get().outcome == EXECUTED_NON_INCREMENTALLY
        !result.reusedOutputOriginMetadata.present
    }

    def "out of date when no history"() {
        when:

        @Override
        public Collector<T> absentIgnoring() {
            // always present
            return this;
        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> collection) {
            collector.add(element, collection);
            return Value.present();
        }

        @Override

  }
  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) {

				continue
			}
			y := v_1.Args[0]
			v.reset(OpSub16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add16 (Com16 x) x)
	// result: (Const16 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != OpCom16 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.reset(OpConst16)
			v.AuxInt = int16ToAuxInt(-1)

            // The resolution will fail if there is no user-provided required version, however it avoids us failing here
            // if the weak version is not present but never selected.
            return PluginResolutionResult.found(new ExternalPluginResolution(getDependencyFactory(), pluginRequest, autoApplied));
        } else {

import java.lang.annotation.Annotation;
import java.util.Optional;

public interface TypeAnnotationMetadata {
    /**
     * The annotations present on the type itself.
     */
    ImmutableSet<Annotation> getAnnotations();

    /**
     * Whether an annotation of the given type is present on the type itself.
     */
    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    /**