"test".getBytes(StandardCharsets.UTF_8), service.select(Arrays.asList("SHA-1", "MD5")));
        assertNotNull(checksums);
        assertEquals(2, checksums.size());
        assertEquals("a94a8fe5ccb19ba61c4c0873d391e987982fbbd3", checksums.get(service.select("SHA-1")));
        assertEquals("098f6bcd4621d373cade4e832627b4f6", checksums.get(service.select("MD5")));
    }

    @Test

    (\$p.category): \$results | map(. + {policy: .policies[] | select(.category == \$p.category)}) | {
      level: \$p.level,
      reason: \$p.reason,
      passing: map(select(.policy.fail | not)) | length,
      failing: map(select(.policy.fail)) | length,
      testnames: map(select(.policy.fail) | .testname),
    }
  })
  # add a meta policy based on whether any policy failed
  + {

                }
            }
            """,
        "select 1.1": """{ ComponentSelection selection ->
                if (selection.candidate.version != '1.1') {
                    selection.reject("not 1.1")
                }
                candidates << selection.candidate.version
            }
            """,
        "select 2.0": """{ ComponentSelection selection ->

		if gotRemove != file {
			t.Fatalf("Remove() failed: got %v want %v", gotRemove, file)
		}
		select {
		case <-addedChan:
			t.Fatal("Remove() failed: callback invoked with added=false")
		default:
		}

		wantEvent = fsnotify.Event{Name: file, Op: fsnotify.Write}
		fakeWatcher.InjectEvent(file, wantEvent)
		select {
		case gotEvent := <-watcher.Events(file):
			t.Fatalf("Unexpected Events() after Remove(): got %v", gotEvent)

		clauses := []clause.Interface{clause.Select{}, clause.From{}, clause.Where{Exprs: []clause.Expression{clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})}}}

		for _, clause := range clauses {
			stmt.AddClause(clause)
		}

		stmt.Build("SELECT", "FROM", "WHERE")
		_ = stmt.SQL.String()
	}
}

	// wasm:"Select"
	return x
}

func cmov32bit(x, y uint32) uint32 {
	if x < y {
		x = -y
	}
	// amd64:"CMOVL(HI|CS)"
	// arm64:"CSNEG\t(LS|HS)"
	// ppc64x:"ISEL\t[$]1"
	// wasm:"Select"
	return x
}

func cmov16bit(x, y uint16) uint16 {
	if x < y {
		x = -y
	}
	// amd64:"CMOVW(HI|CS)"
	// arm64:"CSNEG\t(LS|HS)"
	// ppc64x:"ISEL\t[$][01]"
	// wasm:"Select"
	return x
}

	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)

        def target = Stub(ArtifactSet)
        def selector = Stub(ArtifactVariantSelector)

        when:
        target.select(_, _) >> ResolvedArtifactSet.EMPTY

        then:
        new NoBuildDependenciesArtifactSet(target).select(selector, Mock(ArtifactSelectionSpec)) == ResolvedArtifactSet.EMPTY
    }

    def "creates wrapper for non-empty set of selected artifacts"() {

    }

    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"() {

// 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" */