}
    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def 'projectsLoaded listeners are attributed to the correct registrant'() {
        given:
        def addGradleListeners = { String source ->
            """
                gradle.projectsLoaded({
                    println "gradle.projectsLoaded(Action) from $source"

    private static Closure addingPluginBuildOpQuery = { it.only(ApplyPluginBuildOperationType, { it.details.pluginClass == 'AddingPlugin' }) }

    def '#containerType container callbacks emit registrant when using #callbackName callback(before creation registered)'() {
        given:
        callbackScript(containerAccess, callbackName)
        buildFile << """

                continue
            }

            lock.writeLock().withLock {
                if (application.isRegistrarRegistered(registrar)) return@withLock
                registrar.register()
                application.serviceRegistered[registrar::class] = true
            }
        }
    }

    private fun <DATA> Application.isRegistrarRegistered(registrar: AnalysisApiServiceRegistrar<DATA>): Boolean =

import static java.util.Arrays.stream;
import static org.gradle.internal.execution.impl.FingerprinterRegistration.registration;

public class FileCollectionFingerprinterRegistrations {
    private final Set<FingerprinterRegistration> registrants;

    public FileCollectionFingerprinterRegistrations(
        StringInterner stringInterner,
        FileCollectionSnapshotter fileCollectionSnapshotter,

    private val providersBindingCache: Map<Class<out PsiElement>, List<KotlinPsiReferenceProvider>>

    init {
        val registrar = KotlinPsiReferenceRegistrar()
        KotlinReferenceProviderContributor.getInstance(project).registerReferenceProviders(registrar)
        originalProvidersBinding = registrar.providers

        providersBindingCache = ConcurrentFactoryMap.createMap<Class<out PsiElement>, List<KotlinPsiReferenceProvider>> { klass ->

        return new DefaultCapturingServicesRegistry(registrar);
    }

    private class DefaultCapturingServicesRegistry implements ServiceRegistry {
        private final ImplicitInputRecorder registrar;

        private DefaultCapturingServicesRegistry(ImplicitInputRecorder registrar) {
            this.registrar = registrar;
        }

        @Override

import org.jetbrains.kotlin.resolve.references.ReferenceAccess

internal class KotlinFirReferenceContributor : KotlinReferenceProviderContributor {
    override fun registerReferenceProviders(registrar: KotlinPsiReferenceRegistrar) {
        with(registrar) {
            registerProvider(factory = ::KaFirForLoopInReference)
            registerProvider(factory = ::KaFirInvokeFunctionReference)

 * the list of [serviceRegistrars][org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator.serviceRegistrars].
 *
 * See `StandaloneSessionServiceRegistrar` for the Standalone counterpart to this service registrar.
 */
object AnalysisApiIdeModeTestServiceRegistrar : AnalysisApiTestServiceRegistrar() {

    public RepositoryResourceAccessor withImplicitInputRecorder(final ImplicitInputRecorder registrar) {
        return (relativePath, action) -> {
            ExternalResourceName location = new ExternalResourceName(rootUri, relativePath);
            LocallyAvailableExternalResource resource = resourceResolver.resolveResource(location);
            registrar.register(SERVICE_TYPE, new ServiceCall(rootUriAsString + ";" + relativePath, hashFor(resource)));

Portanto, você pode continuar lançando o `HTTPException` do **FastAPI** normalmente no seu código.

Porém, quando você registrar um manipulador de exceção, você deve registrá-lo através do `HTTPException` do Starlette.