assertTrue(SortedIterables.hasSameComparator(Ordering.natural(), Maps.newTreeMap().keySet()));
    assertTrue(
        SortedIterables.hasSameComparator(
            Ordering.natural().reverse(), Sets.newTreeSet(Ordering.natural().reverse())));
  }

  public void testComparator() {
    assertEquals(Ordering.natural(), SortedIterables.comparator(Sets.newTreeSet()));
  }

    }

    /** Sorts the elements in reverse natural order. */
    @SuppressWarnings("CanIgnoreReturnValueSuggester") // see ImmutableSortedSetExplicitComparator
    @Override
    public List<Integer> order(List<Integer> insertionOrder) {
      sort(insertionOrder, Ordering.<Integer>natural().reverse());
      return insertionOrder;
    }
  }

      assertEquals(expectedSpan, span);
    } catch (NoSuchElementException e) {
      assertNull(expectedSpan);
    }

    // test that asDescendingSetOfRanges is the reverse of asRanges
    assertEquals(Lists.reverse(asRanges), ImmutableList.copyOf(rangeSet.asDescendingSetOfRanges()));
  }

The modules under this directory will be released exactly once each. Once that

    assertThat(Longs.stringConverter().reverse().convert(null)).isNull();
  }

  public void testStringConverter_reverse() {
    Converter<String, Long> converter = Longs.stringConverter();
    assertThat(converter.reverse().convert(1L)).isEqualTo("1");
    assertThat(converter.reverse().convert(0L)).isEqualTo("0");
    assertThat(converter.reverse().convert(-1L)).isEqualTo("-1");

    assertThat(Shorts.stringConverter().reverse().convert(null)).isNull();
  }

  public void testStringConverter_reverse() {
    Converter<String, Short> converter = Shorts.stringConverter();
    assertThat(converter.reverse().convert((short) 1)).isEqualTo("1");
    assertThat(converter.reverse().convert((short) 0)).isEqualTo("0");
    assertThat(converter.reverse().convert((short) -1)).isEqualTo("-1");

    assertThat(Ints.stringConverter().reverse().convert(null)).isNull();
  }

  public void testStringConverter_reverse() {
    Converter<String, Integer> converter = Ints.stringConverter();
    assertThat(converter.reverse().convert(1)).isEqualTo("1");
    assertThat(converter.reverse().convert(0)).isEqualTo("0");
    assertThat(converter.reverse().convert(-1)).isEqualTo("-1");

                    for (int i = elements.length - 1; i >= 0; i--) {
                      list.add(elements[i]);
                    }
                    return Lists.reverse(list);
                  }
                })
            .named("Lists.reverse[ArrayList]")
            .withFeatures(
                CollectionSize.ANY,
                CollectionFeature.ALLOWS_NULL_VALUES,
                ListFeature.GENERAL_PURPOSE)

    @Override
    protected List<String> create(String[] elements) {
      List<String> list = asList(elements);
      Collections.reverse(list);
      return ImmutableList.copyOf(list).reverse();
    }
  }

  public static class ImmutableListHeadSubListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {

    return offset + size;
  }

  /**
   * Returns a view of this immutable list in reverse order. For example, {@code ImmutableList.of(1,
   * 2, 3).reverse()} is equivalent to {@code ImmutableList.of(3, 2, 1)}.
   *
   * @return a view of this immutable list in reverse order
   * @since 7.0
   */
  public ImmutableList<E> reverse() {
    return (size() <= 1) ? this : new ReverseImmutableList<E>(this);
  }