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

  @J2ktIncompatible
  @GwtIncompatible // Float.toString returns different value in GWT.
  public void testStringConverter_reverse() {
    Converter<String, Float> converter = Floats.stringConverter();
    assertThat(converter.reverse().convert(1.0f)).isEqualTo("1.0");
    assertThat(converter.reverse().convert(0.0f)).isEqualTo("0.0");

     */
    @Nonnull
    Optional<Boolean> offline();

    /**
     * Indicates whether Maven should operate in non-recursive mode (i.e., not build child modules).
     *
     * @return an {@link Optional} containing true if non-recursive mode is enabled, false if disabled, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> nonRecursive();

    /**

    protected int preloadSize = 512;

    public boolean isValid(final InputStream in) {
        return isValid(in, true);
    }

    protected boolean isValid(final InputStream in, final boolean recursive) {
        final BufferedInputStream bis = new BufferedInputStream(in);
        bis.mark(preloadSize);

        final byte[] bytes = new byte[preloadSize];
        try {
            if (bis.read(bytes) == -1) {

# Sobre as versões do FastAPI

**FastAPI** já está sendo usado em produção em diversas aplicações e sistemas, a cobertura de testes é mantida em 100%, mas seu desenvolvimento está avançando rapidamente.

Novos recursos são adicionados com frequência, bugs são corrigidos regularmente e o código está sempre melhorando.

    Arrays.sort(array, fromIndex, toIndex);
    reverse(array, fromIndex, toIndex);
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code
   * Collections.reverse(Longs.asList(array))}, but is likely to be more efficient.
   *
   * @since 23.1
   */
  public static void reverse(long[] array) {
    checkNotNull(array);
    reverse(array, 0, array.length);
  }

  /**

    Arrays.sort(array, fromIndex, toIndex);
    reverse(array, fromIndex, toIndex);
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code
   * Collections.reverse(Longs.asList(array))}, but is likely to be more efficient.
   *
   * @since 23.1
   */
  public static void reverse(long[] array) {
    checkNotNull(array);
    reverse(array, 0, array.length);
  }

  /**

    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);
  }

    Arrays.sort(array, fromIndex, toIndex);
    reverse(array, fromIndex, toIndex);
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code
   * Collections.reverse(Chars.asList(array))}, but is likely to be more efficient.
   *
   * @since 23.1
   */
  public static void reverse(char[] array) {
    checkNotNull(array);
    reverse(array, 0, array.length);
  }

  /**

    /* UnsupportedOperationException on indirect modifications. */
    NavigableSet<Integer> reverse = unmod.descendingSet();
    assertThrows(UnsupportedOperationException.class, () -> reverse.add(4));
    assertThrows(UnsupportedOperationException.class, () -> reverse.addAll(singleton(4)));
    assertThrows(UnsupportedOperationException.class, () -> reverse.remove(4));
  }

  void ensureNotDirectlyModifiable(SortedSet<Integer> unmod) {

# See the OWNERS docs at https://go.k8s.io/owners

options:
  # make root approval non-recursive
  no_parent_owners: true
approvers: