public static ModelCache newInstance(RepositorySystemSession session, boolean anew) {
        ConcurrentHashMap<Object, Supplier<?>> cache;
        RepositoryCache repositoryCache = session != null ? session.getCache() : null;
        if (repositoryCache == null) {
            return new DefaultModelCache(new ConcurrentHashMap<>());
        } else {
            if (anew) {
                cache = new ConcurrentHashMap<>();

func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn {
	if r == nil {
		r = bufio.NewReader(c)
	}
	return &ServerConn{c: c, r: r, pipereq: make(map[*http.Request]uint)}
}

// Hijack detaches the [ServerConn] and returns the underlying connection as well
// as the read-side bufio which may have some left over data. Hijack may be
// called before Read has signaled the end of the keep-alive logic. The user

}

var _ volume.Unmounter = &portworxVolumeUnmounter{}

// Unmounts the bind mount, and detaches the disk only if the PD
// resource was the last reference to that disk on the kubelet.
func (c *portworxVolumeUnmounter) TearDown() error {
	return c.TearDownAt(c.GetPath())
}

// Unmounts the bind mount, and detaches the disk only if the PD
// resource was the last reference to that disk on the kubelet.

    }

    /**
     * Returns all matches, when there were more than 1.
     *
     * @return The matches. Returns an empty set when there are no matches.
     */
    public Set<String> getMatches() {
        return matches;
    }

    /**
     * Returns the potential matches, if any.
     *
     * @return The matches. Returns an empty set when there are no potential matches.
     */

            if (value == null || !explanationBuilder.canSkipExplanation()) {
                int[] matches = new MultipleCandidateMatcher<>(schema, candidateList, requestedAttributes, explanationBuilder).getMatches();
                LOGGER.debug("Selected matches {} from candidates {} for {}", Ints.asList(matches), candidateList, requested);
                return matches;
            }
            return value;
        });

	scope.Infof("Processing resources from manifest: %s for CR %s", cname, crHash)
	allObjects, err := object.ParseK8sObjectsFromYAMLManifest(manifest.Content)
	if err != nil {
		return result, err
	}

	objectCache := cache.GetCache(crHash)

	// Ensure that for a given CR crHash only one control loop uses the per-crHash cache at any time.
	objectCache.Mu.Lock()
	defer objectCache.Mu.Unlock()

	framework.NewTest(t).
		Run(func(t framework.TestContext) {
			t.Skip("https://github.com/istio/istio/issues/34051")
			// Get all the clusters where service B resides.
			bClusters := serviceB.GetMatches(echos.Instances).Clusters()

			// Test exporting service B exclusively in each cluster.
			for _, exportCluster := range bClusters {
				exportCluster := exportCluster

	// Watch for changes to primary resource IstioOperator
	err = c.Watch(source.Kind(
		mgr.GetCache(),
		&iopv1alpha1.IstioOperator{},
		&handler.TypedEnqueueRequestForObject[*iopv1alpha1.IstioOperator]{},
		operatorPredicates,
	))
	if err != nil {
		return err
	}
	// watch for changes to Istio resources
	err = watchIstioResources(mgr.GetCache(), c)
	if err != nil {
		return err
	}
	scope.Info("Controller added")

    def key = new TestBuildCacheKey(0x01234567abcdef)
    private config = TestUtil.newInstance(HttpBuildCache.class)

    HttpBuildCacheService cacheRef

    HttpBuildCacheService getCache() {
        if (cacheRef == null) {
            buildCacheDescriber = new NoopBuildCacheDescriber()

	go adc.reconciler.Run(tCtx)
	go adc.desiredStateOfWorldPopulator.Run(tCtx)
	if tc.csiMigration {
		verifyExpectedVolumeState(t, adc, tc)
	} else {
		// Verify if expected attaches and detaches have happened
		testPlugin := plugins[0].(*controllervolumetesting.TestPlugin)
		verifyAttachDetachCalls(t, testPlugin, tc)
	}

}