Resources.copy(resource, out);
    assertEquals(I18N, out.toString("UTF-8"));
  }

  public void testGetResource_notFound() {
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class, () -> Resources.getResource("no such resource"));
    assertThat(e).hasMessageThat().isEqualTo("resource no such resource not found.");
  }

                throw new IllegalArgumentException(formatter.toString());
            } else {
                TreeFormatter formatter = new TreeFormatter();
                formatter.node("The constructor for type ");
                formatter.appendType(reportAs);
                formatter.append(" should be annotated with @Inject.");
                throw new IllegalArgumentException(formatter.toString());
            }
        }

        int i;
        int len;
        if ( buf.length < TOK_ID_SIZE + MECH_OID_LEN_SIZE ) {
            throw new IllegalArgumentException();
        }
        // TOK_ID
        for ( i = 0; i < TOK_ID.length; i++ ) {
            if ( TOK_ID[ i ] != buf[ i ] ) {
                throw new IllegalArgumentException();
            }
        }
        // MECH_OID_LEN
        len = 0xff00 & ( buf[ i++ ] << 8 );

  public <T> void testWhere_incompatibleGenericArrayMapping() {
    assertThrows(
        IllegalArgumentException.class,
        () -> new TypeResolver().where(new TypeCapture<T[]>() {}.capture(), String.class));
  }

  public <T> void testWhere_incompatibleParameterizedTypeMapping() {
    assertThrows(
        IllegalArgumentException.class,
        () -> new TypeResolver().where(new TypeCapture<Iterable<T>>() {}.capture(), List.class));

    filtered.put("a", 1);
    filtered.put("b", 2);
    assertEquals(ImmutableMap.of("a", 1, "b", 2), filtered);

    try {
      filtered.put("yyy", 3);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testFilteredKeysIllegalPutAll() {
    Map<String, Integer> unfiltered = createUnfiltered();
    Map<String, Integer> filtered = Maps.filterKeys(unfiltered, NOT_LENGTH_3);

                return minioClient.getObject(args);
            } catch (InvalidKeyException | ErrorResponseException | IllegalArgumentException | InsufficientDataException | InternalException
                    | InvalidResponseException | NoSuchAlgorithmException | XmlParserException | IOException | ServerException e) {

     * @param root the Maven Dependency, must not be {@code null}
     * @return the collection result, never {@code null}
     * @throws DependencyResolverException if the dependency tree could not be built
     * @throws IllegalArgumentException if an argument is null or invalid
     * @see #collect(DependencyResolverRequest)
     */
    @Nonnull
    default DependencyResolverResult collect(@Nonnull Session session, @Nonnull DependencyCoordinate root) {

   *
   * @param expression a boolean expression
   * @throws IllegalArgumentException if {@code expression} is false
   */
  public static void checkArgument(boolean expression) {
    if (!expression) {
      throw new IllegalArgumentException();
    }
  }

  /**
   * Ensures the truth of an expression involving one or more parameters to the calling method.

    try {
      TopKSelector.<String>least(-1);
      fail();
    } catch (IllegalArgumentException expected) {
    }
    try {
      TopKSelector.<String>greatest(-1);
      fail();
    } catch (IllegalArgumentException expected) {
    }
    try {
      TopKSelector.least(-1, Ordering.natural());
      fail();
    } catch (IllegalArgumentException expected) {
    }
    try {

  boolean isDirected();

  /**
   * Returns true if this graph allows self-loops (edges that connect a node to itself). Attempting
   * to add a self-loop to a graph that does not allow them will throw an {@link
   * IllegalArgumentException}.
   */
  boolean allowsSelfLoops();

  /** Returns the order of iteration for the elements of {@link #nodes()}. */
  ElementOrder<N> nodeOrder();

  /**