assertThat(loadCount.get()).isEqualTo(2);
    assertThat(reloadCount.get()).isEqualTo(1);
    assertThat(loadAllCount.get()).isEqualTo(2);

    executor.runNext();
    assertThat(loadCount.get()).isEqualTo(2);
    assertThat(reloadCount.get()).isEqualTo(2);
    assertThat(loadAllCount.get()).isEqualTo(2);
  }

        final List<MavenProject> sortedProjects = graph.getSortedProjects();
        assertEquals(aProject, sortedProjects.get(0));
        assertEquals(depender1, sortedProjects.get(1));
        assertEquals(depender2, sortedProjects.get(2));
        assertEquals(depender3, sortedProjects.get(3));
    }

    @Test

# =====================================================================================
# Without aliases


@app.get("/optional-str")
async def read_optional_str(p: Optional[str] = None):
    return {"p": p}


class QueryModelOptionalStr(BaseModel):
    p: Optional[str] = None


@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[QueryModelOptionalStr, Query()]):
    return {"p": p.p}

    // next map.get()
    when(backingMap.get(KEY)).thenReturn(existingZero);
    // since get returned zero, try a replace; that fails due to a simulated race
    when(backingMap.replace(eq(KEY), eq(existingZero), isA(AtomicInteger.class))).thenReturn(false);
    when(backingMap.putIfAbsent(eq(KEY), isA(AtomicInteger.class))).thenReturn(existing);

    // another map.get()

    is ValidatePlugins -> listOf(outputFile.get().asFile)
    is FindBrokenInternalLinks -> listOf(reportFile.get().asFile)
    is DistributionTest -> listOf(
        gradleInstallationForTest.gradleUserHomeDir.dir("test-kit-daemon").get().asFile,
        gradleInstallationForTest.gradleUserHomeDir.dir("kotlin-compiler-daemon").get().asFile,
        gradleInstallationForTest.daemonRegistry.get().asFile
    )
    else -> emptyList()
}

# =====================================================================================
# Without aliases


@app.get("/required-str")
async def read_required_str(p: Annotated[str, Cookie()]):
    return {"p": p}


class CookieModelRequiredStr(BaseModel):
    p: str


@app.get("/model-required-str")
async def read_model_required_str(p: Annotated[CookieModelRequiredStr, Cookie()]):
    return {"p": p.p}

async_callable_gen_dependency = AsyncCallableGenDependency()
methods_dependency = MethodsDependency()


@app.get("/partial-function-dependency")
async def get_partial_function_dependency(
    value: Annotated[
        str, Depends(partial(function_dependency, "partial-function-dependency"))
    ],
) -> str:
    return value


@app.get("/partial-async-function-dependency")
async def get_partial_async_function_dependency(
    value: Annotated[

    override val version: JvmVersion
        get() = JvmVersion.JAVA_17
    override val vendor: JvmVendor
        get() = JvmVendor.OPENJDK
}

object OpenJdk8 : Jvm {
    override val version: JvmVersion
        get() = JvmVersion.JAVA_8
    override val vendor: JvmVendor
        get() = JvmVendor.OPENJDK
}

object OpenJdk11 : Jvm {
    override val version: JvmVersion
        get() = JvmVersion.JAVA_11

app = FastAPI()


@app.get("/int/{param:int}")
def int_convertor(param: int = Path()):
    return {"int": param}


@app.get("/float/{param:float}")
def float_convertor(param: float = Path()):
    return {"float": param}


@app.get("/path/{param:path}")
def path_convertor(param: str = Path()):
    return {"path": param}


@app.get("/query/")
def query_convertor(param: str = Query()):

    response.body.close()
    applicationLogs
      .assertLogEqual("--> GET $url")
      .assertLogEqual("--> END GET")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms\)"""))
      .assertLogEqual("Content-Length: 0")
      .assertLogEqual("<-- END HTTP")
      .assertNoMoreLogs()
    networkLogs
      .assertLogEqual("--> GET $url http/1.1")
      .assertLogEqual("Host: $host")