public List<String> order(List<String> insertionOrder) {
                    List<String> order = new ArrayList<>();
                    for (String s : insertionOrder) {
                      int index = order.indexOf(s);
                      if (index == -1) {
                        order.add(s);
                      } else {
                        order.add(index, s);
                      }
                    }

            parent.add(index, element);
        }

        public E remove(final int index) {
            return parent.remove(index);
        }

        public int indexOf(final Object o) {
            return parent.indexOf(o);
        }

        public int lastIndexOf(final Object o) {
            return parent.lastIndexOf(o);
        }

        public ListIterator<E> listIterator() {

        }
        is MappedRange.External -> {
          // Write the mapping.
          val mappingOffset: Int
          val mappedTo = range.mappedTo.utf8()
          val mappingIndex = mappingsBuffer.indexOf(mappedTo)
          if (mappingIndex == -1) {
            mappingOffset = mappingsBuffer.length
            mappingsBuffer.append(mappedTo)
          } else {
            mappingOffset = mappingIndex
          }

    return intersectionInCurrentDomain(Range.downTo(fromElement, BoundType.forBoolean(inclusive)));
  }

  @GwtIncompatible // not used by GWT emulation
  @Override
  int indexOf(@Nullable Object target) {
    if (!contains(target)) {
      return -1;
    }
    // The cast is safe because of the contains check—at least for any reasonable Comparable class.
    @SuppressWarnings("unchecked")

            parent.add(index, element);
        }

        public E remove(final int index) {
            return parent.remove(index);
        }

        public int indexOf(final Object o) {
            return parent.indexOf(o);
        }

        public int lastIndexOf(final Object o) {
            return parent.lastIndexOf(o);
        }

        public ListIterator<E> listIterator() {

            System.clearProperty(Constants.FESS_CONF_PATH);
        }

        List<String> cmdList = mockProcessHelper.getLastCommandList();
        if (cmdList != null) {
            int cpIndex = cmdList.indexOf("-cp");
            if (cpIndex >= 0 && cpIndex + 1 < cmdList.size()) {
                String classpath = cmdList.get(cpIndex + 1);
                assertTrue(classpath.contains(confPath));
            }
        }

        final Map<String, List<String>> paramListMap = new HashMap<>();
        final String[] pairs = queryString.split("&");
        try {
            for (final String pair : pairs) {
                final int pos = pair.indexOf('=');
                if (pos >= 0) {
                    final String key = urlCodec.decode(pair.substring(0, pos), enc);
                    List<String> list = paramListMap.get(key);
                    if (list == null) {

    List<E> expected = copyToList(getSampleElements());
    expected.addAll(index, elements);
    expectContents(expected);
  }

  /*
   * TODO: if we're testing a list, we could check indexOf(). (Doing it in
   * AbstractListTester isn't enough because many tests that run on lists don't
   * extends AbstractListTester.) We could also iterate over all elements to
   * verify absence
   */

      V value = getListDelegate().remove(index);
      totalSize--;
      removeIfEmpty();
      return value;
    }

    @Override
    public int indexOf(@Nullable Object o) {
      refreshIfEmpty();
      return getListDelegate().indexOf(o);
    }

    @Override
    public int lastIndexOf(@Nullable Object o) {
      refreshIfEmpty();
      return getListDelegate().lastIndexOf(o);
    }

                                final String name = entryName.substring(path.length() + 1, entryName.length() - 1);
                                if (name.indexOf('/') == -1) {
                                    subPackages.add(name);
                                    logger.debug("found {} in {}", name, resource);
                                }
                            }