}
		c.disableCache = true
		return false
	}

	if a.Package.Root == "" {
		// Caching does not apply to tests outside of any module, GOPATH, or GOROOT.
		if cache.DebugTest {
			fmt.Fprintf(os.Stderr, "testcache: caching disabled for package outside of module root, GOPATH, or GOROOT: %s\n", a.Package.ImportPath)
		}
		c.disableCache = true
		return false
	}

	out = append(out, x.sds.Snapshot()...)
	return out
}

// DisabledCache is a cache that is always empty
type DisabledCache struct{}

func (d DisabledCache) Run(stop <-chan struct{}) {
}

func (d DisabledCache) Add(entry XdsCacheEntry, pushRequest *PushRequest, value *discovery.Resource) {
}

func (d DisabledCache) Get(entry XdsCacheEntry) *discovery.Resource {
	return nil
}

		res[k] = v
	}
	return res
}

// disabledCache is a cache that is always empty
type disabledCache[K comparable] struct{}

var _ typedXdsCache[uint64] = &disabledCache[uint64]{}

func (d disabledCache[K]) Flush() {
}

func (d disabledCache[K]) Add(k K, entry dependents, pushReq *PushRequest, value *discovery.Resource) {
}

func (d disabledCache[K]) Get(k K) *discovery.Resource {
	return nil
}

	if hostname == "" || port == 0 {
		log.Warnf("failed to parse %v", routeName)
		return nil
	}

	virtualHosts, _, _ := core.BuildSidecarOutboundVirtualHosts(node, push, routeName, port, nil, &model.DisabledCache{})

	// Only generate the required route for grpc. Will need to generate more
	// as GRPC adds more features.
	return &route.RouteConfiguration{
		Name:         routeName,
		VirtualHosts: virtualHosts,
	}

	xdsUpdater := opts.XDSUpdater
	var endpoints *model.EndpointIndex
	if xdsUpdater == nil {
		endpoints = model.NewEndpointIndex(model.DisabledCache{})
		delegate := model.NewEndpointIndexUpdater(endpoints)
		xdsUpdater = xdsfake.NewWithDelegate(delegate)
	}

	domainSuffix := defaultFakeDomainSuffix
	if opts.DomainSuffix != "" {

	sd.WantGetProxyServiceTargets = slices.Map(serviceInstances, model.ServiceInstanceToTarget)
	env.ServiceDiscovery = sd

	env.Watcher = mesh.NewFixedWatcher(m)
	env.EndpointIndex = model.NewEndpointIndex(model.DisabledCache{})
	env.Init()
	pc := model.NewPushContext()
	_ = pc.InitContext(env, nil, nil)
	return 1
}

func FuzzBNMUnmarshalJSON(data []byte) int {
	var bnm model.BootstrapNodeMetadata

	}
	push := model.NewPushContext()
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			cb := NewClusterBuilder(proxy, &model.PushRequest{Push: push}, model.DisabledCache{})
			opts := &buildClusterOpts{
				mutable: newClusterWrapper(&cluster.Cluster{
					ClusterDiscoveryType: &cluster.Cluster_Type{Type: test.discoveryType},
				}),
				mesh: push.Mesh,
			}

		store:                configController,
		env:                  env,
		initialConfigs:       configs,
		stop:                 test.NewStop(t),
		ConfigGen:            NewConfigGenerator(&model.DisabledCache{}),
		MemRegistry:          msd,
		MemServiceRegistry:   memserviceRegistry,
		Registry:             serviceDiscovery,
		ServiceEntryRegistry: se,
	}
	if !opts.SkipRun {
		fake.Run()

	}
	push := model.NewPushContext()
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			cb := NewClusterBuilder(proxy, &model.PushRequest{Push: push}, model.DisabledCache{})
			opts := &buildClusterOpts{
				mutable: newClusterWrapper(&cluster.Cluster{
					ClusterDiscoveryType: &cluster.Cluster_Type{Type: test.discoveryType},
				}),
				mesh: push.Mesh,
			}
			if test.h2 {

	Dual = pm.Dual
)

var _ mesh.Holder = &Environment{}

func NewEnvironment() *Environment {
	var cache XdsCache
	if features.EnableXDSCaching {
		cache = NewXdsCache()
	} else {
		cache = DisabledCache{}
	}
	return &Environment{
		pushContext:   NewPushContext(),
		Cache:         cache,
		EndpointIndex: NewEndpointIndex(cache),
	}
}

// Environment provides an aggregate environmental API for Pilot