/**
     * Sets the value of the property to the given value, replacing whatever value the property already had.
     *
     * <p>
     * This method can also be used to discard the value of the property, by passing it {@code null}. When the
     * value is discarded (or has never been set in the first place), the convention (default value) for this
     * property, if specified, will be used to provide the value instead.
     * </p>
     *

public interface ResolutionStrategyInternal extends ResolutionStrategy {
    /**
     * Discard any configuration state that is not required after graph resolution has been attempted.
     */
    void maybeDiscardStateRequiredForGraphResolution();

    /**
     * Sets whether or not any configuration resolution is final and the state required for resolution can be

        failure.assertHasErrorOutput('error: package rx.observers does not exist')
    }

    @Issue("https://github.com/gradle/gradle/issues/11995")
    def "provides a human understable error message when some variants were discarded and the remainder is ambiguous"() {
        buildFile << """
            apply plugin: 'java-base'

            configurations {
                consumer {
                    assert canBeResolved

	bytesSentPerSecondQuery       = "\\Network Adapter(*)\\Bytes Sent/sec"
	packetsReceivedDiscardedQuery = "\\Network Adapter(*)\\Packets Received Discarded"
	packetsReceivedErrorsQuery    = "\\Network Adapter(*)\\Packets Received Errors"
	packetsOutboundDiscardedQuery = "\\Network Adapter(*)\\Packets Outbound Discarded"
	packetsOutboundErrorsQuery    = "\\Network Adapter(*)\\Packets Outbound Errors"
)

"""
        }
    }

    protected void assertConfigCacheDiscarded() {
        if (GradleContextualExecuter.isConfigCache()) {
            failure.assertOutputContains("Configuration cache entry discarded")
        }
    }

    protected void assertVerificationError(boolean terse, @DelegatesTo(value = VerificationErrorHelper, strategy = Closure.DELEGATE_FIRST) Closure<?> verification) {

            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        // Split the `with` operation so that the `associatedBuildOperation` can be discarded when we wait in `process.waitFor()`
        try {
            CurrentBuildOperationRef.instance().with(this.associatedBuildOperation, () -> {
                startProcess();

                execHandle.started();

        configurationCacheFails(*(projectConfig.tasks))
        server.resetExpectations()

        then:
        configurationCache.assertStateStoreFailed()
        outputContains("Configuration cache entry discarded")
        failure.assertHasFailures(1)
        failure.assertHasDescription("Configuration cache problems found in this build")

    }

    /**
     * Will the build model, that is the configured Gradle and Project objects, be required during the build execution?
     *
     * <p>When the build model is not required, certain state can be discarded or not created.
     */
    public boolean isRequiresBuildModel() {
        return requiresBuildModel;
    }

    public boolean isConfigureOnDemand() {
        return configureOnDemand;
    }

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Transforms the stream of output events to discard progress operations that are not interesting to the logging subsystem. This reduces the amount of work that downstream consumers have to do to process the stream. For example, these discarded events don't need to be written to the daemon client.
 */
public class OutputEventTransformer implements OutputEventListener {

        // This lifecycle could be simplified and allow the dependencies to be discarded at this point
        pruned = false;
        waitingFor.add(node);
        return this;
    }

    @Override
    public NavigableSet<Node> getMustSuccessors() {
        return ImmutableSortedSet.of();
    }

    @Override