# Dex Quickstart Guide [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)

    return someheader


def get_something_else(*, someheader: str = Depends(get_header)):
    return f"{someheader}123"


@app.get("/")
def get_deps(dep1: str = Depends(get_header), dep2: str = Depends(get_something_else)):
    return {"dep1": dep1, "dep2": dep2}


client = TestClient(app)

schema = {
    "components": {
        "schemas": {
            "HTTPValidationError": {

    return scopes.scopes


async def security2(scopes: SecurityScopes):
    return scopes.scopes


async def dep3(
    dep1: Annotated[list[str], Security(security1, scopes=["scope1"])],
    dep2: Annotated[list[str], Security(security2, scopes=["scope2"])],
):
    return {"dep1": dep1, "dep2": dep2}


app = FastAPI()


@app.get("/scopes")
def get_scopes(

     */
    private void checkUtSimpleArtifactDependencies(Dependency dep1, Dependency dep2) {
        assertEquals("compile", dep1.getScope());
        assertFalse(dep1.isOptional(), "Expected " + dep1 + ".isOptional() to return false");
        assertEquals(0, dep1.getExclusions().size());
        Artifact depArtifact = dep1.getArtifact();
        assertEquals("ut.simple", depArtifact.getGroupId());

          --health-retries 5
      openid:
        image: quay.io/minio/dex
        ports:
          - "5556:5556"
        env:
          DEX_LDAP_SERVER: "openldap:389"
      openid2:
        image: quay.io/minio/dex
        ports:
          - "5557:5557"
        env:
          DEX_LDAP_SERVER: "openldap:389"
          DEX_ISSUER: "http://127.0.0.1:5557/dex"
          DEX_WEB_HTTP: "0.0.0.0:5557"

    strategy:

    void testNullInputs() {
        assertDoesNotThrow(() -> {
            SpnegoException ex1 = new SpnegoException((String) null);
            assertNotNull(ex1);
            assertNull(ex1.getMessage());
            assertNull(ex1.getCause());
        });

        assertDoesNotThrow(() -> {
            SpnegoException ex2 = new SpnegoException("msg", null);

    void testDcerpcExceptionIntegration() {
        // Test that DcerpcException can be created and implements DcerpcError
        DcerpcException ex1 = new DcerpcException("Test error", null);
        assertTrue(ex1 instanceof DcerpcError, "DcerpcException should implement DcerpcError");

        // Test that DcerpcException can be created with string messages

        // single project build entry point
        ProjectBuildingException ex1 =
                assertThrows(ProjectBuildingException.class, () -> projectBuilder.build(pomFile, configuration));

        assertEquals(1, ex1.getResults().size());
        MavenProject project1 = ex1.getResults().get(0).getProject();
        assertNotNull(project1);

            scope = DependencyScope.forId(scopeId);
        }
        return scope == null || !scope.isTransitive();
    }

    private Dependency merge(Dependency dep1, Dependency dep2) {
        throw new IllegalArgumentException("Duplicate dependency: " + getDependencyKey(dep1));
    }

    private static String getDependencyKey(org.apache.maven.api.Dependency dependency) {

            }
        };

        SmbResourceLocatorImpl loc = new SmbResourceLocatorImpl(ctx, smbUrl("smb://server/share/"));
        SmbException ex1 = assertThrows(SmbException.class, () -> c.connectWrapException(loc));
        assertTrue(ex1.getMessage().contains("Failed to connect to server"));

        SmbTreeConnection c2 = new SmbTreeConnection(ctx) {
            @Override