"""
        ),
    ] = True,
) -> Any:
    """
    Declare a FastAPI Security dependency.

    The only difference with a regular dependency is that it can declare OAuth2
    scopes that will be integrated with OpenAPI and the automatic UI docs (by default
    at `/docs`).

    It takes a single "dependable" callable (like a function).

)
def test_allowed_schema_type(
    type_value: SchemaType | list[SchemaType] | None,
) -> None:
    """Test that Schema accepts SchemaType, List[SchemaType] and None for type field."""
    schema = Schema(type=type_value)
    assert schema.type == type_value


def test_invalid_type_value() -> None:
    """Test that Schema raises ValueError for invalid type values."""
    with pytest.raises(ValueError, match="2 validation errors for Schema"):

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been
 * on the queue the longest time. The tail of the queue is that element that has been on
 * the queue the shortest time. New elements are inserted at the tail of the queue, and the queue
 * retrieval operations obtain elements at the head of the queue.
 *

 * @author Charles Fry
 */
@NullUnmarked
public final class TestingWeighers {

  /** Returns a {@link Weigher} that returns the given {@code constant} for every request. */
  static Weigher<Object, Object> constantWeigher(int constant) {
    return new ConstantWeigher(constant);
  }

  /** Returns a {@link Weigher} that uses the integer key as the weight. */
  static Weigher<Integer, Object> intKeyWeigher() {
    return new IntKeyWeigher();

But remember that when you import `Query`, `Path`, `Cookie` and others from `fastapi`, those are actually functions that return special classes.

///

/// info

To declare cookies, you need to use `Cookie`, because otherwise the parameters would be interpreted as query parameters.

///

/// info

import com.google.common.annotations.GwtCompatible;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

/**
 * Annotates a "top-level" type-variable usage that takes its nullness from the type argument
 * supplied by the user of the class. For example, {@code Multiset.Entry.getElement()} returns
 * {@code @ParametricNullness E}, which means:
 *
 * <ul>

public abstract class ForwardingObject {

  /** Constructor for use by subclasses. */
  protected ForwardingObject() {}

  /**
   * Returns the backing delegate instance that methods are forwarded to. Abstract subclasses
   * generally override this method with an abstract method that has a more specific return type,
   * such as {@link ForwardingSet#delegate}. Concrete subclasses override this method to supply the
   * instance being decorated.
   */

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link ClosingFuture} that exercise {@link
 * ClosingFuture#finishToValueAndCloser(ValueAndCloserConsumer, Executor)}.
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible

  }

  // Queues

  /**
   * A custom queue for managing eviction order. Note that this is tightly integrated with {@code
   * ReferenceEntry}, upon which it relies to perform its linking.
   *
   * <p>Note that this entire implementation makes the assumption that all elements which are in the
   * map are also in this queue, and that all elements not in the queue are not in the map.
   *

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.misc;

/**
 * Represents a disposable resource.
 * <p>
 * If there are resources that must be disposed of when the S2 container shuts down,
 * create a class that implements this interface and register it with {@link DisposableUtil}.
 * </p>
 *
 * @author koichik
 */
public interface Disposable {

    /**