* regression</a> of {@code y} as a function of {@code x}. The count must be greater than one, and
   * either the {@code x} or {@code y} data must have a non-zero population variance (i.e. {@code
   * xStats().populationVariance() > 0.0 || yStats().populationVariance() > 0.0}). The result is
   * guaranteed to be horizontal if there is variance in the {@code x} data but not the {@code y}

   *   <li>Code that chains multiple predicates together (especially negations) may be more readable
   *       using this method. For example, {@code not(in(target))} is generally more readable than
   *       {@code not(target::contains)}.
   *   <li>This method's name conflicts with Kotlin's {@code in} operator.
   * </ul>
   *
   * <p><b>Discouraged:</b> Prefer using either {@code target::contains} or {@code x ->

# Dependencies with yield { #dependencies-with-yield }

FastAPI supports dependencies that do some <abbr title='sometimes also called "exit code", "cleanup code", "teardown code", "closing code", "context manager exit code", etc.'>extra steps after finishing</abbr>.

To do this, use `yield` instead of `return`, and write the extra steps (code) after.

/// tip

Make sure to use `yield` one single time per dependency.

///

/// note | Technical Details

 *       {@code AsyncCallable}) to complete, without interrupting it (and without calling {@code
 *       cancel} on the {@code Future}). So beware: <i>Even if you cancel every preceding {@code
 *       Future} returned by this class, the next task may still have to wait.</i>.
 *   <li>Once an {@code AsyncCallable} returns a {@code Future}, this class considers that task to

public class ClIllegalArgumentException extends IllegalArgumentException {

    private static final long serialVersionUID = -3701473506893554853L;

    /** Name of the argument that is {@code null} */
    protected final String argName;

    /** Message code */
    protected final String messageCode;

    /** Arguments for the message */
    protected final Object[] args;

    /**
     * Creates a {@link ClIllegalArgumentException}.

 *
 * <p>As this interface extends {@code java.util.function.Predicate}, an instance of this type may
 * be used as a {@code Predicate} directly. To use a {@code java.util.function.Predicate} where a
 * {@code com.google.common.base.Predicate} is expected, use the method reference {@code
 * predicate::test}.
 *
 * <p>This interface is now a legacy type. Use {@code java.util.function.Predicate} (or the

    assertFailsWith<IllegalStateException> {
      newResponse(responseBody("set status code -1"), -1)
    }
  }

  @Test fun zeroStatusCodeIsValid() {
    val response = newResponse(responseBody("set status code 0"), 0)
    assertThat(response.code).isEqualTo(0)
  }

  @Test fun defaultResponseBodyIsEmpty() {
    val response =
      Response
        .Builder()

   * #previous()} can retrieve the preceding {@code position} elements.
   *
   * @throws IndexOutOfBoundsException if {@code position} is negative or is greater than {@code
   *     size}
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size, int position) {
    checkPositionIndex(position, size);
    this.size = size;

	DB.Model(&product).Select("Name", "Code", "Price").Updates(Product3{Name: "Product New4", Code: ""})
	if product.Name != "Product New4" || product.Price != 320 || product.Code != "" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	DB.Model(&product).UpdateColumns(Product3{Code: "L1215"})
	if product.Price != 320 || product.Code != "L1215" {
		t.Errorf("invalid data after update, got %+v", product)

   * @param value the value to be associated with the specified key
   * @return the value that was previously associated with the key, or {@code null} if there was no
   *     previous entry. (If the bimap contains null values, then {@code forcePut}, like {@code
   *     put}, returns {@code null} both if the key is absent and if it is present with a null
   *     value.)
   */
  @CanIgnoreReturnValue