Jendrik Johannes <******@****.***> 1607501645 +0100

```

### 3.2 Use OpenSSL to Generate a Certificate

Use one of the following methods to generate a certificate using `openssl`:

* 3.2.1 [Generate a private key with ECDSA](#generate-private-key-with-ecdsa)
* 3.2.2 [Generate a private key with RSA](#generate-private-key-with-rsa)
* 3.2.3 [Generate a self-signed certificate](#generate-a-self-signed-certificate)

#### 3.2.1 Generate a private key with ECDSA

    INITIALIZE("initialize"),
    GENERATE_SOURCES("generate-sources"),
    PROCESS_SOURCES("process-sources"),
    GENERATE_RESOURCES("generate-resources"),
    PROCESS_RESOURCES("process-resources"),
    COMPILE("compile"),
    PROCESS_CLASSES("process-classes"),
    GENERATE_TEST_SOURCES("generate-test-sources"),
    PROCESS_TEST_SOURCES("process-test-sources"),
    GENERATE_TEST_RESOURCES("generate-test-resources"),

 *
 * To force selection of our fallback strategies we load {@link AbstractFuture} (and all of {@code
 * com.google.common.util.concurrent}) in degenerate class loaders which make certain platform
 * classes unavailable. Then we construct a test suite so we can run the normal AbstractFutureTest
 * test methods in these degenerate classloaders.
 */

public class AbstractFutureFallbackAtomicHelperTest extends TestCase {

 * To force selection of our fallback strategies we load {@link AggregateFutureState} (and all of
 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain
 * platform classes unavailable. Then we construct a test suite so we can run the normal FuturesTest
 * test methods in these degenerate classloaders.
 */

public class AggregateFutureStateFallbackAtomicHelperTest extends TestCase {

  /**

from fastapi import Depends
from typing_extensions import Annotated


async def dependency_a():
    dep_a = generate_dep_a()
    try:
        yield dep_a
    finally:
        dep_a.close()


async def dependency_b(dep_a: Annotated[DepA, Depends(dependency_a)]):
    dep_b = generate_dep_b()
    try:
        yield dep_b
    finally:
        dep_b.close(dep_a)

 *
 * To force selection of our fallback strategies we load {@link AbstractFuture} (and all of {@code
 * com.google.common.util.concurrent}) in degenerate class loaders which make certain platform
 * classes unavailable. Then we construct a test suite so we can run the normal AbstractFutureTest
 * test methods in these degenerate classloaders.
 */

public class AbstractFutureFallbackAtomicHelperTest extends TestCase {

async def dependency_a():
    dep_a = generate_dep_a()
    try:
        yield dep_a
    finally:
        dep_a.close()


async def dependency_b(dep_a=Depends(dependency_a)):
    dep_b = generate_dep_b()
    try:
        yield dep_b
    finally:
        dep_b.close(dep_a)


async def dependency_c(dep_b=Depends(dependency_b)):
    dep_c = generate_dep_c()
    try:
        yield dep_c
    finally:

    private static final String[] PHASES = {
        "validate",
        "initialize",
        "generate-sources",
        "process-sources",
        "generate-resources",
        "process-resources",
        "compile",
        "process-classes",
        "generate-test-sources",
        "process-test-sources",
        "generate-test-resources",
        "process-test-resources",
        "test-compile",

from fastapi import FastAPI
from fastapi.routing import APIRoute
from pydantic import BaseModel


def custom_generate_unique_id(route: APIRoute):
    return f"{route.tags[0]}-{route.name}"


app = FastAPI(generate_unique_id_function=custom_generate_unique_id)


class Item(BaseModel):
    name: str
    price: float


class ResponseMessage(BaseModel):
    message: str


class User(BaseModel):
    username: str