LCOV - code coverage report
Current view: top level - src/composables - useFeatureFlags.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 54.2 % 72 39
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { GetFeaturesResponse } from '@comfyorg/ingest-types'
       2              : import { computed, reactive, readonly, watchEffect } from 'vue'
       3              : import type { Ref } from 'vue'
       4              : 
       5              : import { normalizeHostedBillingDestination } from '@/platform/billing/billingWeb'
       6              : import {
       7              :   opensLocalBillingHandoff,
       8              :   showsCloudBillingNewUxOnLocal
       9              : } from '@/platform/billing/localBillingWebEnabled'
      10              : import { isCloud, isNightly } from '@/platform/distribution/types'
      11              : import {
      12              :   isAuthenticatedConfigLoaded,
      13              :   remoteConfig,
      14              :   sessionAgentGrant,
      15              :   sessionAgentGrantValidUntil,
      16              :   useRemoteConfigCache
      17              : } from '@/platform/remoteConfig/remoteConfig'
      18              : import { ServerFeatureFlag } from '@/platform/remoteConfig/serverFeatureFlag'
      19              : import { useTelemetry } from '@comfyorg/telemetry'
      20              : import { api } from '@/scripts/api'
      21              : import { getDevOverride } from '@/utils/devFeatureFlagOverride'
      22              : import { getSessionOverride } from '@/utils/sessionFeatureFlagOverride'
      23              : 
      24              : function reportFeatureFlagEvaluation<T>(flagKey: string, value: T): T {
      25              :   useTelemetry()?.trackFeatureFlagEvaluation(flagKey, value)
      26              :   return value
      27              : }
      28              : 
      29              : /**
      30              :  * Resolves a feature flag value with session override > dev override >
      31              :  * remoteConfig > serverFeature priority.
      32              :  */
      33      3528804 : function resolveFlag<T>(
      34              :   flagKey: string,
      35              :   remoteConfigValue: T | undefined,
      36              :   defaultValue: T
      37              : ): T {
      38      3528804 :   const sessionOverride = getSessionOverride<T>(flagKey)
      39      3528804 :   if (sessionOverride !== undefined) return sessionOverride
      40              : 
      41      3528804 :   const override = getDevOverride<T>(flagKey)
      42      3528804 :   if (override !== undefined) return override
      43      3528804 :   return remoteConfigValue ?? api.getServerFeature(flagKey, defaultValue)
      44              : }
      45              : 
      46              : /**
      47              :  * A flag that enables a payment flow: same channels as `resolveFlag`, but only
      48              :  * a literal `true` counts. A malformed wire value (`'true'`, `1`) or a failed
      49              :  * lookup resolves to false rather than switching a charge onto a new transport.
      50              :  *
      51              :  * Needs no auth gate: the server returns a concrete `false` for these keys to
      52              :  * an unauthenticated caller, so the anonymous window resolves to the legacy
      53              :  * rail and cannot enable a flow before authenticated config confirms it.
      54              :  */
      55        10506 : function resolveStrictBooleanFlag(
      56              :   flagKey: string,
      57              :   remoteConfigValue: boolean | undefined
      58              : ): boolean {
      59        10506 :   try {
      60        10506 :     return resolveFlag<unknown>(flagKey, remoteConfigValue, false) === true
      61              :   } catch {
      62            0 :     return false
      63              :   }
      64              : }
      65              : 
      66              : /**
      67              :  * Resolves a per-user, Cloud-only flag that selects backend behavior. Off the
      68              :  * Cloud build it is always false; during the auth window it falls back to the
      69              :  * cached session value so anonymous bootstrap config cannot route the user to
      70              :  * the wrong backend before authenticated config confirms the flag.
      71              :  */
      72            0 : function resolveAuthGatedFlag(
      73              :   flagKey: string,
      74              :   remoteConfigValue: boolean | undefined,
      75              :   cachedValue: Ref<boolean | undefined>
      76              : ): boolean {
      77            0 :   const sessionOverride = getSessionOverride<boolean>(flagKey)
      78            0 :   if (sessionOverride !== undefined) return sessionOverride
      79              : 
      80            0 :   const override = getDevOverride<boolean>(flagKey)
      81            0 :   if (override !== undefined) return override
      82              : 
      83            0 :   if (!isCloud) return false
      84              :   if (!isAuthenticatedConfigLoaded.value) return cachedValue.value ?? false
      85              : 
      86              :   return remoteConfigValue ?? api.getServerFeature(flagKey, false)
      87              : }
      88              : 
      89              : /**
      90              :  * Resolves a per-user allowlist flag. Before the first authenticated answer it
      91              :  * is off; after one, a failed refresh falls back to that answer so a blip
      92              :  * cannot pull a granted surface out from under the user mid-session. Unlike
      93              :  * `resolveAuthGatedFlag` the fallback is never read from storage — a persisted
      94              :  * grant is what let one browser show the surface while another hid it for the
      95              :  * same account (PM-1707).
      96              :  */
      97            0 : function resolveWhitelistFlag(
      98              :   flagKey: string,
      99              :   remoteConfigValue: boolean | undefined,
     100              :   grantedThisSession: Ref<boolean | undefined>,
     101              :   grantValidUntil: Ref<number | undefined>
     102              : ): boolean {
     103            0 :   const sessionOverride = getSessionOverride<boolean>(flagKey)
     104            0 :   if (sessionOverride !== undefined) return sessionOverride
     105              : 
     106            0 :   const override = getDevOverride<boolean>(flagKey)
     107            0 :   if (override !== undefined) return override
     108              : 
     109            0 :   if (!isCloud) return false
     110              :   if (!isAuthenticatedConfigLoaded.value)
     111              :     return (
     112              :       grantedThisSession.value === true &&
     113              :       (grantValidUntil.value ?? 0) > Date.now()
     114              :     )
     115              : 
     116              :   return remoteConfigValue === true
     117              : }
     118              : 
     119              : /**
     120              :  * Composable for reactive access to server-side feature flags
     121              :  */
     122        54353 : export function useFeatureFlags() {
     123        54353 :   const hostedBillingDestination = () =>
     124              :     normalizeHostedBillingDestination(
     125              :       resolveFlag(
     126              :         ServerFeatureFlag.HOSTED_BILLING_DESTINATION,
     127              :         remoteConfig.value.hosted_billing_destination,
     128              :         'stripe'
     129              :       )
     130              :     )
     131              : 
     132        54353 :   const flags = reactive({
     133              :     get supportsPreviewMetadata() {
     134            0 :       return api.getServerFeature(ServerFeatureFlag.SUPPORTS_PREVIEW_METADATA)
     135              :     },
     136              :     get maxUploadSize() {
     137            0 :       return api.getServerFeature<GetFeaturesResponse['max_upload_size']>(
     138              :         ServerFeatureFlag.MAX_UPLOAD_SIZE
     139              :       )
     140              :     },
     141              :     get supportsManagerV4() {
     142            0 :       return api.getServerFeature(ServerFeatureFlag.MANAGER_SUPPORTS_V4)
     143              :     },
     144              :     /** ComfyUI's `agent` server feature; callers validate `state`. */
     145              :     get agent() {
     146         7065 :       return api.getServerFeature<{ state?: unknown } | null | undefined>(
     147              :         ServerFeatureFlag.AGENT
     148              :       )
     149              :     },
     150              :     get modelUploadButtonEnabled() {
     151            9 :       return resolveFlag(
     152              :         ServerFeatureFlag.MODEL_UPLOAD_BUTTON_ENABLED,
     153              :         remoteConfig.value.model_upload_button_enabled,
     154              :         false
     155              :       )
     156              :     },
     157              :     get assetDeletionEnabled() {
     158            1 :       return resolveFlag(
     159              :         ServerFeatureFlag.ASSET_DELETION_ENABLED,
     160              :         undefined,
     161              :         false
     162              :       )
     163              :     },
     164              :     get privateModelsEnabled() {
     165            0 :       return resolveFlag(
     166              :         ServerFeatureFlag.PRIVATE_MODELS_ENABLED,
     167              :         remoteConfig.value.private_models_enabled,
     168              :         false
     169              :       )
     170              :     },
     171              :     get onboardingSurveyEnabled() {
     172            0 :       return resolveFlag(
     173              :         ServerFeatureFlag.ONBOARDING_SURVEY_ENABLED,
     174              :         remoteConfig.value.onboarding_survey_enabled,
     175              :         false
     176              :       )
     177              :     },
     178              :     get signedOutRerouteEnabled() {
     179            0 :       return resolveFlag(
     180              :         ServerFeatureFlag.SIGNED_OUT_REROUTE_ENABLED,
     181              :         remoteConfig.value.signed_out_reroute_enabled,
     182              :         false
     183              :       )
     184              :     },
     185              :     get partnerNodeGovernanceEnabled() {
     186          110 :       return resolveFlag(
     187              :         ServerFeatureFlag.PARTNER_NODE_GOVERNANCE_ENABLED,
     188              :         remoteConfig.value.partner_node_governance_enabled,
     189              :         false
     190              :       )
     191              :     },
     192              :     get partnerRunGateEnabled() {
     193         7181 :       return resolveFlag(
     194              :         ServerFeatureFlag.PARTNER_RUN_GATE_ENABLED,
     195              :         remoteConfig.value.partner_run_gate_enabled,
     196              :         true
     197              :       )
     198              :     },
     199              :     get deploymentStartEnabled() {
     200            0 :       return resolveStrictBooleanFlag(
     201              :         ServerFeatureFlag.DEPLOYMENT_START_ENABLED,
     202              :         remoteConfig.value.deployment_start_enabled
     203              :       )
     204              :     },
     205              :     get partnerNodeTokenEnabled() {
     206            5 :       return resolveStrictBooleanFlag(
     207              :         ServerFeatureFlag.PARTNER_NODE_TOKEN,
     208              :         remoteConfig.value.partner_node_token
     209              :       )
     210              :     },
     211              :     get userSecretsEnabled() {
     212          113 :       return resolveFlag(
     213              :         ServerFeatureFlag.USER_SECRETS_ENABLED,
     214              :         remoteConfig.value.user_secrets_enabled,
     215              :         false
     216              :       )
     217              :     },
     218              :     get nodeReplacementsEnabled() {
     219            0 :       return api.getServerFeature(ServerFeatureFlag.NODE_REPLACEMENTS, false)
     220              :     },
     221              :     get openOnCloudEnabled() {
     222         4097 :       return resolveFlag(
     223              :         ServerFeatureFlag.OPEN_ON_CLOUD_ENABLED,
     224              :         remoteConfig.value.open_on_cloud_enabled,
     225              :         import.meta.env.DEV
     226              :       )
     227              :     },
     228              :     get openOnCloudUseLocalAgentEnabled() {
     229            0 :       return (
     230              :         resolveFlag<unknown>(
     231              :           ServerFeatureFlag.OPEN_ON_CLOUD_USE_LOCAL_AGENT_ENABLED,
     232              :           remoteConfig.value.open_on_cloud_use_local_agent_enabled,
     233              :           false
     234              :         ) === true
     235              :       )
     236              :     },
     237              :     get deployToCloud() {
     238         4001 :       return api.getServerFeature(ServerFeatureFlag.DEPLOY_TO_CLOUD, false)
     239              :     },
     240              :     get nodeLibraryEssentialsEnabled() {
     241      3464292 :       return resolveFlag(
     242              :         ServerFeatureFlag.NODE_LIBRARY_ESSENTIALS_ENABLED,
     243              :         remoteConfig.value.node_library_essentials_enabled,
     244              :         isNightly || import.meta.env.DEV
     245              :       )
     246              :     },
     247              :     get comfyHubUploadEnabled() {
     248            0 :       return resolveFlag(
     249              :         ServerFeatureFlag.COMFYHUB_UPLOAD_ENABLED,
     250              :         remoteConfig.value.comfyhub_upload_enabled,
     251              :         false
     252              :       )
     253              :     },
     254              :     get comfyHubProfileGateEnabled() {
     255           51 :       return resolveFlag(
     256              :         ServerFeatureFlag.COMFYHUB_PROFILE_GATE_ENABLED,
     257              :         remoteConfig.value.comfyhub_profile_gate_enabled,
     258              :         false
     259              :       )
     260              :     },
     261              :     get deploymentCompatibilityMarksEnabled() {
     262         8016 :       return resolveFlag(
     263              :         ServerFeatureFlag.DEPLOYMENT_COMPATIBILITY_MARKS_ENABLED,
     264              :         remoteConfig.value.deployment_compatibility_marks_enabled,
     265              :         false
     266              :       )
     267              :     },
     268              :     get runtimeLibraryModelsEnabled() {
     269         9396 :       return resolveFlag(
     270              :         ServerFeatureFlag.RUNTIME_LIBRARY_MODELS_ENABLED,
     271              :         remoteConfig.value.runtime_library_models_enabled,
     272              :         false
     273              :       )
     274              :     },
     275              :     /** The model folders an uploaded model file may go into; empty when uploads are off. */
     276              :     get modelUploadFolders(): readonly string[] {
     277            0 :       return resolveFlag<readonly string[]>(
     278              :         ServerFeatureFlag.MODEL_UPLOAD_FOLDERS,
     279              :         remoteConfig.value.model_upload_folders,
     280              :         []
     281              :       )
     282              :     },
     283              :     get lateCustomNodesEnabled() {
     284         2355 :       return resolveFlag(
     285              :         ServerFeatureFlag.LATE_CUSTOM_NODES_ENABLED,
     286              :         remoteConfig.value.late_custom_nodes_enabled,
     287              :         false
     288              :       )
     289              :     },
     290              :     get hostedBillingDestination() {
     291            0 :       return hostedBillingDestination()
     292              :     },
     293              :     get hostedBillingWebEnabled() {
     294            0 :       return hostedBillingDestination() === 'billing_web'
     295              :     },
     296              :     get showSignInButton(): boolean | undefined {
     297            0 :       return api.getServerFeature<boolean | undefined>(
     298              :         ServerFeatureFlag.SHOW_SIGNIN_BUTTON,
     299              :         undefined
     300              :       )
     301              :     },
     302              :     get unifiedWebSessionEnabled() {
     303            0 :       if (!isCloud) return false
     304              : 
     305              :       const key = ServerFeatureFlag.UNIFIED_WEB_SESSION
     306              :       // Overrides skip the server's web_session_enabled pairing; whoever overrides
     307              :       // this key must also be in the web_session_enabled set.
     308              :       const value =
     309              :         getSessionOverride<unknown>(key) ??
     310              :         getDevOverride<unknown>(key) ??
     311              :         remoteConfig.value.unified_web_session
     312              :       return value === true
     313              :     },
     314              :     get webSessionLapseRecoveryEnabled() {
     315         7091 :       return resolveFlag(
     316              :         ServerFeatureFlag.WEB_SESSION_LAPSE_RECOVERY_ENABLED,
     317              :         remoteConfig.value.web_session_lapse_recovery_enabled,
     318              :         false
     319              :       )
     320              :     },
     321              :     get ssoEnabled() {
     322          179 :       if (!isCloud) return false
     323              : 
     324              :       return resolveStrictBooleanFlag(
     325              :         ServerFeatureFlag.SSO_ENABLED,
     326              :         remoteConfig.value.sso_enabled
     327              :       )
     328              :     },
     329              :     /** Browser sign-in for a local ComfyUI that Desktop does not host. */
     330              :     get localWebSsoEnabled() {
     331              :       if (isCloud) return false
     332              : 
     333         2352 :       return resolveStrictBooleanFlag(
     334              :         ServerFeatureFlag.LOCAL_WEB_SSO,
     335              :         remoteConfig.value.local_web_sso
     336              :       )
     337              :     },
     338              :     get billingControlEnabled() {
     339            0 :       return resolveAuthGatedFlag(
     340              :         ServerFeatureFlag.BILLING_CONTROL_ENABLED,
     341              :         remoteConfig.value.billing_control_enabled,
     342              :         useRemoteConfigCache().cachedBillingControlEnabled
     343              :       )
     344              :     },
     345              :     get memberCreditLimitsEnabled() {
     346            1 :       return resolveStrictBooleanFlag(
     347              :         ServerFeatureFlag.MEMBER_CREDIT_LIMITS_ENABLED,
     348              :         remoteConfig.value.member_credit_limits_enabled
     349              :       )
     350              :     },
     351              :     get billingNewUxEnabled() {
     352         8144 :       return resolveStrictBooleanFlag(
     353              :         ServerFeatureFlag.BILLING_NEW_UX_ENABLED,
     354              :         showsCloudBillingNewUxOnLocal()
     355              :           ? true
     356              :           : remoteConfig.value.billing_new_ux_enabled
     357              :       )
     358              :     },
     359              :     get billingAutoTopUpAtCheckoutEnabled() {
     360            4 :       return resolveStrictBooleanFlag(
     361              :         ServerFeatureFlag.BILLING_AUTO_TOP_UP_AT_CHECKOUT_ENABLED,
     362              :         remoteConfig.value.billing_auto_top_up_at_checkout_enabled
     363              :       )
     364              :     },
     365              :     /** Top-up, subscription and billing reads run on the billing SDK on Cloud. */
     366              :     get billingSdkRailEnabled() {
     367           93 :       return isCloud
     368              :     },
     369              :     get unifiedBillingSettingsEnabled() {
     370          157 :       if (!isCloud) return opensLocalBillingHandoff()
     371              :       return resolveStrictBooleanFlag(
     372              :         ServerFeatureFlag.UNIFIED_BILLING_SETTINGS,
     373              :         remoteConfig.value.unified_billing_settings
     374              :       )
     375              :     },
     376              :     get pricingTableFallback() {
     377            0 :       return resolveStrictBooleanFlag(
     378              :         ServerFeatureFlag.PRICING_TABLE_FALLBACK,
     379              :         remoteConfig.value.pricing_table_fallback
     380              :       )
     381              :     },
     382              :     get oauthConsentSwitchAccountEnabled() {
     383            0 :       return resolveFlag(
     384              :         ServerFeatureFlag.OAUTH_CONSENT_SWITCH_ACCOUNT_ENABLED,
     385              :         remoteConfig.value.oauth_consent_switch_account_enabled,
     386              :         false
     387              :       )
     388              :     },
     389              :     get v1PaymentRecovery() {
     390            0 :       return resolveAuthGatedFlag(
     391              :         ServerFeatureFlag.V1_PAYMENT_RECOVERY,
     392              :         remoteConfig.value.v1_payment_recovery,
     393              :         useRemoteConfigCache().cachedV1PaymentRecovery
     394              :       )
     395              :     },
     396              :     get signupTurnstileMode() {
     397            2 :       return resolveFlag(
     398              :         ServerFeatureFlag.SIGNUP_TURNSTILE,
     399              :         remoteConfig.value.signup_turnstile,
     400              :         'off'
     401              :       )
     402              :     },
     403              :     get supportsModelTypeTags() {
     404          165 :       return resolveFlag(
     405              :         ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS,
     406              :         remoteConfig.value.supports_model_type_tags,
     407              :         false
     408              :       )
     409              :     },
     410              :     get assetsEnabled() {
     411        15419 :       return isCloud || resolveFlag('assets', undefined, false)
     412              :     },
     413              :     get agentInAppExperienceEnabled() {
     414            0 :       return resolveWhitelistFlag(
     415              :         ServerFeatureFlag.AGENT_IN_APP_EXPERIENCE,
     416              :         remoteConfig.value['agent-in-app-experience'],
     417              :         sessionAgentGrant,
     418              :         sessionAgentGrantValidUntil
     419              :       )
     420              :     }
     421              :   })
     422              : 
     423        54353 :   const featureFlag = <T = unknown>(featurePath: string, defaultValue?: T) =>
     424              :     computed(() => api.getServerFeature(featurePath, defaultValue))
     425              : 
     426        54353 :   return {
     427              :     flags: readonly(flags),
     428              :     featureFlag
     429              :   }
     430              : }
     431              : 
     432              : export function startFeatureFlagTelemetry() {
     433              :   const { flags } = useFeatureFlags()
     434              : 
     435              :   return watchEffect(() => {
     436              :     const evaluations = {
     437              :       [ServerFeatureFlag.SUPPORTS_PREVIEW_METADATA]:
     438              :         flags.supportsPreviewMetadata,
     439              :       [ServerFeatureFlag.MAX_UPLOAD_SIZE]: flags.maxUploadSize,
     440              :       [ServerFeatureFlag.MANAGER_SUPPORTS_V4]: flags.supportsManagerV4,
     441              :       [ServerFeatureFlag.MODEL_UPLOAD_BUTTON_ENABLED]:
     442              :         flags.modelUploadButtonEnabled,
     443              :       [ServerFeatureFlag.ASSET_DELETION_ENABLED]: flags.assetDeletionEnabled,
     444              :       [ServerFeatureFlag.PRIVATE_MODELS_ENABLED]: flags.privateModelsEnabled,
     445              :       [ServerFeatureFlag.ONBOARDING_SURVEY_ENABLED]:
     446              :         flags.onboardingSurveyEnabled,
     447              :       [ServerFeatureFlag.SIGNED_OUT_REROUTE_ENABLED]:
     448              :         flags.signedOutRerouteEnabled,
     449              :       [ServerFeatureFlag.PARTNER_NODE_GOVERNANCE_ENABLED]:
     450              :         flags.partnerNodeGovernanceEnabled,
     451              :       [ServerFeatureFlag.USER_SECRETS_ENABLED]: flags.userSecretsEnabled,
     452              :       [ServerFeatureFlag.NODE_REPLACEMENTS]: flags.nodeReplacementsEnabled,
     453              :       [ServerFeatureFlag.OPEN_ON_CLOUD_ENABLED]: flags.openOnCloudEnabled,
     454              :       [ServerFeatureFlag.OPEN_ON_CLOUD_USE_LOCAL_AGENT_ENABLED]:
     455              :         flags.openOnCloudUseLocalAgentEnabled,
     456              :       [ServerFeatureFlag.NODE_LIBRARY_ESSENTIALS_ENABLED]:
     457              :         flags.nodeLibraryEssentialsEnabled,
     458              :       [ServerFeatureFlag.COMFYHUB_UPLOAD_ENABLED]: flags.comfyHubUploadEnabled,
     459              :       [ServerFeatureFlag.COMFYHUB_PROFILE_GATE_ENABLED]:
     460              :         flags.comfyHubProfileGateEnabled,
     461              :       [ServerFeatureFlag.HOSTED_BILLING_DESTINATION]:
     462              :         flags.hostedBillingDestination,
     463              :       [ServerFeatureFlag.SHOW_SIGNIN_BUTTON]: flags.showSignInButton,
     464              :       [ServerFeatureFlag.UNIFIED_WEB_SESSION]: flags.unifiedWebSessionEnabled,
     465              :       [ServerFeatureFlag.SSO_ENABLED]: flags.ssoEnabled,
     466              :       [ServerFeatureFlag.WEB_SESSION_LAPSE_RECOVERY_ENABLED]:
     467              :         flags.webSessionLapseRecoveryEnabled,
     468              :       [ServerFeatureFlag.BILLING_CONTROL_ENABLED]: flags.billingControlEnabled,
     469              :       [ServerFeatureFlag.MEMBER_CREDIT_LIMITS_ENABLED]:
     470              :         flags.memberCreditLimitsEnabled,
     471              :       [ServerFeatureFlag.BILLING_NEW_UX_ENABLED]: flags.billingNewUxEnabled,
     472              :       [ServerFeatureFlag.BILLING_AUTO_TOP_UP_AT_CHECKOUT_ENABLED]:
     473              :         flags.billingAutoTopUpAtCheckoutEnabled,
     474              :       [ServerFeatureFlag.UNIFIED_BILLING_SETTINGS]:
     475              :         flags.unifiedBillingSettingsEnabled,
     476              :       [ServerFeatureFlag.PRICING_TABLE_FALLBACK]: flags.pricingTableFallback,
     477              :       [ServerFeatureFlag.OAUTH_CONSENT_SWITCH_ACCOUNT_ENABLED]:
     478              :         flags.oauthConsentSwitchAccountEnabled,
     479              :       [ServerFeatureFlag.V1_PAYMENT_RECOVERY]: flags.v1PaymentRecovery,
     480              :       [ServerFeatureFlag.SIGNUP_TURNSTILE]: flags.signupTurnstileMode,
     481              :       [ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS]: flags.supportsModelTypeTags,
     482              :       [ServerFeatureFlag.AGENT_IN_APP_EXPERIENCE]:
     483              :         flags.agentInAppExperienceEnabled,
     484              :       assets: flags.assetsEnabled
     485              :     }
     486              : 
     487              :     for (const [key, value] of Object.entries(evaluations))
     488              :       reportFeatureFlagEvaluation(key, value)
     489              :   })
     490              : }
        

Generated by: LCOV version 2.0-1