return func(i echo.Instance) bool {
			return strings.HasPrefix(i.Config().Service, prefix)
		}
	}
	client = servicePrefix("client").GetMatches(echos)
	server = match.ServiceName(echo.NamespacedName{Name: "server", Namespace: appNsInst}).GetMatches(echos)
	ingInst = ist.IngressFor(ctx.Clusters().Default())
	addrs, _ := ingInst.HTTPAddresses()

import java.util.function.Supplier

class ArtifactCacheLockingAccessCoordinatorStub implements ArtifactCacheLockingAccessCoordinator {
    private final Map<String, IndexedCache<?, ?>> caches = [:]

    IndexedCache<?, ?> getCache(String cacheName) {
        caches[cacheName]
    }

    @Override
    <K, V> IndexedCache<K, V> createCache(String cacheName, Serializer<K> keySerializer, Serializer<V> valueSerializer) {

        }
        int targetSize = cacheSizer.scaleCacheSize(maxEntriesToKeepInMemory);
        CacheDetails cacheDetails = getCache(cacheId, targetSize);
        return new InMemoryDecoratedCache<>(backingCache, cacheDetails.entries, cacheId, cacheDetails.lockState);
    }

    private CacheDetails getCache(final String cacheId, final int maxSize) {
        CacheDetails cacheDetails = caches.get(cacheId, () -> {

	}
	return b.WithConfig(config)
}

func (e *External) LoadValues(echos echo.Instances) {
	e.All = match.ServiceName(echo.NamespacedName{Name: ExternalSvc, Namespace: e.Namespace}).GetMatches(echos)

    }

    /**
     * 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.
     */

        request.userProperties(session.getUserProperties());
        request.modelCache(DefaultModelCache.newInstance(session, false));
        if (session.getCache() != null) {
            Map<?, ?> map = (Map) session.getCache().get(session, DefaultModelCache.class.getName());
            List<String> paths = map.keySet().stream()
                    .map(Object::toString)

	if err != nil {
		return err
	}
	for _, c := range ctx.Clusters() {
		ingr = append(ingr, ist.IngressFor(c))
	}
	mockProm = match.ServiceName(echo.NamespacedName{Name: "mock-prom", Namespace: apps.Namespace}).GetMatches(apps.Echos().All.Instances())
	promInst, err = prometheus.New(ctx, prometheus.Config{})
	if err != nil {
		return
	}

	args := map[string]any{
		"DockerConfigJson": base64.StdEncoding.EncodeToString(

                result = new DefaultMultipleCandidateResult<>(requested, candidates);
                rules.execute(result);
                if (result.hasResult()) {
                    return result.getMatches();
                }
            }

            rules = producerSchema.disambiguationRules(attribute);
            if (rules.doesSomething()) {
                if (result == null) {

			ctx.NewSubTest("exported").RunParallel(
				func(ctx framework.TestContext) {
					serviceB := match.ServiceName(echo.NamespacedName{Name: common.ServiceB, Namespace: echos.Namespace})
					for _, cluster := range serviceB.GetMatches(echos.Instances).Clusters() {
						cluster := cluster
						ctx.NewSubTest(cluster.StableName()).RunParallel(func(ctx framework.TestContext) {
							// Verify that the ServiceExport was created.

    @SuppressWarnings("unchecked")
    public static ModelCache newInstance(RepositorySystemSession session) {
        ConcurrentHashMap<Object, Supplier<?>> cache;
        RepositoryCache repositoryCache = session.getCache();
        if (repositoryCache == null) {
            cache = new ConcurrentHashMap<>();
        } else {
            cache = (ConcurrentHashMap<Object, Supplier<?>>)