assertEquals(0, multiset.toArray().length);
    assertTrue(multiset.entrySet().isEmpty());
    assertFalse(multiset.iterator().hasNext());
    assertEquals(0, multiset.entrySet().size());
    assertEquals(0, multiset.entrySet().toArray().length);
    assertFalse(multiset.entrySet().iterator().hasNext());
  }

  public void testEmptyRangeSubMultisetSupportingAdd(SortedMultiset<E> multiset) {

                        ResolutionNode resolved = null;
                        for (Iterator<ConflictResolver> j = conflictResolvers.iterator();
                                resolved == null && j.hasNext(); ) {
                            ConflictResolver conflictResolver = j.next();

                            resolved = conflictResolver.resolveConflict(previous, node);
                        }

          if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
          }
        }

        @Override
        public boolean hasNext() {
          checkForComodification();
          return nextEntry != null;
        }

        @Override
        @ParametricNullness
        public V next() {
          checkForComodification();

  public void testGet_collections() {
    assertEquals(ImmutableSet.of().iterator(), ArbitraryInstances.get(Iterator.class));
    assertFalse(ArbitraryInstances.get(PeekingIterator.class).hasNext());
    assertFalse(ArbitraryInstances.get(ListIterator.class).hasNext());
    assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Iterable.class));
    assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Set.class));

    return new UnmodifiableIterator<E>() {
      int remaining;
      @Nullable E element;

      @Override
      public boolean hasNext() {
        return (remaining > 0) || entryIterator.hasNext();
      }

      @Override
      public E next() {
        if (remaining <= 0) {
          Entry<E> entry = entryIterator.next();
          element = entry.getElement();

        }

        @Override
        public boolean hasNext() {
          return forwardIterator.hasPrevious();
        }

        @Override
        public boolean hasPrevious() {
          return forwardIterator.hasNext();
        }

        @Override
        @ParametricNullness
        public T next() {
          if (!hasNext()) {
            throw new NoSuchElementException();
          }

    Entry<String, Integer> entry = inverseEntryItr.next();
    entry.setValue(3);
    assertEquals(immutableEntry("b", 2), inverseEntryItr.next());
    assertFalse(inverseEntryItr.hasNext());
    assertThat(map.entrySet())
        .containsExactly(immutableEntry(2, "b"), immutableEntry(3, "a"))
        .inOrder();
  }

  }

  @CollectionSize.Require(SEVERAL)
  public void testDescendingNavigation() {
    List<E> descending = new ArrayList<>();
    for (Iterator<E> i = navigableSet.descendingIterator(); i.hasNext(); ) {
      descending.add(i.next());
    }
    Collections.reverse(descending);
    assertEquals(values, descending);
  }

  public void testEmptySubSet() {

  private void writeLines(Iterator<? extends CharSequence> lines, String lineSeparator)
      throws IOException {
    checkNotNull(lineSeparator);

    try (Writer out = openBufferedStream()) {
      while (lines.hasNext()) {
        out.append(lines.next()).append(lineSeparator);
      }
    }
  }

  /**
   * Writes all the text from the given {@link Readable} (such as a {@link Reader}) to this sink.

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
        if (readers.hasNext()) {
            final ImageReader reader = readers.next();
            try {
                reader.setInput(input);
                final ImageReadParam param = reader.getDefaultReadParam();