byte[] array = {(byte) 0, (byte) 1, (byte) 2, (byte) 3};
    List<Byte> list = Bytes.asList(array);
    assertThat(Bytes.toArray(list.subList(1, 3))).isEqualTo(new byte[] {(byte) 1, (byte) 2});
    assertThat(Bytes.toArray(list.subList(2, 2))).isEqualTo(new byte[] {});
  }

  public void testAsListEmpty() {
    assertThat(Bytes.asList(EMPTY)).isSameInstanceAs(Collections.emptyList());
  }

    return entries;
  }

  private void expectFirstRemoved(Entry<K, V>[] entries) {
    resetMap(entries);

    List<Entry<K, V>> expectedWithDuplicateRemoved =
        Arrays.asList(entries).subList(1, getNumElements());
    expectContents(expectedWithDuplicateRemoved);
  }

  /**
   * Returns the {@link Method} instance for {@link #testCreateWithNullKeyUnsupported()} so that

            if (selected != null) {
                sorted.add(selected.getVersion());
            }
        }
        sorted.sort(vC);
        if (forcedVersion != null) {
            return sorted.subList(sorted.indexOf(forcedVersion), sorted.size());
        } else {
            return sorted;
        }
    }

    Set<ModuleResolveState> getParticipatingModules() {
        return participatingModules;
    }

        return Cast.uncheckedCast(references.isEmpty() ? null : references.get(0));
    }

    @Override
    public List<ModelReference<?>> getTailReferences() {
        return references.size() > 1 ? references.subList(1, references.size()) : Collections.<ModelReference<?>>emptyList();
    }

    @Override
    public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {

    }
    return sum;
  }

  private enum SubMultisetSpec {
    TAIL_CLOSED {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntry, List<Entry<E>> entries) {
        return entries.subList(targetEntry, entries.size());
      }

      @Override
      <E> SortedMultiset<E> subMultiset(
          SortedMultiset<E> multiset, List<Entry<E>> entries, int targetEntry) {

            } else if (state == DfsState.VISITING) {
                // we are already visiting this vertex, this mean we have a cycle
                int pos = cycle.lastIndexOf(v.label);
                List<String> ret = cycle.subList(pos, cycle.size());
                ret.add(v.label);
                return ret;
            }
        }
        return null;
    }

    static class Vertex {
        final String label;

                        }
                    });

            List<ModelView<?>> inputsWithBinary = new ArrayList<ModelView<?>>(inputs.size());
            inputsWithBinary.addAll(inputs.subList(1, inputs.size()));
            inputsWithBinary.add(InstanceModelView.of(getSubject().getPath(), getSubject().getType(), binary));

            invoke(invoker, inputsWithBinary, cast, binary, binary);
        }
    }

      byte oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override
    public List<Byte> subList(int fromIndex, int toIndex) {
      int size = size();
      checkPositionIndexes(fromIndex, toIndex, size);
      if (fromIndex == toIndex) {
        return Collections.emptyList();
      }

            }
            val endPos = content.subList(markerPos, content.size).indexOfFirst { it.contains(endDiagram) && !it.contains(startDiagram) }
            if (endPos < 0) {
                throw IllegalArgumentException("Could not locate the end of the generated diagram in $markdownFile")
            }
            content.subList(0, markerPos)
        } else {
            emptyList()
        }

      ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator);
      builder.add(BEFORE_FIRST);
      builder.add(elements);
      builder.add(AFTER_LAST);
      return builder.build().asList().subList(1, elements.length + 1);
    }
  }

  public static class ImmutableSortedSetSubsetAsListSubListGenerator
      extends TestStringListGenerator {
    @Override