@DisplayName("getUserDomain: explicit realm overrides")
        void getUserDomain_fromExplicitRealm() {
            Kerb5Authenticator auth = new Kerb5Authenticator(new Subject());
            auth.setRealm("REALM.TEST");
            assertEquals("REALM.TEST", auth.getUserDomain());
        }

        @Test
        @DisplayName("getUserDomain: falls back to super domain when no realm/subject")

) {
  /**
   * Returns the auth params, including [realm] and [charset] if present, but as
   * strings. The map's keys are lowercase and should be treated case-insensitively.
   */
  @get:JvmName("authParams")
  val authParams: Map<String?, String>

  /** Returns the protection space. */
  @get:JvmName("realm")
  val realm: String?
    get() = authParams["realm"]

  "http://localhost:8080/auth/realms/{realm}/protocol/openid-connect/token"
```

The result will be a JSON document. To invoke the API you need to extract the value of the access_token property. You can then invoke the API by including the value in the Authorization header of requests to the API.

The following example shows how to get the details of the user with `{userid}` from `{realm}` realm:

```
curl \

                ClassRealm realm = entry.getClassRealm();
                for (String exportedPackage : exportedPackages) {
                    extRealm.importFrom(realm, exportedPackage);
                }
                if (exportedPackages.isEmpty()) {
                    // sisu uses realm imports to establish component visibility
                    extRealm.importFrom(realm, realm.getId());
                }
            }

    }

    public CoreExports(ClassRealm realm, Set<String> exportedArtifacts, Set<String> exportedPackages) {
        this.artifacts = Collections.unmodifiableSet(new HashSet<>(exportedArtifacts));
        this.packages = exportedPackages.stream()
                .collect(collectingAndThen(toMap(identity(), v -> realm), Collections::unmodifiableMap));
    }

    /**

                + extension.getVersion();
        final ClassRealm realm = classWorld.newRealm(realmId, null);
        Set<String> providedArtifacts = Collections.emptySet();
        String classLoadingStrategy = extension.getClassLoadingStrategy();
        if (STRATEGY_PARENT_FIRST.equals(classLoadingStrategy)) {
            realm.importFrom(parentRealm, "");
        } else if (STRATEGY_PLUGIN.equals(classLoadingStrategy)) {

                + extension.getVersion();
        final ClassRealm realm = classWorld.newRealm(realmId, null);
        Set<String> providedArtifacts = Collections.emptySet();
        String classLoadingStrategy = extension.getClassLoadingStrategy();
        if (STRATEGY_PARENT_FIRST.equals(classLoadingStrategy)) {
            realm.importFrom(parentRealm, "");
        } else if (STRATEGY_PLUGIN.equals(classLoadingStrategy)) {

    assert response.headers["WWW-Authenticate"] == 'Basic realm="simple"'


def test_security_http_basic_invalid_credentials():
    response = client.get(
        "/users/me", headers={"Authorization": "Basic notabase64token"}
    )
    assert response.status_code == 401, response.text
    assert response.headers["WWW-Authenticate"] == 'Basic realm="simple"'
    assert response.json() == {"detail": "Not authenticated"}

                logger.warn("Failed to parse port: {}", port, e);
            }
        }

        final String realm = paramMap.get(prefix + "realm");
        if (StringUtil.isNotBlank(realm)) {
            config.setRealm(realm);
        }

        // AuthSchemeType
        if (Constants.BASIC.equals(scheme)) {
            config.setAuthSchemeType(AuthSchemeType.BASIC);

        self.scheme_name = scheme_name or self.__class__.__name__
        self.realm = realm
        self.auto_error = auto_error

    def make_authenticate_headers(self) -> dict[str, str]:
        if self.realm:
            return {"WWW-Authenticate": f'Basic realm="{self.realm}"'}
        return {"WWW-Authenticate": "Basic"}

    async def __call__(  # type: ignore