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",
	}

		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Locking{Strength: clause.LockingStrengthUpdate}},
			"SELECT * FROM `users` FOR UPDATE", nil,
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Locking{Strength: clause.LockingStrengthShare, Table: clause.Table{Name: clause.CurrentTable}}},
			"SELECT * FROM `users` FOR SHARE OF `users`", nil,
		},
		{

	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}},
			"SELECT * FROM `users`", nil,
		},
		{
			[]clause.Interface{clause.Select{
				Columns: []clause.Column{clause.PrimaryColumn},
			}, clause.From{}},
			"SELECT `users`.`id` FROM `users`", nil,
		},
		{
			[]clause.Interface{clause.Select{
				Columns: []clause.Column{clause.PrimaryColumn},
			}, clause.Select{
				Columns: []clause.Column{{Name: "name"}},

        def testDiv = content.select("div#tests")
        assert testDiv != null
        def counter = testDiv.select("div.counter")
        assert counter != null
        assert counter.text() == tests as String
    }

    void assertHasFailures(int tests) {
        def testDiv = content.select("div#failures")
        assert testDiv != null
        def counter = testDiv.select("div.counter")
        assert counter != null

                ], outputFile)

        then:
        outputHtml.select('h1').text() == 'Build reports'
        with outputHtml.select('ul li'), {
            size() == 5
            select('a[href=report.html]').text() == 'a'
            select('a[href=inner/otherReport.html]').text() == 'b'
            select('span[class=unavailable]').text() == 'c'
            select('a[href=htmlContent/index.html]').text() == 'd'

    }

    @Override
    public <T> Result<T> select(Class<T> platformType, T requestPlatform) {
        if (CppPlatform.class.isAssignableFrom(platformType)) {
            return Cast.uncheckedCast(select((CppPlatform) requestPlatform));
        } else if (SwiftPlatform.class.isAssignableFrom(platformType)) {
            return Cast.uncheckedCast(select((SwiftPlatform) requestPlatform));
        } else {

		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:

            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)));
    }

    select("tr.severity-$severity").map { tr ->
        tr.select("td")[1]
            .select("span")
            .text()
            .substringBefore(" If you did this intentionally")
    }


private
fun Document.scrapeMessagesForSeverity(severity: String): List<ReportMessage> =

    select("tr.severity-$severity").map { tr ->
        val entry = tr.select("td")[1]