if ( info502.security_descriptor != null ) {
            SecurityDescriptor sd;
            sd = new SecurityDescriptor(info502.security_descriptor, 0, info502.sd_size);
            return sd.getAces();
        }
        return null;
    }

        this.consumerValue = consumerValue;
    }

    @Override
    public boolean hasResult() {
        return singleMatch != null || multipleMatches!=null;
    }

    @Override
    public Set<T> getMatches() {
        assert hasResult();
        if (singleMatch != null) {
            return Collections.singleton(singleMatch);
        }
        return multipleMatches;
    }

    @Nullable
    @Override

        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)

        when:
        cachedIndex.storeInternal("foo", cachedItem(cachedFile))
        def item = cachedIndex.lookup("foo")

        then:
        item == null
        cacheAccessCoordinator.getCache(CACHE_NAME).getIfPresent("foo") == null
        0 * fileAccessTracker.markAccessed(_)
    }

    def "returns missing items"() {
        given:
        def missingItem = cachedItem(null, true)

        when:

	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(

	for _, filterChain := range fChains {
		fc := filterchain{
			destination: getFilterType(filterChain.GetFilters()),
			match:       getMatches(filterChain.FilterChainMatch),
		}
		resp = append(resp, fc)
	}
	return resp
}

func getMatches(f *listener.FilterChainMatch) string {
	match := f
	if match == nil {
		match = &listener.FilterChainMatch{}
	}

    }


    /**
     * @return the type
     */
    public final int getType () {
        return this.type;
    }


    /**
     * @return the aces
     */
    public final ACE[] getAces () {
        return this.aces;
    }


    /**
     * @return the ownerGroupSid
     */
    public final SID getOwnerGroupSid () {
        return this.ownerGroupSid;
    }


    /**

                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<?>>)