"toArray(sameSizeE[]) should return the given array", array, collection.toArray(array));
    expectArrayContentsAnyOrder(createSamplesArray(), array);
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testToArray_rightSizedArray_ordered() {
    E[] array = getSubjectGenerator().createArray(getNumElements());
    assertSame(
        "toArray(sameSizeE[]) should return the given array", array, collection.toArray(array));

     *
     * @return whether the server has signing enabled
     */
    boolean isSigningEnabled();

    /**
     * Checks whether the server requires SMB message signing.
     *
     * @return whether the server requires signing
     */
    boolean isSigningRequired();

    /**
     * Checks whether the server supports Distributed File System (DFS).
     *
     * @return whether the server supports DFS

        return fessConfig.isMailSendMock() ? personnel.asTraining() : personnel;
    }

    protected SMailDogmaticPostalPersonnel createDogmaticPostalPersonnel() { // #ext_point e.g. locale, database
        final AsyncManager asyncManager = getAsyncManager();
        final MessageManager messageManager = getMessageManager();
        return new SMailDogmaticPostalPersonnel() {

            if (o.posInc != 0) {
                return false;
            }
            if (!word.equals(o.word)) {
                return false;
            }
            if (startOffset != o.startOffset) {
                return false;
            }
            if (endOffset != o.endOffset) {
                return false;
            }
            return true;
        }

        @Override

    if (type instanceof TypeVariable) {
      return typeTable.resolve((TypeVariable<?>) type);
    } else if (type instanceof ParameterizedType) {
      return resolveParameterizedType((ParameterizedType) type);
    } else if (type instanceof GenericArrayType) {
      return resolveGenericArrayType((GenericArrayType) type);
    } else if (type instanceof WildcardType) {
      return resolveWildcardType((WildcardType) type);
    } else {

     */
    default List<String> includes() {
        return List.of();
    }

    /**
     * {@return the list of patterns for the files to exclude}
     * The exclusions are applied after the inclusions.
     * The default implementation returns an empty list.
     */
    default List<String> excludes() {
        return List.of();
    }

    /**
     * {@return a matcher combining the include and exclude patterns}

     * @param item The suggest item to index.
     * @return The SuggestIndexResponse.
     */
    public SuggestIndexResponse index(final SuggestItem item) {
        return index(new SuggestItem[] { item });
    }

    /**
     * Indexes multiple suggest items.
     * @param items The suggest items to index.
     * @return The SuggestIndexResponse.
     */

   *
   * @param value a primitive {@code int} value
   * @return a hash code for the value
   */
  @InlineMe(replacement = "Integer.hashCode(value)")
  @InlineMeValidationDisabled(
      "The hash code of a int is the int itself, so it's simplest to return that.")
  public static int hashCode(int value) {
    return value;
  }

  /**

@app.post("/users/", response_model=UserBase)
async def create_user(user: UserCreate):
    return user


@app.get("/pets/{pet_id}", response_model=PetOut)
async def read_pet(pet_id: int):
    user = UserDB(
        email="******@****.***",
        hashed_password="secrethashed",
    )
    pet = PetDB(name="Nibbler", owner=user)
    return pet


@app.get("/pets/", response_model=list[PetOut])
async def read_pets():

     * @return A {@link ParameterizedClassDesc} that represents the return type of the method.
     */
    public static ParameterizedClassDesc createParameterizedClassDesc(final Method method, final Map<TypeVariable<?>, Type> map) {
        assertArgumentNotNull("method", method);
        assertArgumentNotNull("map", map);

        return createParameterizedClassDesc(method.getGenericReturnType(), map);