NoMoreWorkToStart
    }

    abstract class Selection<T> {
        private static final Selection<Object> NO_WORK_READY_TO_START = new Selection<Object>() {
            @Override
            public boolean isNoWorkReadyToStart() {
                return true;
            }
        };
        private static final Selection<Object> NO_MORE_WORK_TO_START = new Selection<Object>() {
            @Override

import org.gradle.api.Incubating;

/**
 * Provides test selection from a specific test task.
 *
 * @see TestLauncher#withTestsFor(Action)
 * @since 7.6
 */
@Incubating
public interface TestSpecs {

    /**
     * Creates a new test selection for the target task.
     *
     * @param taskPath The target task.
     * @return A new test selection.
     */
    TestSpec forTaskPath(String taskPath);

import org.gradle.internal.scan.UsedByScanPlugin;

/**
 * A component selection description, which wraps a cause with an optional custom description.
 *
 * @since 4.6
 */
@UsedByScanPlugin
@HasInternalProtocol
public interface ComponentSelectionDescriptor {

    /**
     * Returns the cause associated with this descriptor
     *
     * @return a component selection cause
     */
    ComponentSelectionCause getCause();

    /**

    }

    /**
     * If false, selection is restricted only to the artifacts exposed a selected node in the graph.
     * If true, selection is expanded to include artifacts from any variant exposed by the component that a given node belongs to.
     */
    public boolean getSelectFromAllVariants() {
        return selectFromAllVariants;
    }

    /**

import spock.lang.Specification

class DefaultComponentSelectionReasonTest extends Specification {

    def "requested only selection reason is expected"() {
        when:
        def reason = ComponentSelectionReasons.requested()

        then:
        reason.isExpected()
    }

    def "root only selection reason is expected"() {
        when:
        def reason = ComponentSelectionReasons.root()

        then:

                resolutionStrategy.capabilitiesResolution.all { details ->
                    def selection =
                        details.candidates.find { it.variantName.endsWith('PrefApiElements') }
                    println("Selecting \$selection from \${details.candidates}")
                    details.select(selection)
                }
            }

            configurations.runtimeClasspath {

import org.gradle.api.internal.artifacts.transform.ArtifactVariantSelector
import spock.lang.Specification

class DefaultVisitedArtifactResultsTest extends Specification {
    def "strict selection includes selected variant of each node"() {
        def artifacts1 = Stub(ArtifactSet)
        def artifacts2 = Stub(ArtifactSet)
        def variant1Artifacts = Stub(ResolvedArtifactSet)

            String path = remainingPaths.remove(0);
            TaskSelection selection = taskSelector.resolveTaskName(taskExecutionRequest.getRootDir(), taskExecutionRequest.getProjectPath(), targetBuild, path);
            Set<Task> tasks = selection.getTasks();
            remainingPaths = taskConfigurer.configureTasks(tasks, remainingPaths);
            out.add(selection);
        }
        return out;
    }

package match

import (
	"path/filepath"
	"strings"

	"istio.io/istio/pkg/log"
)

func MatchesMap(selection, cluster map[string]string) bool {
	if len(selection) == 0 {
		return true
	}
	if len(cluster) == 0 {
		return false
	}

	for ks, vs := range selection {
		vc, ok := cluster[ks]
		if !ok {
			return false
		}
		if !MatchesGlob(vc, vs) {
			return false
		}
	}

*/

package fields

import "k8s.io/apimachinery/pkg/selection"

// Requirements is AND of all requirements.
type Requirements []Requirement

// Requirement contains a field, a value, and an operator that relates the field and value.
// This is currently for reading internal selection information of field selector.
type Requirement struct {
	Operator selection.Operator
	Field    string
	Value    string