}

    @Issue("https://github.com/gradle/gradle/issues/11995")
    def "provides a human understable error message when some variants were discarded and the remainder is ambiguous"() {
        buildFile << """
            apply plugin: 'java-base'

            configurations {
                consumer {
                    assert canBeResolved
                    canBeConsumed = false

            if (expected == null && result) {
                throw new Exception("Expected an ambiguous result, but got $result")
            }
            assert result == [expected] as Set
        } catch (VariantSelectionException e) {
            if (expected == null) {

    /**
     * Returns true if the [candidate] is in the final set of candidates that the call is actually resolved to. There can be multiple
     * candidates if the call is ambiguous.
     */
    public val isInBestCandidates: Boolean by validityAsserted(isInBestCandidates)
}

public typealias KtCallCandidateInfo = KaCallCandidateInfo

/**

		{
			name:     "single hit",
			delegate: fixedRESTMapper{resourcesFor: []schema.GroupVersionResource{{Resource: "single-hit"}}},
			result:   schema.GroupVersionResource{Resource: "single-hit"},
		},
		{
			name: "ambiguous match",
			delegate: fixedRESTMapper{resourcesFor: []schema.GroupVersionResource{
				{Group: "one", Version: "a", Resource: "first"},
				{Group: "two", Version: "b", Resource: "second"},
			}},

	}
	return operr
}

func controlOnConnSetup(network string, address string, c syscall.RawConn) error {
	var operr error
	var fn func(uintptr)
	switch network {
	case "tcp", "udp", "ip":
		return errors.New("ambiguous network: " + network)
	case "unix", "unixpacket", "unixgram":
		fn = func(s uintptr) {
			_, operr = syscall.GetsockoptInt(int(s), syscall.SOL_SOCKET, syscall.SO_ERROR)
		}
	default:
		switch network[len(network)-1] {

	}
	return operr
}

func controlOnConnSetup(network string, address string, c syscall.RawConn) error {
	var operr error
	var fn func(uintptr)
	switch network {
	case "tcp", "udp", "ip":
		return errors.New("ambiguous network: " + network)
	default:
		switch network[len(network)-1] {
		case '4':
			fn = func(s uintptr) {
				operr = syscall.SetsockoptInt(syscall.Handle(s), syscall.IPPROTO_IP, syscall.IP_TTL, 1)
			}

		base.Fatalf("setAlg(%v,%s) starting with unknown priority", t, a)
	}
	if algPriority[a] > algPriority[t.alg] {
		t.alg = a
	} else if a != t.alg && algPriority[a] == algPriority[t.alg] {
		base.Fatalf("ambiguous priority %s and %s", a, t.alg)
	}
}

// AlgType returns the AlgKind used for comparing and hashing Type t.
func AlgType(t *Type) AlgKind {
	CalcSize(t)
	return t.alg
}

                "d" to DefaultFqName("a.b.c", "d")
            ),
            result
        )
        assertTrue(analysisContext.errorCollector.errors.isEmpty())
    }

    @Test
    fun `reports ambiguous import errors`() {
        val imports = listOf(
            importOf("a", "b", "C"),
            importOf("a", "c", "C"),
            importOf("a", "b", "D")
        )
        val analysisContext = testContext()

        when:
        task.configuration = "coB"
        task.dependencySpec = { true } as Spec

        then:
        task.configuration == confB
    }

    def "ambiguous configuration selection by camelCase shortcut fails"() {
        given:
        project.configurations.create("confAlpha")
        project.configurations.create("confAlfa")

        when:

        then:
        failure.assertThatCause(containsNormalizedString("Cannot add task 'test' as a task with that name already exists."))
    }

    // currently not supported, variants are ambiguous without further information
    def "reports of multiple targets cannot be aggregated"() {
        setupBasicTestingProject(['test-report-aggregation'])
        buildFile << """
            testing {