if err != nil {
		err = errors.New(cmdline[0] + ": " + err.Error())
	}
	return buf.Bytes(), err
}

// joinUnambiguously prints the slice, quoting where necessary to make the
// output unambiguous.
// TODO: See issue 5279. The printing of commands needs a complete redo.
func joinUnambiguously(a []string) string {
	var buf strings.Builder
	for i, s := range a {
		if i > 0 {
			buf.WriteByte(' ')
		}

		// We may need to add a filename extension from PATHEXT
		// or verify an extension that is already present.
		// Since the path is absolute, its extension should be unambiguous
		// and independent of cmd.Dir, and we can go ahead and cache the lookup now.
		//
		// Note that we cannot add an extension here for relative paths, because

        failure.assertHasResolutions(
            GET_TASKS,
            NAME_EXPANSION,
            INFO_DEBUG,
            SCAN,
            GET_HELP
        )
    }

    def "reports ambiguous task"() {
        enableProblemsApiCheck()
        createDirs("a", "b")
        settingsFile << """
            rootProject.name = 'test'
            include 'a', 'b'
        """
        buildFile << """

    }

    def "demonstrate ambiguous graph variant without single disambiguating value selection failure for project"() {

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

        failure.assertHasErrorOutput(UnknownPluginException.class.getName())
    }

    @Issue("https://github.com/gradle/gradle/issues/24609")
    def "when plugin request fails due to ambiguous plugin variants available, gets default error message"() {
        given:
        def producer = file('producer')
        def consumer = file('consumer')

// resolvePorts takes a Gateway port, and resolves it to the port that will actually be listened on.
// When legacyGatewaySelector=false, then the gateway is directly referencing a Service. In this
// case, the translation is un-ambiguous - we just find the matching port and return the targetPort
// When legacyGatewaySelector=true things are a bit more complex, as we support referencing a Service

			},
			goroutines: []trace.GoID{7},
		},
	}
	for id, summary := range summaries {
		want, ok := wantTasks[id]
		if !ok {
			continue
		}
		if id != summary.ID {
			t.Errorf("ambiguous task %d (or %d?): field likely set incorrectly", id, summary.ID)
		}

		// Check parent.
		if want.parent != nil {
			if summary.Parent == nil {

		return
	}

	// We have to establish a TLS connection and the
	// client must provide exactly one client certificate.
	// Otherwise, we don't have a certificate to verify or
	// the policy lookup would ambiguous.
	if r.TLS == nil {
		writeSTSErrorResponse(ctx, w, ErrSTSInsecureConnection, errors.New("No TLS connection attempt"))
		return
	}

	// A client may send a certificate chain such that we end up

	sc := armCondCode[(s&C_SCOND)^C_SCOND_XOR]
	if s&C_SBIT != 0 {
		sc += ".S"
	}
	if s&C_PBIT != 0 {
		sc += ".P"
	}
	if s&C_WBIT != 0 {
		sc += ".W"
	}
	if s&C_UBIT != 0 { /* ambiguous with FBIT */
		sc += ".U"
	}
	return sc
}

func (p *Prog) String() string {
	if p == nil {
		return "<nil Prog>"
	}
	if p.Ctxt == nil {
		return "<Prog without ctxt>"
	}