def "reports no execution reasons for skipped tasks"() {
        given:
        buildFile << """
            task disabledTask {
                enabled = false
            }
        """

        when:
        runBuild('disabledTask')

        then:
        taskSkippedResult(':disabledTask')
    }

    def "reports execution reason for executed task without declared outputs"() {

    protected IncrementalChangesContext(IncrementalChangesContext parent) {
        this(parent, parent.getRebuildReasons(), parent.getChanges().orElse(null));
    }

    /**
     * Returns the reasons to re-execute the work, empty if there's no reason to re-execute.
     */
    public ImmutableList<String> getRebuildReasons() {
        return rebuildReasons;
    }

    /**

            "$it.name=${attributes.getAttribute(it as Attribute<Object>)}"
        }.sort().join(',')
    }

    protected String formatReason(ComponentSelectionReasonInternal reason) {
        def reasons = reason.descriptions.collect {
            def message
            if (it.hasCustomDescription() && it.cause != ComponentSelectionCause.REQUESTED) {

        return new CachingState(Either.right(new Disabled(disabledReasons, cacheKeyCalculatedState)));
    }

    public static CachingState disabledWithoutInputs(CachingDisabledReason reason) {
        return disabled(ImmutableList.of(reason), null, null);
    }

    public Optional<Enabled> whenEnabled() {
        return delegate.getLeft();
    }

    public Optional<Disabled> whenDisabled() {

     * the compile classpath and the runtime classpath, the version from the
     * compile classpath is going to be used.
     *
     * Unless you have a good reason to, this option should be preferred to
     * {@link #useRuntimeClasspathVersions()} for different reasons:
     *
     * <ul>
     *     <li>As code is compiled first against the given dependencies,
     *     it is expected that the versions at runtime would be the same.

	regRes := configAMD64.ABIAnalyze(ft, false)
	regResString := strings.TrimSpace(regRes.String())

	// Check results.
	reason := difftokens(tokenize(regResString), tokenize(exp.dump))
	if reason != "" {
		t.Errorf("\nexpected:\n%s\ngot:\n%s\nreason: %s",
			strings.TrimSpace(exp.dump), regResString, reason)
	}

	model.ClusterUpdate:   pushTriggers.With(typeTag.Value(string(model.ClusterUpdate))),
}

func recordPushTriggers(reasons model.ReasonStats) {
	for r, cnt := range reasons {
		t, f := triggerMetric[r]
		if f {
			t.RecordInt(int64(cnt))
		} else {
			pushTriggers.With(typeTag.Value(string(r))).Increment()
		}
	}
}

  // Defaults to "True".
  // If unset, should be treated as "True".
  // +optional
  optional string status = 6;

  // brief reason for the request state
  // +optional
  optional string reason = 2;

  // human readable message with details about the request state
  // +optional
  optional string message = 3;

  // timestamp for the last update to this condition

  // Defaults to "True".
  // If unset, should be treated as "True".
  // +optional
  optional string status = 6;

  // brief reason for the request state
  // +optional
  optional string reason = 2;

  // human readable message with details about the request state
  // +optional
  optional string message = 3;

  // timestamp for the last update to this condition

// tickers, even if they haven't been stopped.
// The Stop method is no longer necessary to help the garbage collector.
// (Code may of course still want to call Stop to stop the ticker for other reasons.)
func NewTicker(d Duration) *Ticker {
	if d <= 0 {
		panic("non-positive interval for NewTicker")
	}
	// Give the channel a 1-element time buffer.
	// If the client falls behind while reading, we drop ticks