.replaceAll(
            (K k, V v) -> {
              int index = keys().asList().indexOf(k);
              return values().asList().get(index + 1);
            });
    List<Entry<K, V>> orderedEntries = getOrderedElements();
    int index = 0;
    for (K key : getMap().keySet()) {
      assertEquals(orderedEntries.get(index).getKey(), key);
      index++;
    }
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)

    void writeParameterWordsWireFormatReturnsZero(int index) {
        SmbComLogoffAndX msg = new SmbComLogoffAndX(null);
        assertEquals(0, msg.writeParameterWordsWireFormat(new byte[10], index), "Expected zero returned regardless of index");
        assertEquals(0, msg.writeParameterWordsWireFormat(null, index), "Expected zero even when dst array is null");
    }

    @ParameterizedTest

    private int queryFreqThreshold = 10;

    private final List<String> excludeWords = new ArrayList<>();

    /**
     * Sets the index name.
     * @param index The index name.
     */
    public void setIndex(final String index) {
        this.index = index;
    }

    /**
     * Sets the size of results.
     * @param size The size.
     */
    public void setSize(final int size) {

     *
     * @param index
     *            The index of the parameter
     * @return The element type if the parameter type is a parameterized {@link Collection}, otherwise {@literal null}
     */
    Class<?> getElementClassOfCollection(int index);

    /**
     * Returns the key type if the parameter type of the method is a parameterized {@link Map}.
     *
     * @param index
     *            The index of the parameter

        return client.index(request);
    }

    /**
     * Executes an index request asynchronously.
     *
     * @param request The index request.
     * @param listener The response listener.
     */
    @Override
    public void index(final IndexRequest request, final ActionListener<IndexResponse> listener) {
        client.index(request, listener);
    }

    /**

func (c *esClientV7) updateEntry(ctx context.Context, index string, key string, eventData event.Event) error {
	doc := map[string]any{
		"Records": []event.Event{eventData},
	}
	var buf bytes.Buffer
	enc := json.NewEncoder(&buf)
	err := enc.Encode(doc)
	if err != nil {
		return err
	}
	res, err := c.Index(
		index,
		&buf,
		c.Index.WithDocumentID(key),
		c.Index.WithContext(ctx),
	)
	if err != nil {

			fi := metadata[index]
			// Assign index when index is initialized
			if fi.Erasure.Index == 0 {
				fi.Erasure.Index = index + 1
			}

			if !fi.IsValid() {
				return errFileCorrupt
			}
			resp, err := disks[index].RenameData(ctx, srcBucket, srcEntry, fi, dstBucket, dstEntry, RenameOptions{})
			if err != nil {
				return err
			}
			diskVersions[index] = resp.Sign

    /** The element. */
    private final T element;

    /** The index of the element. */
    private final int index;

    /**
     * Constructor.
     *
     * @param element the element
     * @param index the index of the element
     */
    public Indexed(final T element, final int index) {
        this.element = element;
        this.index = index;
    }

    /**
     * Returns the element.
     *

    public @Nullable V get(@Nullable Object key) {
      Integer index = keyIndex.get(key);
      if (index == null) {
        return null;
      } else {
        return getValue(index);
      }
    }

    @Override
    public @Nullable V put(K key, @ParametricNullness V value) {
      Integer index = keyIndex.get(key);
      if (index == null) {
        throw new IllegalArgumentException(

    }

    private int reverseIndex(int index) {
      int size = size();
      checkElementIndex(index, size);
      return (size - 1) - index;
    }

    private int reversePosition(int index) {
      int size = size();
      checkPositionIndex(index, size);
      return size - index;
    }

    @Override
    public void add(int index, @ParametricNullness T element) {