// to check for SSL certificate files. If set this overrides the system default.
	// It is a colon separated list of directories.
	// See https://www.openssl.org/docs/man1.0.2/man1/c_rehash.html.
	certDirEnv = "SSL_CERT_DIR"
)

func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) {
	return nil, nil
}

func loadSystemRoots() (*CertPool, error) {

      ImmutableSet<R> rowSpace,
      ImmutableSet<C> columnSpace) {
    Map<R, Integer> rowIndex = Maps.indexMap(rowSpace);
    Map<R, Map<C, V>> rows = Maps.newLinkedHashMap();
    for (R row : rowSpace) {
      rows.put(row, new LinkedHashMap<C, V>());
    }
    Map<C, Map<R, V>> columns = Maps.newLinkedHashMap();
    for (C col : columnSpace) {
      columns.put(col, new LinkedHashMap<R, V>());
    }

    myapp: ratings-myapp
  name: ratings
  namespace: default
---
apiVersion: telemetry.istio.io/v1alpha1
kind: Telemetry
metadata:
  name: maps-correctly-no-conflicts
  namespace: default
spec:
  selector:
    matchLabels:
      app: productpage # Maps to an existing workload without conflicts in the same ns, no error
  metrics:
    - providers:
        - name: prometheus
      overrides:
        - match:

import (
	"cmd/go/internal/cfg"
	"cmd/go/internal/test/internal/genflags"
	"internal/testenv"
	"maps"
	"os"
	"testing"
)

func TestMain(m *testing.M) {
	cfg.SetGOROOT(testenv.GOROOT(nil), false)
	os.Exit(m.Run())
}

func TestPassFlagToTest(t *testing.T) {
	wantNames := genflags.ShortTestFlags()

	missing := map[string]bool{}
	for _, name := range wantNames {
		if !passFlagToTest[name] {
			missing[name] = true

	}

	ns := NamingStrategy{}
	for key, value := range maps {
		if ns.toDBName(key) != value {
			t.Errorf("%v toName should equal %v, but got %v", key, value, ns.toDBName(key))
		}
	}

	maps = map[string]string{
		"x":                              "X",
		"user_restrictions":              "UserRestriction",

	// Manually load the value out of the map.
	typ := abi.TypeOf(value)
	a, ok := uniqueMaps.Load(typ)
	if !ok {
		return
	}
	m := a.(*uniqueMap[T])
	wp, ok := m.Load(value)
	if !ok {
		return
	}
	if wp.Strong() != nil {
		t.Errorf("value %v still referenced a handle (or tiny block?) ", value)
		return
	}
	t.Errorf("failed to drain internal maps of %v", value)

// during function argument type inference.
// M2's constraint is unnamed.
func f1[K1 comparable, E1 any](m1 map[K1]E1) {}

func f2[M2 map[string]int](m2 M2) {
	f1(m2)
}

// The core type of M3 unifies with the type of m1
// during function argument type inference.
// M3's constraint is named.
type Map3 map[string]int

func f3[M3 Map3](m3 M3) {
	f1(m3)
}

// The core type of M5 unifies with the core type of M4

import com.google.common.collect.Maps
import spock.lang.Specification

class GroupsJavadocOptionFileOptionTest extends Specification {
    private JavadocOptionFileWriterContext writerContextMock = Mock()
    private final String optionName = "testOption"

    private GroupsJavadocOptionFileOption groupsFile = new GroupsJavadocOptionFileOption(optionName, Maps.<String, List<String>>newLinkedHashMap())

    public SampleElements<Entry<Country, String>> samples() {
      return new SampleElements<>(
          Maps.immutableEntry(Country.CANADA, "DOLLAR"),
          Maps.immutableEntry(Country.CHILE, "PESO"),
          Maps.immutableEntry(Country.UK, "POUND"),
          Maps.immutableEntry(Country.JAPAN, "YEN"),
          Maps.immutableEntry(Country.SWITZERLAND, "FRANC"));
    }

    @SuppressWarnings("unchecked")
    @Override

	// Remove that 49th entry. m is still growing to 8 buckets,
	// but a clone of m will only have 4 buckets because it
	// only needs to fit 48 entries.
	delete(m, "foo")

	// Clone an 8-bucket map to a 4-bucket map.
	_ = maps.Clone(m)