* <p>A disambiguation rule can select the best match from a list of candidates.</p>
     *
     * <p>A rule <i>can</i> express an preference by calling the @{link {@link MultipleCandidatesDetails#closestMatch(Object)}
     * method to tell that a candidate is the best one.</p>
     *
     * <p>It is not mandatory for a rule to choose, and it is not an error to select multiple candidates.</p>
     *

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

package main

func main() {	
	c := make(chan bool, 1);
	select {
	case _ = <-c:
		panic("BUG: recv should not");
	default:
	}
	c <- true;
	select {
	case _ = <-c:
	default:
		panic("BUG: recv should");
	}

// license that can be found in the LICENSE file.

// /tmp/x.go:5: cannot use _ as value

package p

func f(ch chan int) bool {
	select {
	case _, ok := <-ch:
		return ok
	}
	_, ok := <-ch
	_ = ok
	select {
	case _, _ = <-ch:
		return true
	}
	return false

go build -o $TMP\main.exe main.go

# Read ACLs for the files.
exec powershell -Command 'Get-Acl main.exe | Select -expand AccessToString'
cp stdout $WORK\exe-acl.txt
exec powershell -Command 'Get-Acl main.go | Select -expand AccessToString'
cp stdout $WORK\src-acl.txt
cd $TMP
exec powershell -Command 'Get-Acl main.exe | Select -expand AccessToString'
cp stdout $WORK\guest-acl.txt

cd $WORK

		// making the two calls ambiguous. However because the
		// interfaces and implementations are mutually exclusive,
		// devirtualization can still select the correct callee for
		// each.
		//
		// If they were not mutually exclusive (for example, two Add
		// calls), then we could not definitively select the correct
		// callee.
		val += m.Multiply(42, selectA(i).Add(one(i), 2))
	}
	return val
}

type AddFunc func(int, int) int

	// It is impossible to ensure that a goroutine has actually blocked
	// on a channel, in a select or otherwise. So we kick off goroutines
	// that need to block first in the hope that while we are executing
	// the rest of the test, they will block.
	go func() { // func1
		select {}
	}()
	go func() { // func2
		var c chan int
		c <- 0
	}()
	go func() { // func3
		var c chan int
		<-c
	}()

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

class TestFixturesDependencyModifiersTest extends Specification {
    def "copies given external dependency to select test fixtures"() {
        def modifier = TestUtil.objectFactory().newInstance(TestFixturesDependencyModifiers.TestFixturesDependencyModifier)
        def dependency = new DefaultExternalModuleDependency("group", "name", "1.0")

// from the HTML output.

// This is a regression test for incorrect sorting of boundaries
// that coincide, specifically for empty select clauses.
// START f
func f() {
	ch := make(chan int)
	select {
	case <-ch:
	default:
	}
}

// END f

// https://golang.org/issue/25767
// START g
func g() {
	if false {
		fmt.Printf("Hello")
	}
}

	Get R3
	Get R1
	Get R3
	I64LtU
	Select
	Set R4

	Get R0
	I32WrapI64
	Get R2
	I32WrapI64
	Get R4
	I32WrapI64
	Call memcmp<>(SB)
	I64ExtendI32S
	Tee R5

	I64Eqz
	If
		// check length
		Get R1
		Get R3
		I64Sub
		Set R5
	End

	I64Const $0
	I64Const $-1
	I64Const $1
	Get R5
	I64Const $0
	I64LtS
	Select
	Get R5
	I64Eqz
	Select
	Return

        select(registry, matches);
        return !matches.isEmpty();
    }

    @Override
    public <T extends ProjectIdentifier> T selectProject(String settingsDescription, ProjectRegistry<? extends T> registry) {
        checkPreconditions(registry);
        List<T> matches = new ArrayList<T>();
        select(registry, matches);
        if (matches.isEmpty()) {