Tom Tresansky <******@****.***> 1696954098 -0400

	}
	g.Expect(keys[1]).To(Equal(expected))

	file = c.GetFileFor(keys[1])
	by, err = os.ReadFile(file)
	g.Expect(err).To(BeNil())
	g.Expect(strings.TrimSpace(string(by))).To(Equal(strings.TrimSpace(virtualService)))

	applyKeys := keys
	keys = c.AllKeys()
	g.Expect(keys).To(HaveLen(2))
	g.Expect(keys).To(ContainElement(applyKeys[0]))
	g.Expect(keys).To(ContainElement(applyKeys[1]))

		if err != nil {
			return keys, err
		}
		if len(key) == 0 {
			return keys, fmt.Errorf("xlMetaInlineData: key %d is length 0", i)
		}
		keys = append(keys, string(key))
		// Skip data...
		_, buf, err = msgp.ReadBytesZC(buf)
		if err != nil {
			return keys, err
		}
	}
	return keys, nil
}

// serialize will serialize the provided keys and values.

	tests := []struct {
		input          string
		keys           []string
		expectedFields map[string]struct{}
	}{
		// No keys present
		{
			input:          "",
			keys:           []string{"comment"},
			expectedFields: map[string]struct{}{},
		},
		// No keys requested for tokenizing
		{
			input:          `comment="Hi this is my comment ="`,
			keys:           []string{},
			expectedFields: map[string]struct{}{},

	smt.atomicUpdate = false

	// Add data to empty trie
	keys := getFreshData(10)
	values := getFreshData(10)
	ch := make(chan result, 1)
	smt.update(smt.root, keys, values, nil, 0, smt.trieHeight, false, true, ch)
	res := <-ch
	root := res.update

	// Check all keys have been stored
	for i, key := range keys {
		value, _ := smt.get(root, key, nil, 0, smt.trieHeight)
		if !bytes.Equal(values[i], value) {

        return ImmutableMultiset.copyOf(keys);
      }
    },
    COPY_OF_ITERATOR {
      @Override
      public ImmutableMultiset<Object> create(List<?> keys) {
        return ImmutableMultiset.copyOf(keys.iterator());
      }
    },
    BUILDER_ADD_ENTRY_BY_ENTRY {
      @Override
      public ImmutableMultiset<Object> create(List<?> keys) {

	// Then iterate over that slice to fetch the values to be hashed.
	keys := []string{}
	for key := range cm.Data {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	for _, key := range keys {
		hash.Write([]byte(cm.Data[key]))
	}

	// Do the same as above, but for binaryData this time.
	keys = []string{}
	for key := range cm.BinaryData {

type Set[T comparable] map[T]struct{}

func (s *Set[string]) String() string {
	keys := make([]string, 0, len(*s))
	for k := range *s {
		keys = append(keys, k)
	}
	sort.Strings(keys /* ERRORx "cannot use keys.*with string declared at.*|type parameter" */ )
	return strings /* ERROR "cannot use strings.Join" */ .Join(keys /* ERRORx "cannot use keys.*with string declared at.*|type parameter" */ , ",")

}

func (x XdsCacheImpl) Keys(t string) []any {
	switch t {
	case CDSType:
		keys := x.cds.Keys()
		return convertToAnySlices(keys)
	case EDSType:
		keys := x.eds.Keys()
		return convertToAnySlices(keys)
	case SDSType:
		keys := x.sds.Keys()
		return convertToAnySlices(keys)
	case RDSType:
		keys := x.rds.Keys()
		return convertToAnySlices(keys)
	default:
		return nil
	}
}

		keyField := s.XListMapKeys[0]
		keys := make([]interface{}, 0, len(obj))
		for _, x := range obj {
			if x == nil {
				keys = append(keys, unspecifiedKeyValue{}) // nil object means unspecified key
				continue
			}

			x := x.(map[string]interface{})

			// undefined key?
			key, ok := x[keyField]
			if !ok {
				keys = append(keys, unspecifiedKeyValue{})
				continue
			}