Laura Kassovic <******@****.***> 1701107622 -0800

        try {
            buildCache.store(cacheKey, work, outputFilesProducedByWork, executionTime);
            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("Stored cache entry for {} with cache key {}",
                    work.getDisplayName(), cacheKey.getHashCode());
            }
        } catch (Exception e) {
            throw new RuntimeException(

)

// NewContext allows tests to use istiodContext without exporting it.  returned context is not threadsafe.
func NewContext(stores map[cluster.ID]model.ConfigStore, cancelCh <-chan struct{}, collectionReporter CollectionReporterFn) analysis.Context {
	return &istiodContext{
		stores:             stores,
		cancelCh:           cancelCh,
		messages:           map[string]*diag.Messages{},
		collectionReporter: collectionReporter,

import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Set;

/**
 * A specialized map wrapper, that uses weak references for keys and stores
 * values as strong references. It allows the garbage collector to collect keys when they are no longer in use.
 *
 * Keys are stored wrapped in {@code WeakIdentityHashMap.WeakKey} weak reference implementation, that uses {@code System.identityHashCode}

// license that can be found in the LICENSE file.

package main

import "./a"

func F() {
	// store 1 in a.global
	x, y := 1, 2
	t := a.T{Pointer: &x}
	a.Store(&t)
	_ = y
}

func G() {
	// store 4 in a.global2
	x, y := 3, 4
	t := a.T{Pointer: &y}
	a.Store2(&t)
	_ = x
}

func main() {
	F()
	G()
	p := a.Get()
	n := *p
	if n != 1 {
		println(n, "!= 1")

// testDeadStorePanic_ssa ensures that we don't optimize away stores
// that could be read by after recover().  Modeled after fixedbugs/issue1304.
//
//go:noinline
func testDeadStorePanic_ssa(a int) (r int) {
	defer func() {
		recover()
		r = a
	}()
	a = 2      // store
	b := a - a // optimized to zero
	c := 4
	a = c / b // store, but panics
	a = 3     // store
	r = a
	return
}

// The return value is the address of a bool variable that stores the value of the flag.
func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
	p := new(bool)
	f.BoolVar(p, name, value, usage)
	return p
}

// Bool defines a bool flag with specified name, default value, and usage string.
// The return value is the address of a bool variable that stores the value of the flag.

	// read contains the portion of the map's contents that are safe for
	// concurrent access (with or without mu held).
	//
	// The read field itself is always safe to load, but must only be stored with
	// mu held.
	//
	// Entries stored in read may be updated concurrently without mu, but updating
	// a previously-expunged entry requires that the entry be copied to the dirty
	// map and unexpunged with mu held.
	read atomic.Pointer[readOnly]

    }

    def "stores entry - lastModified = #lastModified"() {
        given:
        def key = "key"
        def artifactFile = tmp.createFile("artifact") << "content"

        when:
        index.store(key, artifactFile, new DefaultExternalResourceMetaData(new URI("abc"), lastModified, 100, contentType, etag, sha1, null, false))

	if shortcut {
		store = false    // stop storing only after the shortcut node.
		shortcut = false // remove shortcut node flag
	}
	if len(lnode) == 0 && len(rnode) == 0 && len(keys) == 1 && store {
		if !bytes.Equal(values[0], defaultLeaf) {
			shortcut = true
		} else {
			// if the subtree contains only one key, store the key/value in a shortcut node
			store = false
		}
	}
	switch {