def store2 = stores1.nextBinaryStore() // rolled
        def store3 = f.createStoreSet().nextBinaryStore()

        then:
        store.file != store2.file //rolled
        [store.file, store2.file, store3.file].each { it.exists() }

        when:
        new CompositeStoppable().add(store, store2, store3)

        then:
        [store.file, store2.file, store3.file].each { !it.exists() }
    }

func TestAggregateStoreWrite(t *testing.T) {
	g := NewWithT(t)

	store1 := memory.Make(collection.SchemasFor(collections.HTTPRoute))
	store2 := memory.Make(collection.SchemasFor(collections.HTTPRoute))

	stores := []model.ConfigStore{store1, store2}

	store, err := makeStore(stores, store1)
	g.Expect(err).NotTo(HaveOccurred())

	if _, err := store.Create(config.Config{
		Meta: config.Meta{

        def store2 = factory.createCachedStore("conf2")

        expect:
        store1.load(() -> results1) == results1
        store1.load(() -> { assert false }) == results1
        store1b.load(() -> { assert false }) == results1
        store2.load(() -> results2) == results2
    }

			Valu("store1", OpStore, types.TypeMem, 0, c.config.Types.Bool, "addr1", "v", "zero1"),
			Valu("store2", OpStore, types.TypeMem, 0, c.config.Types.Bool, "addr2", "v", "store1"),
			Valu("store3", OpStore, types.TypeMem, 0, c.config.Types.Bool, "addr1", "v", "store2"),
			Valu("store4", OpStore, types.TypeMem, 0, c.config.Types.Bool, "addr3", "v", "store3"),
			Goto("exit")),
		Bloc("exit",
			Exit("store3")))

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

package a

var global, global2 *int

type T struct {
	Pointer *int
}

//go:noinline
func Store(t *T) {
	global = t.Pointer
}

//go:noinline
func Store2(t *T) {
	global2 = t.Pointer
}

func Get() *int {
	return global

// 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")

}

// storeOrder orders values with respect to stores. That is,
// if v transitively depends on store s, v is ordered after s,
// otherwise v is ordered before s.
// Specifically, values are ordered like
//
//	store1
//	NilCheck that depends on store1
//	other values that depends on store1
//	store2
//	NilCheck that depends on store2
//	other values that depends on store2
//	...
//

type store struct {
	client              *clientv3.Client
	codec               runtime.Codec
	versioner           storage.Versioner
	transformer         value.Transformer
	pathPrefix          string
	groupResource       schema.GroupResource
	groupResourceString string
	watcher             *watcher
	leaseManager        *leaseManager
}

func (s *store) RequestWatchProgress(ctx context.Context) error {

	DestroyFunc func()
}

// Note: the rest.StandardStorage interface aggregates the common REST verbs
var _ rest.StandardStorage = &Store{}
var _ rest.TableConvertor = &Store{}
var _ GenericStore = &Store{}

var _ rest.SingularNameProvider = &Store{}

const (
	OptimisticLockErrorMsg        = "the object has been modified; please apply your changes to the latest version and try again"

}

// HasWatcher - returns if the storage system has a watcher.
func (store *IAMStoreSys) HasWatcher() bool {
	_, ok := store.IAMStorageAPI.(iamStorageWatcher)
	return ok
}

// GetUser - fetches credential from memory.
func (store *IAMStoreSys) GetUser(user string) (UserIdentity, bool) {
	cache := store.rlock()
	defer store.runlock()

	u, ok := cache.iamUsersMap[user]
	if !ok {
		// Check the sts map