result := dryDB.Table("users").Select("name").Count(&count)
	if !regexp.MustCompile(`SELECT COUNT\(.name.\) FROM .*users.*`).MatchString(result.Statement.SQL.String()) {
		t.Fatalf("Build count with select, but got %v", result.Statement.SQL.String())
	}

	result = dryDB.Table("users").Distinct("name").Count(&count)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func _() {
	len.Println /* ERROR "cannot select on len" */
	len.Println /* ERROR "cannot select on len" */ ()
	_ = len.Println /* ERROR "cannot select on len" */
	_ = len /* ERROR "cannot index len" */ [0]
	_ = *len /* ERROR "cannot indirect len" */

import org.gradle.util.AttributeTestUtil
import org.gradle.util.TestUtil
import spock.lang.Specification

class PlatformDependencyModifiersTest extends Specification {
    def "copies given external dependency to select platform"() {
        def modifier = TestUtil.objectFactory().newInstance(PlatformDependencyModifiers.PlatformDependencyModifier)
        def dependency = new DefaultExternalModuleDependency("group", "name", "1.0")

        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
    }

        then:
        failure.assertHasCause("""Module 'cglib:cglib-nodep' has been rejected:
   Cannot select module with conflict on capability 'cglib:cglib:3.2.5' also provided by [cglib:cglib:3.2.5(runtime)]""")
        failure.assertHasCause("""Module 'cglib:cglib' has been rejected:
   Cannot select module with conflict on capability 'cglib:cglib:3.2.5' also provided by [cglib:cglib-nodep:3.2.5(runtime)]""")
    }

		Name string
		Age  int
	}

	var res result
	DB.Table("users").Select("id, name, age").Where("id = ?", user3.ID).Scan(&res)
	if res.ID != user3.ID || res.Name != user3.Name || res.Age != int(user3.Age) {
		t.Fatalf("Scan into struct should work, got %#v, should %#v", res, user3)
	}

	var resPointer *result
	if err := DB.Table("users").Select("id, name, age").Where("id = ?", user3.ID).Scan(&resPointer).Error; err != nil {

		}
		panic(0)
	}
} /* ERROR "missing return" */

// select statements
func _(ch chan int) (z int) {
	select {}
} // nice!

func _(ch chan int) (z int) {
	select {}
	; ;
}

func _(ch chan int) (z int) {
	select {
	default: break
	}
} /* ERROR "missing return" */

func _(ch chan int) (z int) {
	select {
	case <-ch: return
	default: break
	}

        matcher.candidates == ["tame", "lame"] as Set
    }

    def "does not select map entry when no matches"() {
        expect:
        matcher.find("soNa", ["does not match" : 9]) == null
    }

    def "selects map entry when exact match"() {
        expect:
        matcher.find("name", ["name" : 9]) == 9
    }

    def "selects map entry when one partial match"() {
        expect:

        renderedText = renderedFile.getText("utf-8")
        renderedDocument = Jsoup.parse(renderedText)
    }

    def "has fixed issues holder"() {
        expect:
        !renderedDocument.body().select("h2#fixed-issues").empty
    }

    def "no duplicate ids"() {
        when:
        def groupedElements = renderedDocument.body().allElements.findAll { it.id() }.groupBy { it.id() }

        ":tf_tstring",
        "//tensorflow/core:protos_all_cc",
        "//tensorflow/core/platform:tstring",
        "@com_google_absl//absl/status",
        "@local_xla//xla/tsl/c:tsl_status",
    ] + select({
        "//tensorflow:with_xla_support": [
            "//tensorflow/compiler/jit",
            "//tensorflow/compiler/tf2xla:xla_compiler",
        ],
        "//conditions:default": [],
    }) + if_tensorrt([