DocMap docMap = new DocMap(value);
        assertTrue(docMap.isEmpty());
        value.clear();

        List<String> keys = Arrays.asList("test_2", "test_0", "lang", "test_1");
        value.put(keys.get(0), true);
        value.put(keys.get(1), 1000);
        value.put(keys.get(2), "ja");
        value.put(keys.get(3), "str");
        docMap = new DocMap(value);
        assertFalse(docMap.isEmpty());

    this.keys = keys;
    this.values = values;
  }

  @Override
  public SampleElements<Entry<K, V>> samples() {
    return SampleElements.mapEntries(keys, values);
  }

  @Override
  public Set<Entry<K, V>> create(Object... elements) {
    Entry<K, V>[] entries = createArray(elements.length);
    System.arraycopy(elements, 0, entries, 0, elements.length);

type AESConfiguration struct {
	// keys is a list of keys to be used for creating the AES transformer.
	// Each key has to be 32 bytes long for AES-CBC and 16, 24 or 32 bytes for AES-GCM.
	Keys []Key `json:"keys"`
}

// SecretboxConfiguration contains the API configuration for an Secretbox transformer.
type SecretboxConfiguration struct {
	// keys is a list of keys to be used for creating the Secretbox transformer.

// Batch represents an ordered batch
type Batch[K key, T any] struct {
	keys  []K
	items map[K]T
	limit uint32

	sync.Mutex
}

// Add adds the item to the batch
func (b *Batch[K, T]) Add(key K, item T) error {
	b.Lock()
	defer b.Unlock()

	if b.isFull() {
		return ErrBatchFull
	}

	if _, ok := b.items[key]; !ok {
		b.keys = append(b.keys, key)
	}
	b.items[key] = item

	return nil
}

		}
	})

	t.Run("clear all", func(t *testing.T) {
		c := model.NewXdsCache()
		start := time.Now()
		c.Add(ep1, &model.PushRequest{Start: start}, any1)
		c.Add(ep2, &model.PushRequest{Start: start}, any2)

		c.ClearAll()
		if len(c.Keys(model.EDSType)) != 0 {
			t.Fatalf("expected no keys, got: %v", c.Keys(model.EDSType))
		}

func (m *BiMultimap) Select(key Key) (keys []Key, ok bool) {
	m.mux.RLock()
	defer m.mux.RUnlock()

	selectingObject, ok := m.selectingObjects[key]
	if !ok {
		// Does not exist.
		return nil, false
	}
	keys = make([]Key, 0)
	if labeled, ok := m.labeledBySelecting[selectingObject.selectorKey]; ok {
		for _, labeledObject := range labeled.objects {
			keys = append(keys, labeledObject.key)
		}
	}

        [group: 'foo']               | "Required keys [name, version] are missing from map {group=foo}."
        [name: 'foo']                | "Required keys [group, version] are missing from map {name=foo}."
        [name: 'foo', version: 'v1'] | "Required keys [group] are missing from map {name=foo, version=v1}."
        [name: null]                 | "Required keys [group, name, version] are missing from map {name=null}."
    }

    this.keys = keys;
    this.values = values;
  }

  @Override
  public SampleElements<Entry<K, V>> samples() {
    return SampleElements.mapEntries(keys, values);
  }

  @Override
  public Set<Entry<K, V>> create(Object... elements) {
    Entry<K, V>[] entries = createArray(elements.length);
    System.arraycopy(elements, 0, entries, 0, elements.length);

	return b
}

// Init removes all keys from the map.
func (v *Map) Init() *Map {
	v.keysMu.Lock()
	defer v.keysMu.Unlock()
	v.keys = v.keys[:0]
	v.m.Clear()
	return v
}

// addKey updates the sorted list of keys in v.keys.
func (v *Map) addKey(key string) {
	v.keysMu.Lock()
	defer v.keysMu.Unlock()
	// Using insertion sort to place key into the already-sorted v.keys.

	listFromIndex func() any
	indexMatches  func(any) bool
}

func (f *filter) String() string {
	attrs := []string{}
	if !f.keys.IsNil() {
		attrs = append(attrs, "keys="+f.keys.String())
	}
	if f.selectsNonEmpty != nil {
		attrs = append(attrs, fmt.Sprintf("selectsNonEmpty=%v", f.selectsNonEmpty))
	}
	if f.selects != nil {
		attrs = append(attrs, fmt.Sprintf("selects=%v", f.selects))
	}