}

      @Override
      @SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
      public <T extends @Nullable Object> T[] toArray(T[] array) {
        return standardToArray(array);
      }
    };
  }

  @Override
  @CanIgnoreReturnValue
  public @Nullable B put(Class<? extends @NonNull B> key, @ParametricNullness B value) {
    cast(key, value);

 * limitations under the License.
 */
package okhttp3.curl

import com.github.ajalt.clikt.core.main
import kotlin.system.exitProcess

fun main(args: Array<String>) {
  Main().main(args)
  exitProcess(0)

   *
   * <p>The {@code @Nullable} annotations on the {@code equalityGroup} parameter imply that the
   * objects, and the array itself, can be null. That is for programmer convenience, when the
   * objects come from factory methods that are themselves {@code @Nullable}. In reality neither the
   * array nor its contents can be null, but it is not useful to force the use of {@code
   * requireNonNull} or the like just to assert that.
   *

    /**
     * The number of search results to return per page.
     */
    @ValidateTypeFailure
    public Integer num;

    /**
     * Array of language codes to filter search results.
     */
    public String[] lang;

    /**
     * Array of additional query strings to exclude from search.
     */
    public String[] ex_q;

    /**
     * The starting position for search results pagination.
     */

      chars.add(randomAlpha());
    }
    for (int i = 0; i < nonAlpha; i++) {
      chars.add(randomNonAlpha());
    }
    Collections.shuffle(chars, random);
    char[] array = Chars.toArray(chars);
    this.testString = new String(array);
  }

  private char randomAlpha() {
    return ALPHA.charAt(random.nextInt(ALPHA.length()));
  }

  private char randomNonAlpha() {

# https://github.com/apache/lucene-solr/blob/master/lucene/analysis/common/src/resources/org/apache/lucene/analysis/ga/stopwords.txt
a
ach
ag
agus
an
aon
ar
arna
as
b'
ba
beirt
bhúr
caoga
ceathair
ceathrar
chomh
chtó
chuig
chun
cois
céad
cúig
cúigear
d'
daichead
dar
de
deich
deichniúr
den
dhá
do
don
dtí
dá
dár
dó
faoi
faoin
faoina

    // TODO(user): This is not the most efficient way to handle generic
    // arrays, but is there another way to extract the array class in a
    // non-hacky way (i.e. using String value class names- "[L...")?
    return Array.newInstance(componentType, 0).getClass();
  }

  /*
   * TODO(benyu): Once behavior is the same for all Java (and Android) versions we support, delete

        }

        /**
         * Sets the user's group memberships.
         * @param groups Array of group names.
         */
        public void setGroups(final String[] groups) {
            this.groups = groups;
        }

        /**
         * Sets the user's role assignments.
         * @param roles Array of role names.
         */
        public void setRoles(final String[] roles) {

   */
  public static CharSource asCharSource(URL url, Charset charset) {
    return asByteSource(url).asCharSource(charset);
  }

  /**
   * Reads all bytes from a URL into a byte array.
   *
   * @param url the URL to read from
   * @return a byte array containing all the bytes from the URL
   * @throws IOException if an I/O error occurs
   */
  public static byte[] toByteArray(URL url) throws IOException {

   * need to be escaped. If an empty array is returned, this effectively strips the input character
   * from the resulting text.
   *
   * <p>If the character does not need to be escaped, this method should return {@code null}, rather
   * than a one-character array containing the character itself. This enables the escaping algorithm
   * to perform more efficiently.
   *