}
    }

    @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 =

    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 ->

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() {

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.

	// APIPA/"link-local" IP.
	//
	// It doesn't matter what this IP is, so long as it's not routable and doesn't collide with anything else.
	//
	// IPv6 link local ranges are designed to be collision-resistant by default, and so probably never need to be overridden
	DefaultHostProbeSNATIP   = "169.254.7.127"
	DefaultHostProbeSNATIPV6 = "fd16:9254:7127:1337:ffff:ffff:ffff:ffff"
)

type AmbientArgs struct {

                if(gradle.isRootBuild()) {
                    def listener = new BuildOperationNotificationsEvaluationListener()
                    def registrar = project.services.get($BuildOperationNotificationListenerRegistrar.name)
                    registrar.register(listener)
                }
            }

            $EVALUATION_LISTENER_SOURCE
        """
    }

import com.intellij.mock.MockApplication
import com.intellij.mock.MockProject
import com.intellij.openapi.Disposable

/**
 * @param DATA Additional information provided to the registrar by the setup process.
 */
interface AnalysisApiServiceRegistrar<in DATA> {
    fun registerApplicationServices(application: MockApplication, data: DATA)