models[":"][3].message == "fetch2 It works from project :"


        when:
        executer.withArguments(ENABLE_CLI)
        runBuildAction(new FetchParameterizedCustomModelForEachProject(["fetch1", "fetch2", "fetch1", "fetch2"]))

        then:
        fixture.assertStateLoaded()
        outputDoesNotContain("configuring root")
        outputDoesNotContain("creating model")
    }

	p := &promise{
		doneCtx: doneCtx,
		doneVal: doneVal,
		setCh:   make(chan struct{}),
	}
	if initial != nil {
		p.Set(initial)
	}
	return p
}

func (p *promise) Get() interface{} {
	select {
	case <-p.setCh:
	case <-p.doneCtx.Done():
		p.Set(p.doneVal)
	}
	return p.value
}

func (p *promise) Set(value interface{}) bool {

	"gorm.io/gorm"
)

func TestWithSingleConnection(t *testing.T) {
	expectedName := "test"
	var actualName string

	setSQL, getSQL := getSetSQL(DB.Dialector.Name())
	if len(setSQL) == 0 || len(getSQL) == 0 {
		return
	}

	err := DB.Connection(func(tx *gorm.DB) error {
		if err := tx.Exec(setSQL, expectedName).Error; err != nil {
			return err
		}

		if err := tx.Raw(getSQL).Scan(&actualName).Error; err != nil {

	"istio.io/istio/pkg/slices"
)

func FetchOne[T any](ctx HandlerContext, c Collection[T], opts ...FetchOption) *T {
	res := Fetch[T](ctx, c, opts...)
	switch len(res) {
	case 0:
		return nil
	case 1:
		return &res[0]
	default:
		panic("FetchOne found for more than 1 item")
	}
}

func Fetch[T any](ctx HandlerContext, cc Collection[T], opts ...FetchOption) []T {
	h := ctx.(registerDependency)
	c := cc.(internalCollection[T])

	if(state == 'pan' && enablePan) {
		// Pan mode
		var p = getEventPoint(evt).matrixTransform(stateTf);

		setCTM(g, stateTf.inverse().translate(p.x - stateOrigin.x, p.y - stateOrigin.y));
	} else if(state == 'drag' && enableDrag) {
		// Drag mode
		var p = getEventPoint(evt).matrixTransform(g.getCTM().inverse());

                && StringUtils.compare(attrValue, other.attrValue) == 0;
    }

    public void setId(final String id) {
        this.id = id;
    }

    public void setCss(final String css) {
        this.css = css;
    }

    public void setAttr(final String name, final String value) {
        this.attrName = name;
        this.attrValue = value;
    }

    @Override

	return p[k]
}

func (p Params) GetWellKnown(k WellKnown) any {
	return p[k.String()]
}

func (p Params) Set(k string, v any) Params {
	p[k] = v
	return p
}

func (p Params) SetAll(other Params) Params {
	for k, v := range other {
		p[k] = v
	}
	return p
}

func (p Params) SetAllNoOverwrite(other Params) Params {
	for k, v := range other {
		if !p.Contains(k) {
			p[k] = v
		}

# CHECK-SAME:  control_outputs = ""
# CHECK-SAME:  inputs = "arg"
# CHECK-SAME:  outputs = "arg"
# CHECK:         %[[GRAPH:[0-9]+]] = tf_executor.graph
# CHECK:           tf_executor.fetch %[[ARG_0]]

# CHECK-SAME:  control_outputs = ""
# CHECK-SAME:  inputs = "input"
# CHECK-SAME:  outputs = "input"
# CHECK:         %[[GRAPH:[0-9]+]] = tf_executor.graph
# CHECK:           tf_executor.fetch %[[ARG_0]]

FROM --platform=linux/$BUILDARCH ${SETCAP_IMAGE}
ARG BINARY
COPY ${BINARY} /${BINARY}
# We apply cap_net_bind_service so that kube-apiserver can be run as
# non-root and still listen on port less than 1024
RUN setcap cap_net_bind_service=+ep /${BINARY}

FROM --platform=linux/$TARGETARCH ${BASEIMAGE}
ARG BINARY