// budget.
  // A null selector selects no pods.
  // An empty selector ({}) also selects no pods, which differs from standard behavior of selecting all pods.
  // In policy/v1, an empty selector will select all pods in the namespace.
  // +optional
  optional .k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 2;

  // An eviction is allowed if at most "maxUnavailable" pods selected by

	p := participle.MustBuild(
		&Select{},
		participle.Lexer(sqlLexer),
		participle.CaseInsensitive("Keyword"),
	)

	s := Select{}
	cases := []string{
		"select * from s3object",
		"select a, b from s3object s",
		"select a, b from s3object as s",
		"select a, b from s3object as s where a = 1",
		"select a, b from s3object s where a = 1",
		"select a, b from s3object where a = 1",
	}

		for _, n := range names {
			event := "xds"
			if req.Full {
				event += " full"
			}
			select {
			case fx.Events <- Event{Type: event, ID: n}:
			default:
			}
		}
	} else {
		id := strings.Join(names, ",")
		event := "xds"
		if req.Full {
			event += " full"
		}
		select {
		case fx.Events <- Event{Type: event, ID: id, Reason: req.Reason}:
		default:
		}
	}
	if fx.Delegate != nil {

        def selector = Stub(ArtifactVariantSelector)

        given:
        artifacts1.select(selector, _) >> variant1Artifacts
        artifacts2.select(selector, _) >> variant2Artifacts

        def results = new DefaultVisitedArtifactResults([artifacts1, artifacts2])
        def selected = results.select(selector, Mock(ArtifactSelectionSpec), false)

        expect:

  // budget.
  // A null selector will match no pods, while an empty ({}) selector will select
  // all pods within the namespace.
  // +patchStrategy=replace
  // +optional
  optional .k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 2;

  // An eviction is allowed if at most "maxUnavailable" pods selected by
  // "selector" are unavailable after the eviction, i.e. even in absence of

            details.select(unqalifiedComponent);
            return;
        }
        if (bestComponent != null) {
            // Found a snapshot and no unqualified release present
            details.select(bestComponent);
        }

        // Only non releases and no unqualified version or snapshot - just return the highest version
        details.select(matches.get(sorted.get(0)));
    }

import okhttp3.Address
import okhttp3.HttpUrl
import okhttp3.Route
import okhttp3.internal.canParseAsIpAddress
import okhttp3.internal.immutableListOf
import okhttp3.internal.toImmutableList

/**
 * Selects routes to connect to an origin server. Each connection requires a choice of proxy server,
 * IP address, and TLS mode. Connections may also be recycled.
 */
class RouteSelector(
  private val address: Address,

        // if more than one conflicting project dependencies
        // let the delegate resolver select among them
        if (projectCandidates != null) {
            ConflictResolverDetails<T> projectDetails = new DefaultConflictResolverDetails<>(Cast.<List<T>>uncheckedCast(projectCandidates));
            delegate.select(projectDetails);
            details.select(projectDetails.getSelected());
            return;
        }

    }

    def "always returns default for select question"() {
        expect:
        userInputHandler.selectOption('Select count', [1, 2, 3], 2) == 2
    }

    def "returns first option when no default"() {
        expect:
        userInputHandler.choice('Select count', [1, 2, 3])
            .ask() == 1
    }

    def "returns default option for choice"() {

        def parsedHtmlReport = Jsoup.parse(htmlDir.file("index.html"), "UTF-8")
        def table = parsedHtmlReport.select("table#coveragetable").first()
        def td = table.select("tfoot td:eq(2)").first()
        String totalCoverage = td.text().replaceAll(NON_BREAKING_WHITESPACE, '') // remove non-breaking whitespace
        return totalCoverage.endsWith("%") ? totalCoverage.subSequence(0, totalCoverage.length() - 1) as BigDecimal : null
    }