"istio.io/istio/pkg/config/schema/gvk"
	"istio.io/istio/pkg/maps"
	"istio.io/istio/pkg/util/protomarshal"
)

type EffectiveProxyConfigResolver struct {
	meshConfig    *meshconfig.MeshConfig
	rootNamespace string
	root          *v1beta1.ProxyConfig
	namespace     map[string]*v1beta1.ProxyConfig
	workload      map[string]*v1beta1.ProxyConfig
}

	}
	// unstructured maps, as seen in annotations
	// map keys must be strings
	if mapOfVal, ok := value.Value().(map[ref.Val]ref.Val); ok {
		result := make(map[string]any)
		for k, v := range mapOfVal {
			stringKey, ok := k.Value().(string)
			if !ok {
				return nil, fmt.Errorf("map key %q is of type %t, not string", k, k)
			}
			result[stringKey] = v.Value()
		}
		return result, nil
	}

    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(
        Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = Maps.newHashMap();
    expected.put(k0(), Sets.newHashSet(v0(), v3()));
    expected.put(k1(), Sets.newHashSet(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

    private static final String COLOR_DIVIDER = "-";

    /**
     * Maps a {@link StyledTextOutput.Style} to the default color spec (that can be overridden by system properties)
     */
    private final Map<String, String> defaults = new HashMap<String, String>();

    /**
     * Maps a {@link StyledTextOutput.Style} to the {@link org.gradle.internal.logging.console.ColorMap.Color} that has been created for it

	"bufio",
	"bytes",
	"cmp",
	"context",
	"crypto",
	"embed",
	"encoding",
	"errors",
	"expvar",
	"flag",
	"fmt",
	"hash",
	"html",
	"image",
	"io",
	"iter",
	"log",
	"maps",
	"math",
	"mime",
	"net",
	"os",
	"path",
	"plugin",
	"reflect",
	"regexp",
	"runtime",
	"slices",
	"sort",
	"strconv",
	"strings",
	"structs",
	"sync",
	"syscall",
	"testing",

	return Handle[T]{ptr}
}

var (
	// uniqueMaps is an index of type-specific concurrent maps used for unique.Make.
	//
	// The two-level map might seem odd at first since the HashTrieMap could have "any"
	// as its key type, but the issue is escape analysis. We do not want to force lookups
	// to escape the argument, and using a type-specific map allows us to avoid that where

plugins {
    id("gradlebuild.distribution.api-java")
    id("gradlebuild.publish-public-libraries")
}

description = """Persistent caches on disk and cross process locking.
    | Mostly for persisting Maps to the disk.
    | Also contains implementations for in-memory caches in front of the disk cache.
""".trimMargin()

dependencies {
    api(projects.concurrent)
    api(projects.stdlibJavaExtensions)
    api(projects.serialization)

    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(
        Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = Maps.newHashMap();
    expected.put(k0(), Sets.newHashSet(v0(), v3()));
    expected.put(k1(), Sets.newHashSet(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package reflect_test

import (
	"iter"
	"maps"
	. "reflect"
	"testing"
)

func TestValueSeq(t *testing.T) {
	m := map[string]int{
		"1": 1,
		"2": 2,
		"3": 3,
		"4": 4,
	}
	c := make(chan int, 3)
	for i := range 3 {
		c <- i
	}
	close(c)
	tests := []struct {

		IntDec: cbor.IntDecConvertSignedOrFail,

		// Disable producing map[cbor.ByteString]interface{}, which is not acceptable for
		// decodes into interface{}.
		MapKeyByteString: cbor.MapKeyByteStringForbidden,

		// Error on map keys that don't map to a field in the destination struct.
		ExtraReturnErrors: cbor.ExtraDecErrorUnknownField,

		// Decode maps into concrete type map[string]interface{} when the destination is an
		// interface{}.