fromList.subList(fromIndex, toIndex).clear();
    }

    @Override
    @ParametricNullness
    public T get(int index) {
      return function.apply(fromList.get(index));
    }

    @Override
    public Iterator<T> iterator() {
      return listIterator();
    }

    @Override
    public ListIterator<T> listIterator(int index) {

      this.keyIndex = keyIndex;
    }

    @Override
    public Set<K> keySet() {
      return keyIndex.keySet();
    }

    K getKey(int index) {
      return keyIndex.keySet().asList().get(index);
    }

    abstract String getKeyRole();

    @ParametricNullness
    abstract V getValue(int index);

    @ParametricNullness
    abstract V setValue(int index, @ParametricNullness V newValue);

            @Override
            public int size() {
              return axes.size();
            }

            @Override
            public List<E> get(int index) {
              return axes.get(index).asList();
            }

            @Override
            boolean isPartialView() {
              return true;
            }

            // redeclare to help optimizers with b/310253115

    public int size() {
      return ImmutableMultimap.this.size();
    }

    @Override
    Multiset.Entry<K> getEntry(int index) {
      Map.Entry<K, ? extends Collection<V>> entry = map.entrySet().asList().get(index);
      return Multisets.immutableEntry(entry.getKey(), entry.getValue().size());
    }

    @Override
    boolean isPartialView() {
      return true;
    }

    @GwtIncompatible

            // Select channel based on affinity key
            List<ChannelInfo> list = new ArrayList<>(channels);
            int index = Math.abs((int)(affinityKey % list.size()));
            return list.get(index);
        }
        
        // No affinity, use weighted random
        return selectWeightedRandom(channels);
    }
    

          addToMap();
        }
      }
      return changed;
    }

    @Override
    @ParametricNullness
    public V get(int index) {
      refreshIfEmpty();
      return getListDelegate().get(index);
    }

    @Override
    @ParametricNullness
    public V set(int index, @ParametricNullness V element) {
      refreshIfEmpty();
      return getListDelegate().set(index, element);
    }

        return Lists.asList("foo", "bar", new String[0]).iterator();
      }
    }.test();
  }

  private static void assertIndexIsOutOfBounds(List<String> list, int index) {
    try {
      list.get(index);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testReverseViewRandomAccess() {
    List<Integer> fromList = new ArrayList<>(SOME_LIST);

        // Align to 8-byte boundary
        ndrBuffer.setIndex(5);
        alignedBytes = ndrBuffer.align(8);
        assertEquals(3, alignedBytes); // Should advance by 3 bytes (5 -> 8)
        assertEquals(8, ndrBuffer.getIndex());
    }

    @Test
    void testEncDecNdrSmall() {
        ndrBuffer.enc_ndr_small(0xAB);
        assertEquals(1, ndrBuffer.getIndex());

    }

    @Override
    ImmutableList<E> createAsList() {
      return new ImmutableAsList<E>() {
        @Override
        public E get(int index) {
          return Indexed.this.get(index);
        }

        @Override
        Indexed<E> delegateCollection() {
          return Indexed.this;
        }

        // redeclare to help optimizers with b/310253115

      public E next() {
        checkConcurrentModification();
        if (!hasNext()) {
          throw new NoSuchElementException();
        }
        canRemove = true;
        return elements.get(index++);
      }

      @Override
      public void remove() {
        checkConcurrentModification();
        checkRemove(canRemove);
        elements.remove(--index);
        expectedModCount = ++modCount;