|----------------------------|--------------|-----------|
    | org.gradle.category        | library      |           |
    | org.gradle.libraryelements | jar          |           |
    | org.gradle.status          | release      |           |
    | org.gradle.usage           | java-runtime |           |

org:leaf2:1.0
+--- org:middle:1.0
|    \\--- org:top:1.0
|         \\--- conf
\\--- org:top:1.0 (*)
"""
    }

// prepareDC prepares a query on the driverConn and calls release before
// returning. When cg == nil it implies that a connection pool is used, and
// when cg != nil only a single driver connection is used.
func (db *DB) prepareDC(ctx context.Context, dc *driverConn, release func(error), cg stmtConnGrabber, query string) (*Stmt, error) {
	var ds *driverStmt
	var err error
	defer func() {
		release(err)
	}()
	withLock(dc, func() {

ownership. The script below can handle this for you. Replace `RELEASE` and `NAMESPACE` with the name and namespace of the release: ```console KINDS=(service deployment) RELEASE=istio-ingressgateway NAMESPACE=istio-system for KIND in "${KINDS[@]}"; do kubectl --namespace $NAMESPACE --overwrite=true annotate $KIND $RELEASE meta.helm.sh/release-name=$RELEASE kubectl --namespace $NAMESPACE --overwrite=true annotate $KIND $RELEASE meta.helm.sh/release-namespace=$NAMESPACE kubectl --namespace $NAMESPACE --overwrite=true...

"""

        when:
        succeeds "resolve"

        then:
        outputContains("variants: [{artifactType=size, org.gradle.status=release}, {artifactType=size, org.gradle.status=release}, {artifactType=size, org.gradle.status=release}, {artifactType=size, org.gradle.status=release}]")

apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    app: istiod
    release: istio
  name: istiod
  namespace: istio-system

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    app: istio-reader
    release: istio
  name: istio-reader-clusterrole-istio-system
rules:
- apiGroups:
  - config.istio.io
  - security.istio.io
  - networking.istio.io
  - authentication.istio.io

letonComp.class package org.codehaus.plexus.component.manager; public synchronized class ClassicSingletonComp extends AbstractComponentMan { private Object lock; private java.util.Map singletonMap; public void ClassicSingletonComp(); public void release(Object) throws org.codehaus.plexus.component.repository.exception.ComponentLifecycleEx; public void dispose() throws org.codehaus.plexus.component.repository.exception.ComponentLifecycleEx; public Object getComponent(org.codehaus.plexus.classworl...

# Cluster specific test helpers

# Execute prior to running tests to build a release if required for env.
#
# Assumed Vars:
#   KUBE_ROOT
function test-build-release() {
  # Make a release
  "${KUBE_ROOT}/build/release.sh"
}

# Execute prior to running tests to initialize required structure.
#
# Assumed vars:
#   Variables from config.sh

letonComp.class package org.codehaus.plexus.component.manager; public synchronized class ClassicSingletonComp extends AbstractComponentMan { private Object lock; private java.util.Map singletonMap; public void ClassicSingletonComp(); public void release(Object) throws org.codehaus.plexus.component.repository.exception.ComponentLifecycleEx; public void dispose() throws org.codehaus.plexus.component.repository.exception.ComponentLifecycleEx; public Object getComponent(org.codehaus.plexus.classworl...

	}
	releaseLockRankAndM(lockRankGscan)
}

// This will return false if the gp is not in the expected status and the cas fails.
// This acts like a lock acquire while the casfromgstatus acts like a lock release.
func castogscanstatus(gp *g, oldval, newval uint32) bool {
	switch oldval {
	case _Grunnable,
		_Grunning,
		_Gwaiting,
		_Gsyscall:
		if newval == oldval|_Gscan {

		t.Skip("skipping allocation test when using race detector")
	}
	c := new(Conn)
	ctx := context.Background()
	n := int(testing.AllocsPerRun(1000, func() {
		_, release, err := c.grabConn(ctx)
		if err != nil {
			t.Fatal(err)
		}
		release(nil)
	}))
	if n > 0 {
		t.Fatalf("Conn.grabConn allocated %v objects; want 0", n)
	}
}

func BenchmarkGrabConn(b *testing.B) {
	b.ReportAllocs()