*/
    boolean hasCustomDescription();

    /**
     * Updates this component selection descriptor to indicate it is equivalent to a force
     *
     * @return a new descriptor, equivalent to force
     */
    ComponentSelectionDescriptorInternal markAsEquivalentToForce();

    /**
     * Indicates whether the component selection descriptor is equivalent to a forced dependency
     *

    }

    def "serializes BuildComponentSelector"() {
        given:
        ProjectComponentSelector selection = TestComponentIdentifiers.newSelector(':myPath')

        when:
        ProjectComponentSelector result = serialize(selection, serializer)

        then:
        result.projectPath == ':myPath'
    }

        def request = new DefaultTaskExecutionRequest(['foo'], 'project', null)
        def selection = new TaskSelection(':project', ':foo', asTaskSelectionResults(task))

        selector.resolveTaskName(null, 'project', defaultBuild, 'foo') >> selection

        when:
        def out = parser.parseTasks(request)

        then:
        out == [selection]
    }

    def "parses multiple tasks selectors"() {
        given:

	"sort"
	"strings"
)

// A MethodSet is an ordered set of concrete or abstract (interface) methods;
// a method is a [MethodVal] selection, and they are ordered by ascending m.Obj().Id().
// The zero value for a MethodSet is a ready-to-use empty method set.
type MethodSet struct {
	list []*Selection
}

func (s *MethodSet) String() string {
	if s.Len() == 0 {
		return "MethodSet {}"
	}

	var buf strings.Builder

	for k, v := range ps.MatchLabels {
		r, err := labels.NewRequirement(k, selection.Equals, []string{v})
		if err != nil {
			return nil, err
		}
		requirements = append(requirements, *r)
	}
	for _, expr := range ps.MatchExpressions {
		var op selection.Operator
		switch metav1.LabelSelectorOperator(expr.Operator) {
		case metav1.LabelSelectorOpIn:
			op = selection.In
		case metav1.LabelSelectorOpNotIn:
			op = selection.NotIn

        // Remove any outgoing edges for the current selection
        selected.removeOutgoingEdges();

        this.selected = newSelection;
        this.replaced = false;

        doRestart(newSelection);
        changingSelection = false;
    }

    /**
     * Clears the current selection for the module, to prepare for conflict resolution.
     * - For the current selection, disconnect and remove any outgoing dependencies.

     *
     * @return true if a dependency constraint influenced the selection of this component
     *
     * @since 4.6
     */
    boolean isConstrained();

    /**
     * Returns a list of descriptions of the causes that led to the selection of this component.
     *
     * @return the list of descriptions.
     *
     * @since 4.6
     */

import java.util.Optional;
import java.util.Set;

/**
 * Provides a central location for handling failures encountered during
 * each stage of the variant selection process during dependency resolution.
 *
 * All variant selection failures encountered during selection by the {@link GraphVariantSelector} or
 * {@link AttributeMatchingArtifactVariantSelector}
 * should be routed through this class.
 *

    /**
     * Creates a set that selects the artifacts from this set that match the given criteria.
     * Implementations are lazy, so that the selection happens only when the contents are queried.
     *
     * @param spec Parameters controlling the artifact selection process
     */
    SelectedArtifactSet select(ArtifactSelectionSpec spec);

     * The implementation should attempt to select artifacts eagerly, but may be lazy where
     * the selection cannot happen until the results are queried.
     *
     * @param variantSelector Performs variant selection
     * @param spec Governs how artifacts are selected
     * @param lenient If true, ignore artifacts that are resolved, but unavailable
     */