• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2024 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.adservices.service;
18 
19 import static com.android.adservices.service.Flags.AD_SERVICES_MODULE_JOB_POLICY;
20 import static com.android.adservices.service.Flags.APPSEARCH_ONLY;
21 import static com.android.adservices.service.Flags.COBALT__IGNORED_REPORT_ID_LIST;
22 import static com.android.adservices.service.Flags.COMPONENT_AD_RENDER_ID_MAX_LENGTH_BYTES;
23 import static com.android.adservices.service.Flags.DEFAULT_ADID_CACHE_TTL_MS;
24 import static com.android.adservices.service.Flags.DEFAULT_AD_SERVICES_CEL_SAMPLING_CONFIG;
25 import static com.android.adservices.service.Flags.DEFAULT_AD_SERVICES_JOB_EXECUTION_SAMPLING_CONFIG;
26 import static com.android.adservices.service.Flags.DEFAULT_AD_SERVICES_JOB_SCHEDULING_SAMPLING_CONFIG;
27 import static com.android.adservices.service.Flags.DEFAULT_BLOCKED_TOPICS_SOURCE_OF_TRUTH;
28 import static com.android.adservices.service.Flags.DEFAULT_CONSENT_SOURCE_OF_TRUTH;
29 import static com.android.adservices.service.Flags.DEFAULT_ENABLE_LOG_SAMPLING_INFRA;
30 import static com.android.adservices.service.Flags.DEFAULT_JOB_SCHEDULING_LOGGING_SAMPLING_RATE;
31 import static com.android.adservices.service.Flags.DEFAULT_MDD_PACKAGE_DENY_REGISTRY_MANIFEST_FILE_URL;
32 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_AD_IDS_PER_DEVICE_PER_WINDOW_PERIOD_MS;
33 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_COUNT_UNIQUE_APP_ALLOWLIST;
34 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_COUNT_UNIQUE_APP_SIGNATURE_ALLOWLIST;
35 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_COUNT_UNIQUE_REPORTING_JOB_PERIOD_MS;
36 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_ENABLE_AD_IDS_PER_DEVICE_PER_WINDOW;
37 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_ENABLE_COUNT_UNIQUE_REPORTING_JOB;
38 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_ENABLE_COUNT_UNIQUE_SERVICE;
39 import static com.android.adservices.service.Flags.DEFAULT_MEASUREMENT_ENABLE_PACKAGE_NAME_UID_CHECK;
40 import static com.android.adservices.service.Flags.DEFAULT_MSMT_REGISTER_SOURCE_PACKAGE_DENY_LIST;
41 import static com.android.adservices.service.Flags.DEFAULT_PACKAGE_DENY_BACKGROUND_JOB_PERIOD_MILLIS;
42 import static com.android.adservices.service.Flags.DEFAULT_PAS_SCRIPT_DOWNLOAD_CONNECTION_TIMEOUT_MS;
43 import static com.android.adservices.service.Flags.DEFAULT_PAS_SCRIPT_DOWNLOAD_READ_TIMEOUT_MS;
44 import static com.android.adservices.service.Flags.DEFAULT_PAS_SCRIPT_EXECUTION_TIMEOUT_MS;
45 import static com.android.adservices.service.Flags.DEFAULT_PAS_SIGNALS_DOWNLOAD_CONNECTION_TIMEOUT_MS;
46 import static com.android.adservices.service.Flags.DEFAULT_PAS_SIGNALS_DOWNLOAD_READ_TIMEOUT_MS;
47 import static com.android.adservices.service.Flags.ENABLE_APPSEARCH_CONSENT_DATA;
48 import static com.android.adservices.service.Flags.ENABLE_CUSTOM_AUDIENCE_COMPONENT_ADS;
49 import static com.android.adservices.service.Flags.ENABLE_GET_BINDING_UID_IMPORTANCE;
50 import static com.android.adservices.service.Flags.ENABLE_PAS_COMPONENT_ADS;
51 import static com.android.adservices.service.Flags.ENFORCE_FOREGROUND_STATUS_FETCH_AND_JOIN_CUSTOM_AUDIENCE;
52 import static com.android.adservices.service.Flags.ENFORCE_FOREGROUND_STATUS_LEAVE_CUSTOM_AUDIENCE;
53 import static com.android.adservices.service.Flags.ENFORCE_FOREGROUND_STATUS_SCHEDULE_CUSTOM_AUDIENCE;
54 import static com.android.adservices.service.Flags.FLEDGE_CUSTOM_AUDIENCE_PER_BUYER_MAX_COUNT;
55 import static com.android.adservices.service.Flags.FLEDGE_FETCH_AND_JOIN_CUSTOM_AUDIENCE_REQUEST_PERMITS_PER_SECOND;
56 import static com.android.adservices.service.Flags.FLEDGE_FORCED_ENCODING_AFTER_SIGNALS_UPDATE_COOLDOWN_SECONDS;
57 import static com.android.adservices.service.Flags.FLEDGE_GET_AD_SELECTION_DATA_BUYER_INPUT_CREATOR_VERSION;
58 import static com.android.adservices.service.Flags.FLEDGE_GET_AD_SELECTION_DATA_DESERIALIZE_ONLY_AD_RENDER_IDS;
59 import static com.android.adservices.service.Flags.FLEDGE_GET_AD_SELECTION_DATA_MAX_NUM_ENTIRE_PAYLOAD_COMPRESSIONS;
60 import static com.android.adservices.service.Flags.FLEDGE_GET_AD_SELECTION_DATA_REQUEST_PERMITS_PER_SECOND;
61 import static com.android.adservices.service.Flags.FLEDGE_JOIN_CUSTOM_AUDIENCE_REQUEST_PERMITS_PER_SECOND;
62 import static com.android.adservices.service.Flags.FLEDGE_LEAVE_CUSTOM_AUDIENCE_REQUEST_PERMITS_PER_SECOND;
63 import static com.android.adservices.service.Flags.FLEDGE_PERSIST_AD_SELECTION_RESULT_REQUEST_PERMITS_PER_SECOND;
64 import static com.android.adservices.service.Flags.FLEDGE_REPORT_IMPRESSION_REQUEST_PERMITS_PER_SECOND;
65 import static com.android.adservices.service.Flags.FLEDGE_REPORT_INTERACTION_REQUEST_PERMITS_PER_SECOND;
66 import static com.android.adservices.service.Flags.FLEDGE_SCHEDULE_CUSTOM_AUDIENCE_UPDATE_BACKGROUND_JOB_REQUIRED_NETWORK_TYPE;
67 import static com.android.adservices.service.Flags.FLEDGE_SCHEDULE_CUSTOM_AUDIENCE_UPDATE_MAX_BYTES;
68 import static com.android.adservices.service.Flags.FLEDGE_SCHEDULE_CUSTOM_AUDIENCE_UPDATE_REQUEST_PERMITS_PER_SECOND;
69 import static com.android.adservices.service.Flags.FLEDGE_SELECT_ADS_REQUEST_PERMITS_PER_SECOND;
70 import static com.android.adservices.service.Flags.FLEDGE_SELECT_ADS_WITH_OUTCOMES_REQUEST_PERMITS_PER_SECOND;
71 import static com.android.adservices.service.Flags.FLEDGE_SET_APP_INSTALL_ADVERTISERS_REQUEST_PERMITS_PER_SECOND;
72 import static com.android.adservices.service.Flags.FLEDGE_UPDATE_AD_COUNTER_HISTOGRAM_REQUEST_PERMITS_PER_SECOND;
73 import static com.android.adservices.service.Flags.FLEDGE_UPDATE_SIGNALS_REQUEST_PERMITS_PER_SECOND;
74 import static com.android.adservices.service.Flags.GLOBAL_KILL_SWITCH;
75 import static com.android.adservices.service.Flags.MAX_COMPONENT_ADS_PER_CUSTOM_AUDIENCE;
76 import static com.android.adservices.service.Flags.MDD_LOGGER_KILL_SWITCH;
77 import static com.android.adservices.service.Flags.MEASUREMENT_ADR_BUDGET_PER_ORIGIN_PUBLISHER_WINDOW;
78 import static com.android.adservices.service.Flags.MEASUREMENT_ADR_BUDGET_PER_PUBLISHER_WINDOW;
79 import static com.android.adservices.service.Flags.MEASUREMENT_ADR_BUDGET_WINDOW_LENGTH_MILLIS;
80 import static com.android.adservices.service.Flags.MEASUREMENT_ATTRIBUTION_JOB_TRIGGERING_MAX_DELAY_MS;
81 import static com.android.adservices.service.Flags.MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_DUAL_DESTINATION_EVENT;
82 import static com.android.adservices.service.Flags.MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_DUAL_DESTINATION_NAVIGATION;
83 import static com.android.adservices.service.Flags.MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_EVENT;
84 import static com.android.adservices.service.Flags.MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_NAVIGATION;
85 import static com.android.adservices.service.Flags.MEASUREMENT_DEBUG_JOIN_KEYS_NONCOMPLIANT_ADTECHS;
86 import static com.android.adservices.service.Flags.MEASUREMENT_DEBUG_JOIN_KEYS_NONCOMPLIANT_ADTECHS_SAMPLE_RATE;
87 import static com.android.adservices.service.Flags.MEASUREMENT_DEFAULT_DESTINATION_LIMIT_ALGORITHM;
88 import static com.android.adservices.service.Flags.MEASUREMENT_DEFAULT_FILTERING_ID_MAX_BYTES;
89 import static com.android.adservices.service.Flags.MEASUREMENT_DESTINATION_PER_DAY_RATE_LIMIT;
90 import static com.android.adservices.service.Flags.MEASUREMENT_DESTINATION_PER_DAY_RATE_LIMIT_WINDOW_IN_MS;
91 import static com.android.adservices.service.Flags.MEASUREMENT_DESTINATION_RATE_LIMIT_WINDOW;
92 import static com.android.adservices.service.Flags.MEASUREMENT_ENABLE_DEBUG_JOIN_KEYS_OPEN_ACCESS;
93 import static com.android.adservices.service.Flags.MEASUREMENT_KILL_SWITCH;
94 import static com.android.adservices.service.Flags.MEASUREMENT_MAX_ADR_COUNT_PER_SOURCE;
95 import static com.android.adservices.service.Flags.MEASUREMENT_MAX_AGGREGATE_REPORTS_PER_SOURCE;
96 import static com.android.adservices.service.Flags.MEASUREMENT_MAX_FILTERING_ID_MAX_BYTES;
97 import static com.android.adservices.service.Flags.MEASUREMENT_MAX_LENGTH_PER_BUDGET_NAME;
98 import static com.android.adservices.service.Flags.MEASUREMENT_MAX_NAMED_BUDGETS_PER_SOURCE_REGISTRATION;
99 import static com.android.adservices.service.Flags.MEASUREMENT_MAX_REINSTALL_REATTRIBUTION_WINDOW_SECONDS;
100 import static com.android.adservices.service.Flags.MEASUREMENT_MIN_REPORT_LIFESPAN_FOR_UNINSTALL_SECONDS;
101 import static com.android.adservices.service.Flags.MEASUREMENT_REPORTING_JOB_PERSISTED;
102 import static com.android.adservices.service.Flags.MEASUREMENT_REPORTING_JOB_REQUIRED_BATTERY_NOT_LOW;
103 import static com.android.adservices.service.Flags.MEASUREMENT_REPORTING_JOB_REQUIRED_NETWORK_TYPE;
104 import static com.android.adservices.service.Flags.MEASUREMENT_REPORTING_JOB_SERVICE_BATCH_WINDOW_MILLIS;
105 import static com.android.adservices.service.Flags.MEASUREMENT_REPORTING_JOB_SERVICE_MIN_EXECUTION_WINDOW_MILLIS;
106 import static com.android.adservices.service.Flags.MEASUREMENT_TRIGGER_DEBUG_SIGNAL_PROBABILITY_FOR_FAKE_REPORTS;
107 import static com.android.adservices.service.Flags.PPAPI_AND_SYSTEM_SERVER;
108 import static com.android.adservices.service.Flags.PROTECTED_SIGNALS_MAX_JS_FAILURE_EXECUTION_ON_CERTAIN_VERSION_BEFORE_STOP;
109 import static com.android.adservices.service.Flags.PROTECTED_SIGNALS_MAX_SIGNAL_SIZE_PER_BUYER_BYTES;
110 import static com.android.adservices.service.Flags.PROTECTED_SIGNALS_MAX_SIGNAL_SIZE_PER_BUYER_WITH_OVERSUBSCIPTION_BYTES;
111 import static com.android.adservices.service.Flags.PROTECTED_SIGNALS_UPDATE_SCHEMA_VERSION;
112 import static com.android.adservices.service.Flags.TOPICS_EPOCH_JOB_FLEX_MS;
113 import static com.android.adservices.shared.common.flags.ModuleSharedFlags.DEFAULT_JOB_SCHEDULING_LOGGING_ENABLED;
114 import static com.android.adservices.shared.testing.AndroidSdk.SC;
115 import static com.android.adservices.shared.testing.AndroidSdk.SC_V2;
116 
117 import android.util.Log;
118 
119 import com.android.adservices.common.AdServicesUnitTestCase;
120 import com.android.adservices.shared.common.flags.ConfigFlag;
121 import com.android.adservices.shared.common.flags.FeatureFlag;
122 import com.android.adservices.shared.testing.annotations.RequiresSdkLevelAtLeastT;
123 import com.android.adservices.shared.testing.annotations.RequiresSdkRange;
124 import com.android.internal.util.Preconditions;
125 
126 import org.junit.AssumptionViolatedException;
127 import org.junit.Test;
128 
129 import java.lang.annotation.Annotation;
130 import java.lang.reflect.Field;
131 import java.lang.reflect.Modifier;
132 import java.util.ArrayList;
133 import java.util.Arrays;
134 import java.util.List;
135 
136 // NOTE: when adding a new method to the class, try to find the proper "block"
137 public final class FlagsTest extends AdServicesUnitTestCase {
138 
139     private static final String TAG = FlagsTest.class.getSimpleName();
140 
141     static final String REASON_TO_NOT_MOCK_SDK_LEVEL =
142             "Uses Flags.java constant that checks SDK level when the class is instantiated, hence"
143                     + " calls to static SdkLevel methods cannot be mocked";
144 
145     private final Flags mFlags = new Flags() {};
146 
147     private final Flags mGlobalKsOnFlags = new GlobalKillSwitchAwareFlags(true);
148     private final Flags mGlobalKsOffFlags = new GlobalKillSwitchAwareFlags(false);
149 
150     private final Flags mMsmtEnabledFlags = new MsmtFeatureAwareFlags(true);
151     private final Flags mMsmtDisabledFlags = new MsmtFeatureAwareFlags(false);
152 
153     private final Flags mMsmtKsOnFlags = new MsmtKillSwitchAwareFlags(true);
154     private final Flags mMsmtKsOffFlags = new MsmtKillSwitchAwareFlags(false);
155 
156     ////////////////////////////////////////////////////////////////////////////////////////////////
157     // Tests for flags that depend on SDK level.                                                  //
158     ////////////////////////////////////////////////////////////////////////////////////////////////
159 
160     @Test
161     @RequiresSdkRange(atLeast = SC, atMost = SC_V2, reason = REASON_TO_NOT_MOCK_SDK_LEVEL)
testConsentSourceOfTruth_isS()162     public void testConsentSourceOfTruth_isS() {
163         assertConsentSourceOfTruth(APPSEARCH_ONLY);
164     }
165 
166     @Test
167     @RequiresSdkLevelAtLeastT(reason = REASON_TO_NOT_MOCK_SDK_LEVEL)
testConsentSourceOfTruth_isAtLeastT()168     public void testConsentSourceOfTruth_isAtLeastT() {
169         assertConsentSourceOfTruth(PPAPI_AND_SYSTEM_SERVER);
170     }
171 
assertConsentSourceOfTruth(int expected)172     private void assertConsentSourceOfTruth(int expected) {
173         expect.withMessage("DEFAULT_CONSENT_SOURCE_OF_TRUTH")
174                 .that(DEFAULT_CONSENT_SOURCE_OF_TRUTH)
175                 .isEqualTo(expected);
176 
177         expect.withMessage("getConsentSourceOfTruth()")
178                 .that(mFlags.getConsentSourceOfTruth())
179                 .isEqualTo(expected);
180     }
181 
182     @Test
183     @RequiresSdkRange(atLeast = SC, atMost = SC_V2, reason = REASON_TO_NOT_MOCK_SDK_LEVEL)
testBlockedTopicsConsentSourceOfTruth_isS()184     public void testBlockedTopicsConsentSourceOfTruth_isS() {
185         assertBlockedTopicsSourceOfTruth(APPSEARCH_ONLY);
186     }
187 
188     @Test
189     @RequiresSdkLevelAtLeastT(reason = REASON_TO_NOT_MOCK_SDK_LEVEL)
testBlockedTopicsConsentSourceOfTruth_isAtLeastT()190     public void testBlockedTopicsConsentSourceOfTruth_isAtLeastT() {
191         assertBlockedTopicsSourceOfTruth(PPAPI_AND_SYSTEM_SERVER);
192     }
193 
assertBlockedTopicsSourceOfTruth(int expected)194     private void assertBlockedTopicsSourceOfTruth(int expected) {
195         expect.withMessage("DEFAULT_BLOCKED_TOPICS_SOURCE_OF_TRUTH")
196                 .that(DEFAULT_BLOCKED_TOPICS_SOURCE_OF_TRUTH)
197                 .isEqualTo(expected);
198 
199         expect.withMessage("getBlockedTopicsSourceOfTruth()")
200                 .that(mFlags.getBlockedTopicsSourceOfTruth())
201                 .isEqualTo(expected);
202     }
203 
204     @Test
205     @RequiresSdkRange(atLeast = SC, atMost = SC_V2, reason = REASON_TO_NOT_MOCK_SDK_LEVEL)
testEnableAppsearchConsentData_isS()206     public void testEnableAppsearchConsentData_isS() {
207         assertEnableAppsearchConsentData(true);
208     }
209 
210     @Test
211     @RequiresSdkLevelAtLeastT(reason = REASON_TO_NOT_MOCK_SDK_LEVEL)
testEnableAppsearchConsentData_isAtLeastT()212     public void testEnableAppsearchConsentData_isAtLeastT() {
213         assertEnableAppsearchConsentData(false);
214     }
215 
assertEnableAppsearchConsentData(boolean expected)216     private void assertEnableAppsearchConsentData(boolean expected) {
217         expect.withMessage("ENABLE_APPSEARCH_CONSENT_DATA")
218                 .that(ENABLE_APPSEARCH_CONSENT_DATA)
219                 .isEqualTo(expected);
220 
221         expect.withMessage("getEnableAppsearchConsentData()")
222                 .that(mFlags.getEnableAppsearchConsentData())
223                 .isEqualTo(expected);
224     }
225 
226     @Test
testGetAdServicesModuleJobPolicy()227     public void testGetAdServicesModuleJobPolicy() {
228         expect.withMessage("AD_SERVICES_MODULE_JOB_POLICY")
229                 .that(AD_SERVICES_MODULE_JOB_POLICY)
230                 .isEqualTo("");
231         expect.withMessage("getAdServicesModuleJobPolicy()")
232                 .that(mFlags.getAdServicesModuleJobPolicy())
233                 .isEqualTo(AD_SERVICES_MODULE_JOB_POLICY);
234     }
235 
236     ////////////////////////////////////////////////////////////////////////////////////////////////
237     // Tests for (legacy) kill-switch flags that are already in production - the flag name cannot //
238     // change, but their underlying getter / constants might.                                     //
239     ////////////////////////////////////////////////////////////////////////////////////////////////
240 
241     @Test
testGetGlobalKillSwitch()242     public void testGetGlobalKillSwitch() {
243         // Getter
244         expect.withMessage("getGlobalKillSwitch()").that(mFlags.getGlobalKillSwitch()).isTrue();
245 
246         // Constant
247         expect.withMessage("GLOBAL_KILL_SWITCH").that(GLOBAL_KILL_SWITCH).isTrue();
248     }
249 
250     @Test
testGetTopicsKillSwitch()251     public void testGetTopicsKillSwitch() {
252         testNewKillSwitchGuardedByGlobalKillSwitch(
253                 "TOPICS_KILL_SWITCH", Flags::getTopicsKillSwitch);
254     }
255 
256     @Test
testGetLegacyMeasurementKillSwitch()257     public void testGetLegacyMeasurementKillSwitch() {
258         testRampedUpKillSwitchGuardedByGlobalKillSwitch(
259                 "MEASUREMENT_KILL_SWITCH", Flags::getLegacyMeasurementKillSwitch);
260         expect.withMessage("getLegacyMeasurementKillSwitch()")
261                 .that(mFlags.getLegacyMeasurementKillSwitch())
262                 .isEqualTo(!mFlags.getMeasurementEnabled());
263         expect.withMessage("getLegacyMeasurementKillSwitch() when global kill_switch is enabled")
264                 .that(mGlobalKsOnFlags.getLegacyMeasurementKillSwitch())
265                 .isEqualTo(!mGlobalKsOnFlags.getMeasurementEnabled());
266         expect.withMessage("getLegacyMeasurementKillSwitch() when global kill_switch is enabled")
267                 .that(mGlobalKsOffFlags.getLegacyMeasurementKillSwitch())
268                 .isEqualTo(!mGlobalKsOffFlags.getMeasurementEnabled());
269     }
270 
271     @Test
testGetMeasurementEnabled()272     public void testGetMeasurementEnabled() {
273         testFeatureFlagBasedOnLegacyKillSwitchAndGuardedByGlobalKillSwitch(
274                 "getMeasurementEnabled()", MEASUREMENT_KILL_SWITCH, Flags::getMeasurementEnabled);
275     }
276 
277     @Test
testGetMddLoggerEnabled()278     public void testGetMddLoggerEnabled() {
279         testFeatureFlagBasedOnLegacyKillSwitchAndGuardedByGlobalKillSwitch(
280                 "getMddLoggerEnabled()", MDD_LOGGER_KILL_SWITCH, Flags::getMddLoggerEnabled);
281     }
282 
283     ////////////////////////////////////////////////////////////////////////////////////////////////
284     // Tests for feature flags.                                                                   //
285     ////////////////////////////////////////////////////////////////////////////////////////////////
286 
287     @Test
testGetEnablePackageDenyService()288     public void testGetEnablePackageDenyService() {
289         testFeatureFlag("DEFAULT_ENABLE_PACKAGE_DENY_SERVICE", Flags::getEnablePackageDenyService);
290     }
291 
292     @Test
testGetEnablePackageDenyMdd()293     public void testGetEnablePackageDenyMdd() {
294         testFeatureFlag("DEFAULT_ENABLE_PACKAGE_DENY_MDD", Flags::getEnablePackageDenyMdd);
295     }
296 
297     @Test
testGetEnablePackageDenyJobOnPackageAdd()298     public void testGetEnablePackageDenyJobOnPackageAdd() {
299         testFeatureFlag(
300                 "DEFAULT_ENABLE_PACKAGE_DENY_JOB_ON_PACKAGE_ADD",
301                 Flags::getEnablePackageDenyJobOnPackageAdd);
302     }
303 
304     @Test
testGetEnablePackageDenyBgJob()305     public void testGetEnablePackageDenyBgJob() {
306         testFeatureFlag("DEFAULT_ENABLE_PACKAGE_DENY_BG_JOB", Flags::getEnablePackageDenyBgJob);
307     }
308 
309     @Test
testGetEnableInstalledPackageFilter()310     public void testGetEnableInstalledPackageFilter() {
311         testFeatureFlag(
312                 "DEFAULT_PACKAGE_DENY_ENABLE_INSTALLED_PACKAGE_FILTER",
313                 Flags::getPackageDenyEnableInstalledPackageFilter);
314     }
315 
316     @Test
testGetBackgroundJobPeriodMillis()317     public void testGetBackgroundJobPeriodMillis() {
318         testFlag(
319                 "getBackgroundJobPeriodMillis",
320                 DEFAULT_PACKAGE_DENY_BACKGROUND_JOB_PERIOD_MILLIS,
321                 Flags::getPackageDenyBackgroundJobPeriodMillis);
322     }
323 
324     @Test
testGetEnablePackageDenyJobOnMddDownload()325     public void testGetEnablePackageDenyJobOnMddDownload() {
326         testFeatureFlag(
327                 "DEFAULT_ENABLE_PACKAGE_DENY_JOB_ON_MDD_DOWNLOAD",
328                 Flags::getEnablePackageDenyJobOnMddDownload);
329     }
330 
331     @Test
testGetProtectedSignalsEnabled()332     public void testGetProtectedSignalsEnabled() {
333         testFeatureFlagGuardedByGlobalKillSwitch(
334                 "PROTECTED_SIGNALS_ENABLED", Flags::getProtectedSignalsEnabled);
335     }
336 
337     @Test
testGetCobaltLoggingEnabled()338     public void testGetCobaltLoggingEnabled() {
339         testFeatureFlagGuardedByGlobalKillSwitch(
340                 "COBALT_LOGGING_ENABLED", Flags::getCobaltLoggingEnabled);
341     }
342 
343     @Test
testGetMsmtRegistrationCobaltLoggingEnabled()344     public void testGetMsmtRegistrationCobaltLoggingEnabled() {
345         testFeatureFlagGuardedByGlobalKillSwitch(
346                 "MSMT_REGISTRATION_COBALT_LOGGING_ENABLED",
347                 Flags::getMsmtRegistrationCobaltLoggingEnabled);
348     }
349 
350     @Test
testGetMsmtAttributionCobaltLoggingEnabled()351     public void testGetMsmtAttributionCobaltLoggingEnabled() {
352         testFeatureFlagGuardedByGlobalKillSwitch(
353                 "MSMT_ATTRIBUTION_COBALT_LOGGING_ENABLED",
354                 Flags::getMsmtAttributionCobaltLoggingEnabled);
355     }
356 
357     @Test
testGetMsmtReportigCobaltLoggingEnabled()358     public void testGetMsmtReportigCobaltLoggingEnabled() {
359         testFeatureFlagGuardedByGlobalKillSwitch(
360                 "MSMT_REPORTING_COBALT_LOGGING_ENABLED",
361                 Flags::getMsmtReportingCobaltLoggingEnabled);
362     }
363 
364     @Test
testGetMeasurementEnableHeaderErrorDebugReport()365     public void testGetMeasurementEnableHeaderErrorDebugReport() {
366         testFeatureFlagGuardedByGlobalKillSwitch(
367                 "MEASUREMENT_ENABLE_HEADER_ERROR_DEBUG_REPORT",
368                 Flags::getMeasurementEnableHeaderErrorDebugReport);
369     }
370 
371     @Test
testGetEnableBackCompat()372     public void testGetEnableBackCompat() {
373         testFeatureFlag("ENABLE_BACK_COMPAT", Flags::getEnableBackCompat);
374     }
375 
376     @Test
testGetFledgeAuctionServerGetAdSelectionDataPayloadMetricsEnabled()377     public void testGetFledgeAuctionServerGetAdSelectionDataPayloadMetricsEnabled() {
378         testFeatureFlag(
379                 "FLEDGE_AUCTION_SERVER_GET_AD_SELECTION_DATA_PAYLOAD_METRICS_ENABLED",
380                 Flags::getFledgeAuctionServerGetAdSelectionDataPayloadMetricsEnabled);
381     }
382 
383     @Test
testGetFledgeAuctionServerKeyFetchMetricsEnabled()384     public void testGetFledgeAuctionServerKeyFetchMetricsEnabled() {
385         testFeatureFlag(
386                 "FLEDGE_AUCTION_SERVER_KEY_FETCH_METRICS_ENABLED",
387                 Flags::getFledgeAuctionServerKeyFetchMetricsEnabled);
388     }
389 
390     @Test
testGetFledgeSelectAdsFromOutcomesApiMetricsEnabled()391     public void testGetFledgeSelectAdsFromOutcomesApiMetricsEnabled() {
392         testFeatureFlag(
393                 "FLEDGE_SELECT_ADS_FROM_OUTCOMES_API_METRICS_ENABLED",
394                 Flags::getFledgeSelectAdsFromOutcomesApiMetricsEnabled);
395     }
396 
397     @Test
testGetFledgeCpcBillingMetricsEnabled()398     public void testGetFledgeCpcBillingMetricsEnabled() {
399         testFeatureFlag(
400                 "FLEDGE_CPC_BILLING_METRICS_ENABLED", Flags::getFledgeCpcBillingMetricsEnabled);
401     }
402 
403     @Test
testGetFledgeDataVersionHeaderMetricsEnabled()404     public void testGetFledgeDataVersionHeaderMetricsEnabled() {
405         testFeatureFlag(
406                 "FLEDGE_DATA_VERSION_HEADER_METRICS_ENABLED",
407                 Flags::getFledgeDataVersionHeaderMetricsEnabled);
408     }
409 
410     @Test
testGetFledgeReportImpressionApiMetricsEnabled()411     public void testGetFledgeReportImpressionApiMetricsEnabled() {
412         testFeatureFlag(
413                 "FLEDGE_REPORT_IMPRESSION_API_METRICS_ENABLED",
414                 Flags::getFledgeReportImpressionApiMetricsEnabled);
415     }
416 
417     @Test
testGetFledgeJsScriptResultCodeMetricsEnabled()418     public void testGetFledgeJsScriptResultCodeMetricsEnabled() {
419         testFeatureFlag(
420                 "FLEDGE_JS_SCRIPT_RESULT_CODE_METRICS_ENABLED",
421                 Flags::getFledgeJsScriptResultCodeMetricsEnabled);
422     }
423 
424     @Test
testGetSpeOnPilotJobsEnabled()425     public void testGetSpeOnPilotJobsEnabled() {
426         testFeatureFlag("DEFAULT_SPE_ON_PILOT_JOBS_ENABLED", Flags::getSpeOnPilotJobsEnabled);
427     }
428 
429     @Test
testGetEnrollmentApiBasedSchemaEnabled()430     public void testGetEnrollmentApiBasedSchemaEnabled() {
431         testFeatureFlag(
432                 "ENROLLMENT_API_BASED_SCHEMA_ENABLED", Flags::getEnrollmentApiBasedSchemaEnabled);
433     }
434 
435     @Test
testGetEnableEnrollmentConfigV3Db()436     public void testGetEnableEnrollmentConfigV3Db() {
437         testFeatureFlag(
438                 "DEFAULT_ENABLE_ENROLLMENT_CONFIG_V3_DB", Flags::getEnableEnrollmentConfigV3Db);
439     }
440 
441     @Test
testGetUseConfigsManagerToQueryEnrollment()442     public void testGetUseConfigsManagerToQueryEnrollment() {
443         testFeatureFlag(
444                 "DEFAULT_USE_CONFIGS_MANAGER_TO_QUERY_ENROLLMENT",
445                 Flags::getUseConfigsManagerToQueryEnrollment);
446     }
447 
448     @Test
testGetSharedDatabaseSchemaVersion4Enabled()449     public void testGetSharedDatabaseSchemaVersion4Enabled() {
450         testFeatureFlag(
451                 "SHARED_DATABASE_SCHEMA_VERSION_4_ENABLED",
452                 Flags::getSharedDatabaseSchemaVersion4Enabled);
453     }
454 
455     @Test
testGetJobSchedulingLoggingEnabled()456     public void testGetJobSchedulingLoggingEnabled() {
457         testFlag(
458                 "getJobSchedulingLoggingEnabled()",
459                 DEFAULT_JOB_SCHEDULING_LOGGING_ENABLED,
460                 Flags::getJobSchedulingLoggingEnabled);
461     }
462 
463     @Test
testGetMeasurementMaxLengthPerBudgetName()464     public void testGetMeasurementMaxLengthPerBudgetName() {
465         testFlag(
466                 "getMeasurementMaxLengthPerBudgetName()",
467                 MEASUREMENT_MAX_LENGTH_PER_BUDGET_NAME,
468                 Flags::getMeasurementMaxLengthPerBudgetName);
469     }
470 
471     @Test
testGetMeasurementMaxNamedBudgetsPerSourceRegistration()472     public void testGetMeasurementMaxNamedBudgetsPerSourceRegistration() {
473         testFlag(
474                 "getMeasurementMaxNamedBudgetsPerSourceRegistration()",
475                 MEASUREMENT_MAX_NAMED_BUDGETS_PER_SOURCE_REGISTRATION,
476                 Flags::getMeasurementMaxNamedBudgetsPerSourceRegistration);
477     }
478 
479     @Test
testGetMeasurementMaxAggregateReportsPerSource()480     public void testGetMeasurementMaxAggregateReportsPerSource() {
481         testFlag(
482                 "getMeasurementMaxAggregateReportsPerSource()",
483                 MEASUREMENT_MAX_AGGREGATE_REPORTS_PER_SOURCE,
484                 Flags::getMeasurementMaxAggregateReportsPerSource);
485     }
486 
487     @Test
testGetMeasurementEnableUnboundedReportsWithTriggerContextId()488     public void testGetMeasurementEnableUnboundedReportsWithTriggerContextId() {
489         testFeatureFlag(
490                 "MEASUREMENT_ENABLE_UNBOUNDED_REPORTS_WITH_TRIGGER_CONTEXT_ID",
491                 Flags::getMeasurementEnableUnboundedReportsWithTriggerContextId);
492     }
493 
494     @Test
testGetMeasurementEnableTriggerDebugSignal()495     public void testGetMeasurementEnableTriggerDebugSignal() {
496         testFeatureFlag(
497                 "MEASUREMENT_ENABLE_TRIGGER_DEBUG_SIGNAL",
498                 Flags::getMeasurementEnableTriggerDebugSignal);
499     }
500 
501     @Test
testGetMeasurementEnableEventTriggerDebugSignalForCoarseDestination()502     public void testGetMeasurementEnableEventTriggerDebugSignalForCoarseDestination() {
503         testFeatureFlag(
504                 "MEASUREMENT_ENABLE_EVENT_TRIGGER_DEBUG_SIGNAL_FOR_COARSE_DESTINATION",
505                 Flags::getMeasurementEnableEventTriggerDebugSignalForCoarseDestination);
506     }
507 
508     @Test
testGetMeasurementTriggerDebugProbabilityForFakeReports()509     public void testGetMeasurementTriggerDebugProbabilityForFakeReports() {
510         testFloatFlag(
511                 "getMeasurementTriggerDebugSignalProbabilityForFakeReports",
512                 MEASUREMENT_TRIGGER_DEBUG_SIGNAL_PROBABILITY_FOR_FAKE_REPORTS,
513                 Flags::getMeasurementTriggerDebugSignalProbabilityForFakeReports);
514     }
515 
516     @Test
testGetEnableBackCompatInit()517     public void testGetEnableBackCompatInit() {
518         testFeatureFlag("DEFAULT_ENABLE_BACK_COMPAT_INIT", Flags::getEnableBackCompatInit);
519     }
520 
521     @Test
testGetMsmtEnableSeparateReportTypes()522     public void testGetMsmtEnableSeparateReportTypes() {
523         testFeatureFlag(
524                 "MEASUREMENT_ENABLE_SEPARATE_DEBUG_REPORT_TYPES_FOR_ATTRIBUTION_RATE_LIMIT",
525                 Flags::getMeasurementEnableSeparateDebugReportTypesForAttributionRateLimit);
526     }
527 
528     @Test
testGetMeasurementEnableReinstallReattribution()529     public void testGetMeasurementEnableReinstallReattribution() {
530         testFeatureFlag(
531                 "MEASUREMENT_ENABLE_REINSTALL_REATTRIBUTION",
532                 Flags::getMeasurementEnableReinstallReattribution);
533     }
534 
535     @Test
testGetMeasurementEnableMinReportLifespanForUninstall()536     public void testGetMeasurementEnableMinReportLifespanForUninstall() {
537         testFeatureFlag(
538                 "MEASUREMENT_ENABLE_MIN_REPORT_LIFESPAN_FOR_UNINSTALL",
539                 Flags::getMeasurementEnableMinReportLifespanForUninstall);
540     }
541 
542     @Test
testGetMeasurementEnableInstallAttributionOnS()543     public void testGetMeasurementEnableInstallAttributionOnS() {
544         testFeatureFlag(
545                 "MEASUREMENT_ENABLE_INSTALL_ATTRIBUTION_ON_S",
546                 Flags::getMeasurementEnableInstallAttributionOnS);
547     }
548 
549     @Test
testGetMeasurementEnableDestinationLimitPriority()550     public void testGetMeasurementEnableDestinationLimitPriority() {
551         testFeatureFlag(
552                 "MEASUREMENT_ENABLE_DESTINATION_LIMIT_PRIORITY",
553                 Flags::getMeasurementEnableSourceDestinationLimitPriority);
554     }
555 
556     @Test
testGetMeasurementEnableDestinationPerDayRateLimitWindow()557     public void testGetMeasurementEnableDestinationPerDayRateLimitWindow() {
558         testFeatureFlag(
559                 "MEASUREMENT_ENABLE_DESTINATION_PER_DAY_RATE_LIMIT_WINDOW",
560                 Flags::getMeasurementEnableDestinationPerDayRateLimitWindow);
561     }
562 
563     @Test
testGetMeasurementEnableSourceDestinationLimitAlgorithmField()564     public void testGetMeasurementEnableSourceDestinationLimitAlgorithmField() {
565         testFeatureFlag(
566                 "MEASUREMENT_ENABLE_DESTINATION_LIMIT_ALGORITHM_FIELD",
567                 Flags::getMeasurementEnableSourceDestinationLimitAlgorithmField);
568     }
569 
570     @Test
testGetMeasurementEnableEventLevelEpsilonInSource()571     public void testGetMeasurementEnableEventLevelEpsilonInSource() {
572         testFeatureFlag(
573                 "MEASUREMENT_ENABLE_EVENT_LEVEL_EPSILON_IN_SOURCE",
574                 Flags::getMeasurementEnableEventLevelEpsilonInSource);
575     }
576 
577     @Test
testGetMeasurementEnableAggregateValueFilters()578     public void testGetMeasurementEnableAggregateValueFilters() {
579         testFeatureFlag(
580                 "MEASUREMENT_ENABLE_AGGREGATE_VALUE_FILTERS",
581                 Flags::getMeasurementEnableAggregateValueFilters);
582     }
583 
584     @Test
testGetMeasurementEnableAggregatableNamedBudgets()585     public void testGetMeasurementEnableAggregatableNamedBudgets() {
586         testFeatureFlag(
587                 "MEASUREMENT_ENABLE_AGGREGATABLE_NAMED_BUDGETS",
588                 Flags::getMeasurementEnableAggregatableNamedBudgets);
589     }
590 
591     @Test
testGetMeasurementEnableV1SourceTriggerData()592     public void testGetMeasurementEnableV1SourceTriggerData() {
593         testFeatureFlag(
594                 "MEASUREMENT_ENABLE_V1_SOURCE_TRIGGER_DATA",
595                 Flags::getMeasurementEnableV1SourceTriggerData);
596     }
597 
598     @Test
testGetCustomErrorCodeSamplingEnabled()599     public void testGetCustomErrorCodeSamplingEnabled() {
600         testFeatureFlag(
601                 "DEFAULT_CUSTOM_ERROR_CODE_SAMPLING_ENABLED",
602                 Flags::getCustomErrorCodeSamplingEnabled);
603     }
604 
605     @Test
testGetSpeOnPilotJobsBatch2Enabled()606     public void testGetSpeOnPilotJobsBatch2Enabled() {
607         testFeatureFlag(
608                 "DEFAULT_SPE_ON_PILOT_JOBS_BATCH_2_ENABLED", Flags::getSpeOnPilotJobsBatch2Enabled);
609     }
610 
611     @Test
testGetSpeOnEpochJobEnabled()612     public void testGetSpeOnEpochJobEnabled() {
613         testFeatureFlag("DEFAULT_SPE_ON_EPOCH_JOB_ENABLED", Flags::getSpeOnEpochJobEnabled);
614     }
615 
616     @Test
testGetSpeOnBackgroundFetchJobEnabled()617     public void testGetSpeOnBackgroundFetchJobEnabled() {
618         testFeatureFlag(
619                 "DEFAULT_SPE_ON_BACKGROUND_FETCH_JOB_ENABLED",
620                 Flags::getSpeOnBackgroundFetchJobEnabled);
621     }
622 
623     @Test
testGetSpeOnAsyncRegistrationFallbackJobEnabled()624     public void testGetSpeOnAsyncRegistrationFallbackJobEnabled() {
625         testFeatureFlag(
626                 "DEFAULT_SPE_ON_ASYNC_REGISTRATION_FALLBACK_JOB_ENABLED",
627                 Flags::getSpeOnAsyncRegistrationFallbackJobEnabled);
628     }
629 
630     @Test
testGetMeasurementReportingJobServiceEnabled()631     public void testGetMeasurementReportingJobServiceEnabled() {
632         testFeatureFlag(
633                 "MEASUREMENT_REPORTING_JOB_ENABLED",
634                 Flags::getMeasurementReportingJobServiceEnabled);
635     }
636 
637     @Test
testGetMddEnrollmentManifestFileUrl()638     public void testGetMddEnrollmentManifestFileUrl() {
639         testFlag("getMddEnrollmentManifestFileUrl()", "", Flags::getMddEnrollmentManifestFileUrl);
640     }
641 
642     @Test
testGetEnrollmentProtoFileEnabled()643     public void testGetEnrollmentProtoFileEnabled() {
644         testFeatureFlag(
645                 "DEFAULT_ENROLLMENT_PROTO_FILE_ENABLED", Flags::getEnrollmentProtoFileEnabled);
646     }
647 
648     @Test
testGetCobaltOperationalLoggingEnabled()649     public void testGetCobaltOperationalLoggingEnabled() {
650         testFeatureFlag(
651                 "COBALT_OPERATIONAL_LOGGING_ENABLED", Flags::getCobaltOperationalLoggingEnabled);
652     }
653 
654     @Test
testGetCobaltRegistryOutOfBandUpdateEnabled()655     public void testGetCobaltRegistryOutOfBandUpdateEnabled() {
656         testFeatureFlag(
657                 "COBALT_REGISTRY_OUT_OF_BAND_UPDATE_ENABLED",
658                 Flags::getCobaltRegistryOutOfBandUpdateEnabled);
659     }
660 
661     @Test
testGetCobaltFallBackToDefaultBaseRegistry()662     public void testGetCobaltFallBackToDefaultBaseRegistry() {
663         testFeatureFlag(
664                 "COBALT__FALL_BACK_TO_DEFAULT_BASE_REGISTRY",
665                 Flags::getCobaltFallBackToDefaultBaseRegistry);
666     }
667 
668     @Test
testGetCobaltEnableApiCallResponseLogging()669     public void testGetCobaltEnableApiCallResponseLogging() {
670         testFeatureFlag(
671                 "COBALT__ENABLE_API_CALL_RESPONSE_LOGGING",
672                 Flags::getCobaltEnableApiCallResponseLogging);
673     }
674 
675     @Test
testGetRNotificationDefaultConsentFixEnabled()676     public void testGetRNotificationDefaultConsentFixEnabled() {
677         testFeatureFlag(
678                 "DEFAULT_R_NOTIFICATION_DEFAULT_CONSENT_FIX_ENABLED",
679                 Flags::getRNotificationDefaultConsentFixEnabled);
680     }
681 
682     @Test
testTopicsJobSchedulerRescheduleEnabled()683     public void testTopicsJobSchedulerRescheduleEnabled() {
684         testFeatureFlag(
685                 "TOPICS_JOB_SCHEDULER_RESCHEDULE_ENABLED",
686                 Flags::getTopicsJobSchedulerRescheduleEnabled);
687     }
688 
689     @Test
testTopicsEpochJobBatteryNotLowInsteadOfCharging()690     public void testTopicsEpochJobBatteryNotLowInsteadOfCharging() {
691         testFlag(
692                 "TOPICS_EPOCH_JOB_BATTERY_NOT_LOW_INSTEAD_OF_CHARGING",
693                 /* defaultValue */ false,
694                 Flags::getTopicsEpochJobBatteryNotLowInsteadOfCharging);
695     }
696 
697     @Test
testGetTopicsEpochJobBatteryConstraintLoggingEnabled()698     public void testGetTopicsEpochJobBatteryConstraintLoggingEnabled() {
699         testFlag(
700                 "TOPICS_EPOCH_JOB_BATTERY_CONSTRAINT_LOGGING_ENABLED",
701                 /* defaultValue */ false,
702                 Flags::getTopicsEpochJobBatteryConstraintLoggingEnabled);
703     }
704 
705     @Test
testGetTopicsCleanDBWhenEpochJobSettingsChanged()706     public void testGetTopicsCleanDBWhenEpochJobSettingsChanged() {
707         testFlag(
708                 "TOPICS_CLEAN_DB_WHEN_EPOCH_JOB_SETTINGS_CHANGED",
709                 /* defaultValue */ false,
710                 Flags::getTopicsCleanDBWhenEpochJobSettingsChanged);
711     }
712 
713     @Test
testGetFledgeEnableForcedEncodingAfterSignalsUpdate()714     public void testGetFledgeEnableForcedEncodingAfterSignalsUpdate() {
715         testFeatureFlag(
716                 "FLEDGE_ENABLE_FORCED_ENCODING_AFTER_SIGNALS_UPDATE",
717                 Flags::getFledgeEnableForcedEncodingAfterSignalsUpdate);
718     }
719 
720     @Test
testGetEnableRbAtrace()721     public void testGetEnableRbAtrace() {
722         testFlag("DEFAULT_ENABLE_RB_ATRACE", /* defaultValue */ false, Flags::getEnableRbAtrace);
723     }
724 
725     @Test
testGetProtectedSignalsEnablePrioritizedEviction()726     public void testGetProtectedSignalsEnablePrioritizedEviction() {
727         testFeatureFlag(
728                 "PROTECTED_SIGNALS_ENABLE_PRIORITIZED_EVICTION",
729                 Flags::getProtectedSignalsEnablePrioritizedEviction);
730     }
731 
732     ////////////////////////////////////////////////////////////////////////////////////////////////
733     // Tests for (legacy) kill-switch flags that will be refactored as feature flag - they should //
734     // move to the block above once refactored.                                                   //
735     ////////////////////////////////////////////////////////////////////////////////////////////////
736 
737     @Test
testGetMeasurementApiDeleteRegistrationsKillSwitch()738     public void testGetMeasurementApiDeleteRegistrationsKillSwitch() {
739         testLegacyMsmtKillSwitchGuardedByMsmtKillSwitch(
740                 "getMeasurementApiDeleteRegistrationsKillSwitch()",
741                 "MEASUREMENT_API_DELETE_REGISTRATIONS_KILL_SWITCH",
742                 Flags::getMeasurementApiDeleteRegistrationsKillSwitch);
743     }
744 
745     // TODO(b/325074749) - remove once all flags have been converted
746 
747     /**
748      * @deprecated - flags that are converted should call some method like {@code
749      *     testFeatureFlagGuardedByMsmtFeatureFlag} instead.
750      */
751     @Deprecated
752     @SuppressWarnings("UnusedMethod") // will be used as more kill switches are refactored
testLegacyMsmtKillSwitchGuardedByMsmtKillSwitch( String getterName, String killSwitchName, Flaginator<Flags, Boolean> flaginator)753     private void testLegacyMsmtKillSwitchGuardedByMsmtKillSwitch(
754             String getterName, String killSwitchName, Flaginator<Flags, Boolean> flaginator) {
755         boolean defaultKillSwitchValue = getConstantValue(killSwitchName);
756 
757         // Getter
758         expect.withMessage("%s when global kill_switch is on", getterName)
759                 .that(flaginator.getFlagValue(mGlobalKsOnFlags))
760                 .isTrue();
761         expect.withMessage("%s when msmt_enabled is true", getterName)
762                 .that(flaginator.getFlagValue(mMsmtEnabledFlags))
763                 .isEqualTo(defaultKillSwitchValue);
764         expect.withMessage("%s when msmt enabled is false", getterName)
765                 .that(flaginator.getFlagValue(mMsmtDisabledFlags))
766                 .isFalse();
767 
768         // TODO(b/325074749): remove 2 checks below once Flags.getLegacyMeasurementKillSwitch() is
769         // gone
770         expect.withMessage("%s when msmt kill_switch is on", getterName)
771                 .that(flaginator.getFlagValue(mMsmtKsOnFlags))
772                 .isTrue();
773         expect.withMessage("%s when msmt kill_switch is off", getterName)
774                 .that(flaginator.getFlagValue(mMsmtKsOffFlags))
775                 .isEqualTo(defaultKillSwitchValue);
776 
777         // Constant
778         expect.withMessage("%s", killSwitchName).that(defaultKillSwitchValue).isFalse();
779     }
780 
781     @Test
testGetPasExtendedMetricsEnabled()782     public void testGetPasExtendedMetricsEnabled() {
783         testFeatureFlag("PAS_EXTENDED_METRICS_ENABLED", Flags::getPasExtendedMetricsEnabled);
784     }
785 
786     @Test
testGetPasProductMetricsV1Enabled()787     public void testGetPasProductMetricsV1Enabled() {
788         testFeatureFlag("PAS_PRODUCT_METRICS_V1_ENABLED", Flags::getPasProductMetricsV1Enabled);
789     }
790 
791     @Test
testGetMeasurementAttributionFallbackJobEnabled()792     public void testGetMeasurementAttributionFallbackJobEnabled() {
793         testMsmtFeatureFlagBackedByLegacyKillSwitchAndGuardedByMsmtEnabled(
794                 "getMeasurementAttributionFallbackJobEnabled()",
795                 "MEASUREMENT_ATTRIBUTION_FALLBACK_JOB_KILL_SWITCH",
796                 flag -> flag.getMeasurementAttributionFallbackJobEnabled());
797     }
798 
799     ////////////////////////////////////////////////////////////////////////////////////////////////
800     // Tests for feature flags that already launched - they will eventually be removed (once the  //
801     // underlying getter is removed).                                                             //
802     ////////////////////////////////////////////////////////////////////////////////////////////////
803 
804     // NOTE: there isn't any such flag currently, so commented code below is shown as an example
805     // @Test
806     // public void testGetAppConfigReturnsEnabledByDefault() {
807     //     testRetiredFeatureFlag(
808     //             "APP_CONFIG_RETURNS_ENABLED_BY_DEFAULT",
809     //             Flags::getAppConfigReturnsEnabledByDefault);
810     // }
811 
812     ////////////////////////////////////////////////////////////////////////////////////////////////
813     // Tests for "config" flags (not feature flag / kill switch).                                 //
814     ////////////////////////////////////////////////////////////////////////////////////////////////
815     @Test
testGetTopicsEpochJobFlexMs()816     public void testGetTopicsEpochJobFlexMs() {
817         testFlag(
818                 "getTopicsEpochJobFlexMs()",
819                 TOPICS_EPOCH_JOB_FLEX_MS,
820                 Flags::getTopicsEpochJobFlexMs);
821     }
822 
823     @Test
testGetMeasurementDefaultDestinationLimitAlgorithm()824     public void testGetMeasurementDefaultDestinationLimitAlgorithm() {
825         testFlag(
826                 "getMeasurementDefaultSourceDestinationLimitAlgorithm()",
827                 MEASUREMENT_DEFAULT_DESTINATION_LIMIT_ALGORITHM,
828                 Flags::getMeasurementDefaultSourceDestinationLimitAlgorithm);
829     }
830 
831     @Test
testGetMeasurementDestinationRateLimitWindow()832     public void testGetMeasurementDestinationRateLimitWindow() {
833         testFlag(
834                 "getMeasurementDestinationRateLimitWindow()",
835                 MEASUREMENT_DESTINATION_RATE_LIMIT_WINDOW,
836                 Flags::getMeasurementDestinationRateLimitWindow);
837     }
838 
839     @Test
testGetMeasurementDestinationPerDayRateLimitWindowInMs()840     public void testGetMeasurementDestinationPerDayRateLimitWindowInMs() {
841         testFlag(
842                 "getMeasurementDestinationPerDayRateLimitWindowInMs()",
843                 MEASUREMENT_DESTINATION_PER_DAY_RATE_LIMIT_WINDOW_IN_MS,
844                 Flags::getMeasurementDestinationPerDayRateLimitWindowInMs);
845     }
846 
847     @Test
testGetMeasurementDestinationPerDayRateLimit()848     public void testGetMeasurementDestinationPerDayRateLimit() {
849         testFlag(
850                 "getMeasurementDestinationPerDayRateLimit()",
851                 MEASUREMENT_DESTINATION_PER_DAY_RATE_LIMIT,
852                 Flags::getMeasurementDestinationPerDayRateLimit);
853     }
854 
855     @Test
testGetJobSchedulingLoggingSamplingRate()856     public void testGetJobSchedulingLoggingSamplingRate() {
857         testFlag(
858                 "getJobSchedulingLoggingSamplingRate()",
859                 DEFAULT_JOB_SCHEDULING_LOGGING_SAMPLING_RATE,
860                 Flags::getJobSchedulingLoggingSamplingRate);
861     }
862 
863     @Test
testGetPasScriptDownloadReadTimeoutMs()864     public void testGetPasScriptDownloadReadTimeoutMs() {
865         testFlag(
866                 "getPasScriptDownloadReadTimeoutMs()",
867                 DEFAULT_PAS_SCRIPT_DOWNLOAD_READ_TIMEOUT_MS,
868                 Flags::getPasScriptDownloadReadTimeoutMs);
869     }
870 
871     @Test
testGetPasScriptDownloadConnectionTimeoutMs()872     public void testGetPasScriptDownloadConnectionTimeoutMs() {
873         testFlag(
874                 "getPasScriptDownloadConnectionTimeoutMs()",
875                 DEFAULT_PAS_SCRIPT_DOWNLOAD_CONNECTION_TIMEOUT_MS,
876                 Flags::getPasScriptDownloadConnectionTimeoutMs);
877     }
878 
879     @Test
testGetPasSignalsDownloadReadTimeoutMs()880     public void testGetPasSignalsDownloadReadTimeoutMs() {
881         testFlag(
882                 "getPasSignalsDownloadReadTimeoutMs()",
883                 DEFAULT_PAS_SIGNALS_DOWNLOAD_READ_TIMEOUT_MS,
884                 Flags::getPasSignalsDownloadReadTimeoutMs);
885     }
886 
887     @Test
testGetPasSignalsDownloadConnectionTimeoutMs()888     public void testGetPasSignalsDownloadConnectionTimeoutMs() {
889         testFlag(
890                 "getPasSignalsDownloadConnectionTimeoutMs()",
891                 DEFAULT_PAS_SIGNALS_DOWNLOAD_CONNECTION_TIMEOUT_MS,
892                 Flags::getPasSignalsDownloadConnectionTimeoutMs);
893     }
894 
895     @Test
testGetPasScriptExecutionTimeoutMs()896     public void testGetPasScriptExecutionTimeoutMs() {
897         testFlag(
898                 "getPasScriptExecutionTimeoutMs()",
899                 DEFAULT_PAS_SCRIPT_EXECUTION_TIMEOUT_MS,
900                 Flags::getPasScriptExecutionTimeoutMs);
901     }
902 
903     @Test
testGetAdServicesApiV2MigrationEnabled()904     public void testGetAdServicesApiV2MigrationEnabled() {
905         testFeatureFlag(
906                 "DEFAULT_ADSERVICES_CONSENT_BUSINESS_LOGIC_MIGRATION_ENABLED",
907                 Flags::getAdServicesConsentBusinessLogicMigrationEnabled);
908     }
909 
910     @Test
testGetMeasurementMaxReinstallReattributionWindowSeconds()911     public void testGetMeasurementMaxReinstallReattributionWindowSeconds() {
912         testFlag(
913                 "getMeasurementMaxReinstallReattributionWindowSeconds",
914                 MEASUREMENT_MAX_REINSTALL_REATTRIBUTION_WINDOW_SECONDS,
915                 Flags::getMeasurementMaxReinstallReattributionWindowSeconds);
916     }
917 
918     @Test
testGetMeasurementMinReportLifespanForUninstallSeconds()919     public void testGetMeasurementMinReportLifespanForUninstallSeconds() {
920         testFlag(
921                 "getMeasurementMinReportLifespanForUninstallSeconds",
922                 MEASUREMENT_MIN_REPORT_LIFESPAN_FOR_UNINSTALL_SECONDS,
923                 Flags::getMeasurementMinReportLifespanForUninstallSeconds);
924     }
925 
926     @Test
testGetMeasurementReportingJobRequiredBatteryNotLow()927     public void testGetMeasurementReportingJobRequiredBatteryNotLow() {
928         testFlag(
929                 "getMeasurementReportingJobRequiredBatteryNotLow",
930                 MEASUREMENT_REPORTING_JOB_REQUIRED_BATTERY_NOT_LOW,
931                 Flags::getMeasurementReportingJobRequiredBatteryNotLow);
932     }
933 
934     @Test
testGetMeasurementReportingJobRequiredNetworkType()935     public void testGetMeasurementReportingJobRequiredNetworkType() {
936         testFlag(
937                 "getMeasurementReportingJobRequiredNetworkType",
938                 MEASUREMENT_REPORTING_JOB_REQUIRED_NETWORK_TYPE,
939                 Flags::getMeasurementReportingJobRequiredNetworkType);
940     }
941 
942     @Test
testGetMeasurementReportingJobPersisted()943     public void testGetMeasurementReportingJobPersisted() {
944         testFlag(
945                 "getMeasurementReportingJobPersisted",
946                 MEASUREMENT_REPORTING_JOB_PERSISTED,
947                 Flags::getMeasurementReportingJobPersisted);
948     }
949 
950     @Test
testGetMeasurementReportingJobServiceBatchWindowMillis()951     public void testGetMeasurementReportingJobServiceBatchWindowMillis() {
952         testFlag(
953                 "getMeasurementReportingJobServiceBatchWindowMillis",
954                 MEASUREMENT_REPORTING_JOB_SERVICE_BATCH_WINDOW_MILLIS,
955                 Flags::getMeasurementReportingJobServiceBatchWindowMillis);
956     }
957 
958     @Test
testGetMeasurementReportingJobServiceMinExecutionWindowMillis()959     public void testGetMeasurementReportingJobServiceMinExecutionWindowMillis() {
960         testFlag(
961                 "getMeasurementReportingJobServiceMinExecutionWindowMillis",
962                 MEASUREMENT_REPORTING_JOB_SERVICE_MIN_EXECUTION_WINDOW_MILLIS,
963                 Flags::getMeasurementReportingJobServiceMinExecutionWindowMillis);
964     }
965 
966     @Test
testGetMeasurementAttributionScopeMaxInfoGainNavigation()967     public void testGetMeasurementAttributionScopeMaxInfoGainNavigation() {
968         testFloatFlag(
969                 "getMeasurementAttributionScopeMaxInfoGainNavigation",
970                 MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_NAVIGATION,
971                 Flags::getMeasurementAttributionScopeMaxInfoGainNavigation);
972     }
973 
974     @Test
testGetMeasurementAttributionScopeMaxInfoGainDualDestinationNavigation()975     public void testGetMeasurementAttributionScopeMaxInfoGainDualDestinationNavigation() {
976         testFloatFlag(
977                 "getMeasurementAttributionScopeMaxInfoGainDualDestinationNavigation",
978                 MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_DUAL_DESTINATION_NAVIGATION,
979                 Flags::getMeasurementAttributionScopeMaxInfoGainDualDestinationNavigation);
980     }
981 
982     @Test
testGetMeasurementAttributionScopeMaxInfoGainEvent()983     public void testGetMeasurementAttributionScopeMaxInfoGainEvent() {
984         testFloatFlag(
985                 "getMeasurementAttributionScopeMaxInfoGainEvent",
986                 MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_EVENT,
987                 Flags::getMeasurementAttributionScopeMaxInfoGainEvent);
988     }
989 
990     @Test
testGetMeasurementAttributionScopeMaxInfoGainDualDestinationEvent()991     public void testGetMeasurementAttributionScopeMaxInfoGainDualDestinationEvent() {
992         testFloatFlag(
993                 "getMeasurementAttributionScopeMaxInfoGainDualDestinationEvent",
994                 MEASUREMENT_ATTRIBUTION_SCOPE_MAX_INFO_GAIN_DUAL_DESTINATION_EVENT,
995                 Flags::getMeasurementAttributionScopeMaxInfoGainDualDestinationEvent);
996     }
997 
998     @Test
testGetMeasurementAttributionJobTriggeringMaxDelayMs()999     public void testGetMeasurementAttributionJobTriggeringMaxDelayMs() {
1000         testFlag(
1001                 "getMeasurementAttributionJobTriggeringMaxDelayMs",
1002                 MEASUREMENT_ATTRIBUTION_JOB_TRIGGERING_MAX_DELAY_MS,
1003                 Flags::getMeasurementAttributionJobTriggeringMaxDelayMs);
1004     }
1005 
1006     @Test
testGetMeasurementEnableFakeReportTriggerTime()1007     public void testGetMeasurementEnableFakeReportTriggerTime() {
1008         testFeatureFlag(
1009                 "MEASUREMENT_ENABLE_FAKE_REPORT_TRIGGER_TIME",
1010                 Flags::getMeasurementEnableFakeReportTriggerTime);
1011     }
1012 
1013     @Test
testGetMeasurementDefaultFilteringIdMaxBytes()1014     public void testGetMeasurementDefaultFilteringIdMaxBytes() {
1015         testFlag(
1016                 "getMeasurementDefaultFilteringIdMaxBytes",
1017                 MEASUREMENT_DEFAULT_FILTERING_ID_MAX_BYTES,
1018                 Flags::getMeasurementDefaultFilteringIdMaxBytes);
1019     }
1020 
1021     @Test
testGetMeasurementValidFilteringIdMaxBytes()1022     public void testGetMeasurementValidFilteringIdMaxBytes() {
1023         testFlag(
1024                 "getMeasurementValidFilteringIdMaxBytes",
1025                 MEASUREMENT_MAX_FILTERING_ID_MAX_BYTES,
1026                 Flags::getMeasurementMaxFilteringIdMaxBytes);
1027     }
1028 
1029     @Test
testGetMeasurementEnableFlexibleContributionFiltering()1030     public void testGetMeasurementEnableFlexibleContributionFiltering() {
1031         testFeatureFlag(
1032                 "MEASUREMENT_ENABLE_FLEXIBLE_CONTRIBUTION_FILTERING",
1033                 Flags::getMeasurementEnableFlexibleContributionFiltering);
1034     }
1035 
1036     @Test
testGetMeasurementEnableAggregateDebugReporting()1037     public void testGetMeasurementEnableAggregateDebugReporting() {
1038         testFeatureFlag(
1039                 "MEASUREMENT_ENABLE_AGGREGATE_DEBUG_REPORTING",
1040                 Flags::getMeasurementEnableAggregateDebugReporting);
1041     }
1042 
1043     @Test
testGetMeasurementEnableBothSideDebugKeysInReports()1044     public void testGetMeasurementEnableBothSideDebugKeysInReports() {
1045         testFeatureFlag(
1046                 "MEASUREMENT_ENABLE_BOTH_SIDE_DEBUG_KEYS_IN_REPORTS",
1047                 Flags::getMeasurementEnableBothSideDebugKeysInReports);
1048     }
1049 
1050     @Test
testGetFledgeGetAdSelectionDataBuyerInputCreatorVersion()1051     public void testGetFledgeGetAdSelectionDataBuyerInputCreatorVersion() {
1052         testFlag(
1053                 "getFledgeGetAdSelectionDataBuyerInputCreatorVersion",
1054                 FLEDGE_GET_AD_SELECTION_DATA_BUYER_INPUT_CREATOR_VERSION,
1055                 Flags::getFledgeGetAdSelectionDataBuyerInputCreatorVersion);
1056     }
1057 
1058     @Test
testGetFledgeGetAdSelectionDataBuyerInputMaxNumEntirePayloadCompressions()1059     public void testGetFledgeGetAdSelectionDataBuyerInputMaxNumEntirePayloadCompressions() {
1060         testFlag(
1061                 "getFledgeGetAdSelectionDataMaxNumEntirePayloadCompressions",
1062                 FLEDGE_GET_AD_SELECTION_DATA_MAX_NUM_ENTIRE_PAYLOAD_COMPRESSIONS,
1063                 Flags::getFledgeGetAdSelectionDataMaxNumEntirePayloadCompressions);
1064     }
1065 
1066     @Test
testGetFledgeGetAdSelectionDataDeserializeOnlyAdRenderIds()1067     public void testGetFledgeGetAdSelectionDataDeserializeOnlyAdRenderIds() {
1068         testFlag(
1069                 "getFledgeGetAdSelectionDataDeserializeOnlyAdRenderIds",
1070                 FLEDGE_GET_AD_SELECTION_DATA_DESERIALIZE_ONLY_AD_RENDER_IDS,
1071                 Flags::getFledgeGetAdSelectionDataDeserializeOnlyAdRenderIds);
1072     }
1073 
1074     @Test
testGetPasEncodingJobImprovementsEnabled()1075     public void testGetPasEncodingJobImprovementsEnabled() {
1076         testFeatureFlag(
1077                 "PAS_ENCODING_JOB_IMPROVEMENTS_ENABLED",
1078                 Flags::getPasEncodingJobImprovementsEnabled);
1079     }
1080 
1081     @Test
testGetCobaltIgnoredReportIdList()1082     public void testGetCobaltIgnoredReportIdList() {
1083         testFlag(
1084                 "getCobaltIgnoredReportIdList",
1085                 COBALT__IGNORED_REPORT_ID_LIST,
1086                 Flags::getCobaltIgnoredReportIdList);
1087     }
1088 
1089     @Test
testGetMddPackageDenyRegistryManifestFileUrl()1090     public void testGetMddPackageDenyRegistryManifestFileUrl() {
1091         testFlag(
1092                 "getMddPackageDenyRegistryManifestFileUrl()",
1093                 DEFAULT_MDD_PACKAGE_DENY_REGISTRY_MANIFEST_FILE_URL,
1094                 Flags::getMddPackageDenyRegistryManifestFileUrl);
1095     }
1096 
1097     @Test
testGetMeasurementAdrBudgetOriginXPublisherXWindow()1098     public void testGetMeasurementAdrBudgetOriginXPublisherXWindow() {
1099         testFlag(
1100                 "getMeasurementAdrBudgetOriginXPublisherXWindow",
1101                 MEASUREMENT_ADR_BUDGET_PER_ORIGIN_PUBLISHER_WINDOW,
1102                 Flags::getMeasurementAdrBudgetOriginXPublisherXWindow);
1103     }
1104 
1105     @Test
testGetMeasurementAdrBudgetPublisherXWindow()1106     public void testGetMeasurementAdrBudgetPublisherXWindow() {
1107         testFlag(
1108                 "getMeasurementAdrBudgetPublisherXWindow",
1109                 MEASUREMENT_ADR_BUDGET_PER_PUBLISHER_WINDOW,
1110                 Flags::getMeasurementAdrBudgetPublisherXWindow);
1111     }
1112 
1113     @Test
testGetMeasurementAdrBudgetWindowLengthMillis()1114     public void testGetMeasurementAdrBudgetWindowLengthMillis() {
1115         testFlag(
1116                 "getMeasurementAdrBudgetWindowLengthMillis",
1117                 MEASUREMENT_ADR_BUDGET_WINDOW_LENGTH_MILLIS,
1118                 Flags::getMeasurementAdrBudgetWindowLengthMillis);
1119     }
1120 
1121     @Test
testGetMeasurementMaxAdrCountPerSource()1122     public void testGetMeasurementMaxAdrCountPerSource() {
1123         testFlag(
1124                 "getMeasurementMaxAdrCountPerSource",
1125                 MEASUREMENT_MAX_ADR_COUNT_PER_SOURCE,
1126                 Flags::getMeasurementMaxAdrCountPerSource);
1127     }
1128 
1129     @Test
testGetMeasurementEnablePackageNameUidCheck()1130     public void testGetMeasurementEnablePackageNameUidCheck() {
1131         testFlag(
1132                 "getMeasurementEnablePackageNameUidCheck",
1133                 DEFAULT_MEASUREMENT_ENABLE_PACKAGE_NAME_UID_CHECK,
1134                 Flags::getMeasurementEnablePackageNameUidCheck);
1135     }
1136 
1137     @Test
testGetMeasurementEnableAdIdsPerDevicePerWindow()1138     public void testGetMeasurementEnableAdIdsPerDevicePerWindow() {
1139         testFlag(
1140                 "getMeasurementEnableAdIdsPerDevicePerWindow",
1141                 DEFAULT_MEASUREMENT_ENABLE_AD_IDS_PER_DEVICE_PER_WINDOW,
1142                 Flags::getMeasurementEnableAdIdsPerDevicePerWindow);
1143     }
1144 
1145     @Test
testMeasurementAdIdsPerDevicePerWindowPeriodMs()1146     public void testMeasurementAdIdsPerDevicePerWindowPeriodMs() {
1147         testFlag(
1148                 "getMeasurementAdIdsPerDevicePerWindowPeriodMs",
1149                 DEFAULT_MEASUREMENT_AD_IDS_PER_DEVICE_PER_WINDOW_PERIOD_MS,
1150                 Flags::getMeasurementAdIdsPerDevicePerWindowPeriodMs);
1151     }
1152 
1153     @Test
testGetMeasurementEnableCountUniqueService()1154     public void testGetMeasurementEnableCountUniqueService() {
1155         testFlag(
1156                 "getMeasurementEnableCountUniqueService",
1157                 DEFAULT_MEASUREMENT_ENABLE_COUNT_UNIQUE_SERVICE,
1158                 Flags::getMeasurementEnableCountUniqueService);
1159     }
1160 
1161     @Test
testGetMeasurementEnableCountUniqueReportingJob()1162     public void testGetMeasurementEnableCountUniqueReportingJob() {
1163         testFlag(
1164                 "getMeasurementEnableCountUniqueReportingJob",
1165                 DEFAULT_MEASUREMENT_ENABLE_COUNT_UNIQUE_REPORTING_JOB,
1166                 Flags::getMeasurementEnableCountUniqueReportingJob);
1167     }
1168 
1169     @Test
testGetMeasurementCountUniqueReportingJobPeriodMs()1170     public void testGetMeasurementCountUniqueReportingJobPeriodMs() {
1171         testFlag(
1172                 "getMeasurementCountUniqueReportingJobPeriodMs",
1173                 DEFAULT_MEASUREMENT_COUNT_UNIQUE_REPORTING_JOB_PERIOD_MS,
1174                 Flags::getMeasurementCountUniqueReportingJobPeriodMs);
1175     }
1176 
1177     @Test
testGetMeasurementCountUniqueAppAllowlist()1178     public void testGetMeasurementCountUniqueAppAllowlist() {
1179         testFlag(
1180                 "getMeasurementCountUniqueAppAllowlist",
1181                 DEFAULT_MEASUREMENT_COUNT_UNIQUE_APP_ALLOWLIST,
1182                 Flags::getMeasurementCountUniqueAppAllowlist);
1183     }
1184 
1185     @Test
testGetMeasurementCountUniqueAppSignatureAllowlist()1186     public void testGetMeasurementCountUniqueAppSignatureAllowlist() {
1187         testFlag(
1188                 "getMeasurementCountUniqueAppSignatureAllowlist",
1189                 DEFAULT_MEASUREMENT_COUNT_UNIQUE_APP_SIGNATURE_ALLOWLIST,
1190                 Flags::getMeasurementCountUniqueAppSignatureAllowlist);
1191     }
1192 
1193     @Test
testGetFledgeEnableScheduleCustomAudienceUpdateAdditionalScheduleRequests()1194     public void testGetFledgeEnableScheduleCustomAudienceUpdateAdditionalScheduleRequests() {
1195         testFeatureFlag(
1196                 "FLEDGE_ENABLE_SCHEDULE_CUSTOM_AUDIENCE_UPDATE_ADDITIONAL_SCHEDULE_REQUESTS",
1197                 Flags::getFledgeEnableScheduleCustomAudienceUpdateAdditionalScheduleRequests);
1198     }
1199 
1200     @Test
testGetFledgeScheduleCustomAudienceUpdateMaxBytes()1201     public void testGetFledgeScheduleCustomAudienceUpdateMaxBytes() {
1202         testFlag(
1203                 "getFledgeScheduleCustomAudienceUpdateMaxBytes()",
1204                 FLEDGE_SCHEDULE_CUSTOM_AUDIENCE_UPDATE_MAX_BYTES,
1205                 Flags::getFledgeScheduleCustomAudienceUpdateMaxBytes);
1206     }
1207 
1208     @Test
testGetFledgeScheduleCustomAudienceUpdateBackgroundJobRequiredNetworkType()1209     public void testGetFledgeScheduleCustomAudienceUpdateBackgroundJobRequiredNetworkType() {
1210         testFlag(
1211                 "getFledgeScheduleCustomAudienceUpdateBackgroundJobRequiredNetworkType()",
1212                 FLEDGE_SCHEDULE_CUSTOM_AUDIENCE_UPDATE_BACKGROUND_JOB_REQUIRED_NETWORK_TYPE,
1213                 Flags::getFledgeScheduleCustomAudienceUpdateBackgroundJobRequiredNetworkType);
1214     }
1215 
1216     @Test
testGetFledgeForcedEncodingAfterSignalsUpdateCooldownSeconds()1217     public void testGetFledgeForcedEncodingAfterSignalsUpdateCooldownSeconds() {
1218         testFlag(
1219                 "getFledgeForcedEncodingAfterSignalsUpdateCooldownSeconds()",
1220                 FLEDGE_FORCED_ENCODING_AFTER_SIGNALS_UPDATE_COOLDOWN_SECONDS,
1221                 Flags::getFledgeForcedEncodingAfterSignalsUpdateCooldownSeconds);
1222     }
1223 
1224     @Test
testGetFledgeJoinCustomAudienceRequestPermitsPerSecond()1225     public void testGetFledgeJoinCustomAudienceRequestPermitsPerSecond() {
1226         testFloatFlag(
1227                 "getFledgeJoinCustomAudienceRequestPermitsPerSecond()",
1228                 FLEDGE_JOIN_CUSTOM_AUDIENCE_REQUEST_PERMITS_PER_SECOND,
1229                 Flags::getFledgeJoinCustomAudienceRequestPermitsPerSecond);
1230     }
1231 
1232     @Test
testGetFledgeFetchAndJoinCustomAudienceRequestPermitsPerSecond()1233     public void testGetFledgeFetchAndJoinCustomAudienceRequestPermitsPerSecond() {
1234         testFloatFlag(
1235                 "getFledgeFetchAndJoinCustomAudienceRequestPermitsPerSecond()",
1236                 FLEDGE_FETCH_AND_JOIN_CUSTOM_AUDIENCE_REQUEST_PERMITS_PER_SECOND,
1237                 Flags::getFledgeFetchAndJoinCustomAudienceRequestPermitsPerSecond);
1238     }
1239 
1240     @Test
testGetFledgeScheduleCustomAudienceUpdateRequestPermitsPerSecond()1241     public void testGetFledgeScheduleCustomAudienceUpdateRequestPermitsPerSecond() {
1242         testFloatFlag(
1243                 "getFledgeScheduleCustomAudienceUpdateRequestPermitsPerSecond()",
1244                 FLEDGE_SCHEDULE_CUSTOM_AUDIENCE_UPDATE_REQUEST_PERMITS_PER_SECOND,
1245                 Flags::getFledgeScheduleCustomAudienceUpdateRequestPermitsPerSecond);
1246     }
1247 
1248     @Test
testGetFledgeLeaveCustomAudienceRequestPermitsPerSecond()1249     public void testGetFledgeLeaveCustomAudienceRequestPermitsPerSecond() {
1250         testFloatFlag(
1251                 "getFledgeLeaveCustomAudienceRequestPermitsPerSecond()",
1252                 FLEDGE_LEAVE_CUSTOM_AUDIENCE_REQUEST_PERMITS_PER_SECOND,
1253                 Flags::getFledgeLeaveCustomAudienceRequestPermitsPerSecond);
1254     }
1255 
1256     @Test
testGetFledgeUpdateSignalsRequestPermitsPerSecond()1257     public void testGetFledgeUpdateSignalsRequestPermitsPerSecond() {
1258         testFloatFlag(
1259                 "getFledgeUpdateSignalsRequestPermitsPerSecond()",
1260                 FLEDGE_UPDATE_SIGNALS_REQUEST_PERMITS_PER_SECOND,
1261                 Flags::getFledgeUpdateSignalsRequestPermitsPerSecond);
1262     }
1263 
1264     @Test
testGetFledgeSelectAdsRequestPermitsPerSecond()1265     public void testGetFledgeSelectAdsRequestPermitsPerSecond() {
1266         testFloatFlag(
1267                 "getFledgeSelectAdsRequestPermitsPerSecond()",
1268                 FLEDGE_SELECT_ADS_REQUEST_PERMITS_PER_SECOND,
1269                 Flags::getFledgeSelectAdsRequestPermitsPerSecond);
1270     }
1271 
1272     @Test
testGetFledgeSelectAdsWithOutcomesRequestPermitsPerSecond()1273     public void testGetFledgeSelectAdsWithOutcomesRequestPermitsPerSecond() {
1274         testFloatFlag(
1275                 "getFledgeSelectAdsWithOutcomesRequestPermitsPerSecond()",
1276                 FLEDGE_SELECT_ADS_WITH_OUTCOMES_REQUEST_PERMITS_PER_SECOND,
1277                 Flags::getFledgeSelectAdsWithOutcomesRequestPermitsPerSecond);
1278     }
1279 
1280     @Test
testGetFledgeGetAdSelectionDataRequestPermitsPerSecond()1281     public void testGetFledgeGetAdSelectionDataRequestPermitsPerSecond() {
1282         testFloatFlag(
1283                 "getFledgeGetAdSelectionDataRequestPermitsPerSecond()",
1284                 FLEDGE_GET_AD_SELECTION_DATA_REQUEST_PERMITS_PER_SECOND,
1285                 Flags::getFledgeGetAdSelectionDataRequestPermitsPerSecond);
1286     }
1287 
1288     @Test
testGetFledgePersistAdSelectionResultRequestPermitsPerSecond()1289     public void testGetFledgePersistAdSelectionResultRequestPermitsPerSecond() {
1290         testFloatFlag(
1291                 "getFledgePersistAdSelectionResultRequestPermitsPerSecond()",
1292                 FLEDGE_PERSIST_AD_SELECTION_RESULT_REQUEST_PERMITS_PER_SECOND,
1293                 Flags::getFledgePersistAdSelectionResultRequestPermitsPerSecond);
1294     }
1295 
1296     @Test
testGetFledgeReportImpressionRequestPermitsPerSecond()1297     public void testGetFledgeReportImpressionRequestPermitsPerSecond() {
1298         testFloatFlag(
1299                 "getFledgeReportImpressionRequestPermitsPerSecond()",
1300                 FLEDGE_REPORT_IMPRESSION_REQUEST_PERMITS_PER_SECOND,
1301                 Flags::getFledgeReportImpressionRequestPermitsPerSecond);
1302     }
1303 
1304     @Test
testGetFledgeReportInteractionRequestPermitsPerSecond()1305     public void testGetFledgeReportInteractionRequestPermitsPerSecond() {
1306         testFloatFlag(
1307                 "getFledgeReportInteractionRequestPermitsPerSecond()",
1308                 FLEDGE_REPORT_INTERACTION_REQUEST_PERMITS_PER_SECOND,
1309                 Flags::getFledgeReportInteractionRequestPermitsPerSecond);
1310     }
1311 
1312     @Test
testGetFledgeSetAppInstallAdvertisersRequestPermitsPerSecond()1313     public void testGetFledgeSetAppInstallAdvertisersRequestPermitsPerSecond() {
1314         testFloatFlag(
1315                 "getFledgeSetAppInstallAdvertisersRequestPermitsPerSecond()",
1316                 FLEDGE_SET_APP_INSTALL_ADVERTISERS_REQUEST_PERMITS_PER_SECOND,
1317                 Flags::getFledgeSetAppInstallAdvertisersRequestPermitsPerSecond);
1318     }
1319 
1320     @Test
testGetFledgeUpdateAdCounterHistogramRequestPermitsPerSecond()1321     public void testGetFledgeUpdateAdCounterHistogramRequestPermitsPerSecond() {
1322         testFloatFlag(
1323                 "getFledgeUpdateAdCounterHistogramRequestPermitsPerSecond()",
1324                 FLEDGE_UPDATE_AD_COUNTER_HISTOGRAM_REQUEST_PERMITS_PER_SECOND,
1325                 Flags::getFledgeUpdateAdCounterHistogramRequestPermitsPerSecond);
1326     }
1327 
1328     @Test
testGetProtectedSignalsMaxJsFailureExecutionOnCertainVersionBeforeStop()1329     public void testGetProtectedSignalsMaxJsFailureExecutionOnCertainVersionBeforeStop() {
1330         testFlag(
1331                 "getProtectedSignalsMaxJsFailureExecutionOnCertainVersionBeforeStop()",
1332                 PROTECTED_SIGNALS_MAX_JS_FAILURE_EXECUTION_ON_CERTAIN_VERSION_BEFORE_STOP,
1333                 Flags::getProtectedSignalsMaxJsFailureExecutionOnCertainVersionBeforeStop);
1334     }
1335 
1336     @Test
testGetProtectedSignalsMaxSignalSizePerBuyerBytes()1337     public void testGetProtectedSignalsMaxSignalSizePerBuyerBytes() {
1338         testFlag(
1339                 "getProtectedSignalsMaxSignalSizePerBuyerBytes()",
1340                 PROTECTED_SIGNALS_MAX_SIGNAL_SIZE_PER_BUYER_BYTES,
1341                 Flags::getProtectedSignalsMaxSignalSizePerBuyerBytes);
1342     }
1343 
1344     @Test
testGetProtectedSignalsMaxSignalSizePerBuyerWithOversubsciptionBytes()1345     public void testGetProtectedSignalsMaxSignalSizePerBuyerWithOversubsciptionBytes() {
1346         testFlag(
1347                 "getProtectedSignalsMaxSignalSizePerBuyerWithOversubsciptionBytes()",
1348                 PROTECTED_SIGNALS_MAX_SIGNAL_SIZE_PER_BUYER_WITH_OVERSUBSCIPTION_BYTES,
1349                 Flags::getProtectedSignalsMaxSignalSizePerBuyerWithOversubsciptionBytes);
1350     }
1351 
1352     @Test
testGetProtectedSignalsUpdateSchemaVersion()1353     public void testGetProtectedSignalsUpdateSchemaVersion() {
1354         testFlag(
1355                 "getProtectedSignalsUpdateSchemaVersion",
1356                 PROTECTED_SIGNALS_UPDATE_SCHEMA_VERSION,
1357                 Flags::getProtectedSignalsUpdateSchemaVersion);
1358     }
1359 
1360     ////////////////////////////////////////////////////////////////////////////////////////////////
1361     // Internal helpers and tests - do not add new tests for flags following this point.          //
1362     ////////////////////////////////////////////////////////////////////////////////////////////////
1363 
1364     /* NOTE: to enable this test locally, run:
1365 
1366     find $ANDROID_BUILD_TOP/packages/modules/AdServices/shared/libraries/device-side/java/com/android/adservices/shared/common/flags/  -type f -iname "*.java" -exec sed -i.bak 's/SOURCE/RUNTIME/g' "{}" + && rm -rf `find $ANDROID_BUILD_TOP/packages/modules/AdServices/shared/libraries/device-side/java/com/android/adservices/shared/common/flags/ -name *.java.bak|xargs`
1367 
1368     */
1369 
1370     @Test
testAllFlagsAreProperlyAnnotated()1371     public void testAllFlagsAreProperlyAnnotated() throws Exception {
1372         requireFlagAnnotationsRuntimeRetention();
1373 
1374         // NOTE: pass explicitly flags when developing, otherwise it would return hundreds of
1375         // failed fields. Example:
1376         //        List<Field> allFields = getAllFlagFields(
1377         //                "MEASUREMENT_REPORTING_JOB_REQUIRED_BATTERY_NOT_LOW",
1378         //                "MEASUREMENT_REPORTING_JOB_REQUIRED_NETWORK_TYPE",
1379         //                "MEASUREMENT_AGGREGATE_FALLBACK_REPORTING_JOB_REQUIRED_BATTERY_NOT_LOW");
1380         List<Field> allFields = getAllFlagFields();
1381         List<String> fieldsMissingAnnotation = new ArrayList<>();
1382 
1383         for (Field field : allFields) {
1384             String name = field.getName();
1385             if (!hasAnnotation(field, FeatureFlag.class)
1386                     && !hasAnnotation(field, ConfigFlag.class)) {
1387                 fieldsMissingAnnotation.add(name);
1388             }
1389         }
1390         expect.withMessage(
1391                         "%s (out of %s) fields missing @FeatureFlag or @ConfigFlag annotation",
1392                         fieldsMissingAnnotation.size(), allFields.size())
1393                 .that(fieldsMissingAnnotation)
1394                 .isEmpty();
1395     }
1396 
1397     @Test
testGetAdIdCacheTtl()1398     public void testGetAdIdCacheTtl() {
1399         testFlag("getAdIdCacheTtl()", DEFAULT_ADID_CACHE_TTL_MS, Flags::getAdIdCacheTtlMs);
1400     }
1401 
1402     @Test
testGetEnableAtomicFileDatastoreBatchUpdateApi()1403     public void testGetEnableAtomicFileDatastoreBatchUpdateApi() {
1404         testFeatureFlag(
1405                 "DEFAULT_ENABLE_ATOMIC_FILE_DATASTORE_BATCH_UPDATE_API",
1406                 Flags::getEnableAtomicFileDatastoreBatchUpdateApi);
1407     }
1408 
1409     @Test
testGetAdIdMigrationEnabled()1410     public void testGetAdIdMigrationEnabled() {
1411         testFeatureFlag("DEFAULT_AD_ID_MIGRATION_ENABLED", Flags::getAdIdMigrationEnabled);
1412     }
1413 
1414     @Test
testGetFledgeCustomAudiencePerBuyerMaxCount()1415     public void testGetFledgeCustomAudiencePerBuyerMaxCount() {
1416         testFlag(
1417                 "getFledgeCustomAudiencePerBuyerMaxCount",
1418                 FLEDGE_CUSTOM_AUDIENCE_PER_BUYER_MAX_COUNT,
1419                 Flags::getFledgeCustomAudiencePerBuyerMaxCount);
1420     }
1421 
1422     @Test
testGetEnforceForegroundStatusForFetchAndJoinCustomAudience()1423     public void testGetEnforceForegroundStatusForFetchAndJoinCustomAudience() {
1424         testFlag(
1425                 "getEnforceForegroundStatusForFetchAndJoinCustomAudience",
1426                 ENFORCE_FOREGROUND_STATUS_FETCH_AND_JOIN_CUSTOM_AUDIENCE,
1427                 Flags::getEnforceForegroundStatusForFetchAndJoinCustomAudience);
1428     }
1429 
1430     @Test
testGetEnforceForegroundStatusForLeaveCustomAudience()1431     public void testGetEnforceForegroundStatusForLeaveCustomAudience() {
1432         testFlag(
1433                 "getEnforceForegroundStatusForLeaveCustomAudience",
1434                 ENFORCE_FOREGROUND_STATUS_LEAVE_CUSTOM_AUDIENCE,
1435                 Flags::getEnforceForegroundStatusForLeaveCustomAudience);
1436     }
1437 
1438     @Test
testGetEnforceForegroundStatusForScheduleCustomAudience()1439     public void testGetEnforceForegroundStatusForScheduleCustomAudience() {
1440         testFlag(
1441                 "getEnforceForegroundStatusForScheduleCustomAudience",
1442                 ENFORCE_FOREGROUND_STATUS_SCHEDULE_CUSTOM_AUDIENCE,
1443                 Flags::getEnforceForegroundStatusForScheduleCustomAudience);
1444     }
1445 
1446     @Test
testGetEnableGetBindingUidImportance()1447     public void testGetEnableGetBindingUidImportance() {
1448         testFlag(
1449                 "getEnableGetBindingUidImportance",
1450                 ENABLE_GET_BINDING_UID_IMPORTANCE,
1451                 Flags::getEnableGetBindingUidImportance);
1452     }
1453 
1454     @Test
testGetEnableCustomAudienceComponentAds()1455     public void testGetEnableCustomAudienceComponentAds() {
1456         testFlag(
1457                 "getEnableCustomAudienceComponentAds",
1458                 ENABLE_CUSTOM_AUDIENCE_COMPONENT_ADS,
1459                 Flags::getEnableCustomAudienceComponentAds);
1460     }
1461 
1462     @Test
testGetEnablePasComponentAds()1463     public void testGetEnablePasComponentAds() {
1464         testFlag(
1465                 "getEnablePasComponentAds",
1466                 ENABLE_PAS_COMPONENT_ADS,
1467                 Flags::getEnablePasComponentAds);
1468     }
1469 
1470     @Test
testGetMaxComponentAdsPerCustomAudience()1471     public void testGetMaxComponentAdsPerCustomAudience() {
1472         testFlag(
1473                 "getMaxComponentAdsPerCustomAudience",
1474                 MAX_COMPONENT_ADS_PER_CUSTOM_AUDIENCE,
1475                 Flags::getMaxComponentAdsPerCustomAudience);
1476     }
1477 
1478     @Test
testGetComponentAdRenderIdMaxLengthBytes()1479     public void testGetComponentAdRenderIdMaxLengthBytes() {
1480         testFlag(
1481                 "getComponentAdRenderIdMaxLengthBytes",
1482                 COMPONENT_AD_RENDER_ID_MAX_LENGTH_BYTES,
1483                 Flags::getComponentAdRenderIdMaxLengthBytes);
1484     }
1485 
1486     @Test
testGetEnableMsmtRegisterSourcePackageDenyList()1487     public void testGetEnableMsmtRegisterSourcePackageDenyList() {
1488         testFlag(
1489                 "getEnableMsmtRegisterSourcePackageDenyList",
1490                 DEFAULT_MSMT_REGISTER_SOURCE_PACKAGE_DENY_LIST,
1491                 Flags::getEnableMsmtRegisterSourcePackageDenyList);
1492     }
1493 
1494     @Test
testGetEnableLogSamplingInfra()1495     public void testGetEnableLogSamplingInfra() {
1496         testFlag(
1497                 "getEnableLogSamplingInfra",
1498                 DEFAULT_ENABLE_LOG_SAMPLING_INFRA,
1499                 Flags::getEnableLogSamplingInfra);
1500     }
1501 
1502     @Test
testGetAdServicesJobExecutionSamplingConfig()1503     public void testGetAdServicesJobExecutionSamplingConfig() {
1504         testFlag(
1505                 "getAdServicesJobExecutionSamplingConfig",
1506                 DEFAULT_AD_SERVICES_JOB_EXECUTION_SAMPLING_CONFIG,
1507                 Flags::getAdServicesJobExecutionSamplingConfig);
1508     }
1509 
1510     @Test
testGetAdServicesJobSchedulingSamplingConfig()1511     public void testGetAdServicesJobSchedulingSamplingConfig() {
1512         testFlag(
1513                 "getAdServicesJobSchedulingSamplingConfig",
1514                 DEFAULT_AD_SERVICES_JOB_SCHEDULING_SAMPLING_CONFIG,
1515                 Flags::getAdServicesJobSchedulingSamplingConfig);
1516     }
1517 
1518     @Test
testGetAdServicesCelSamplingConfig()1519     public void testGetAdServicesCelSamplingConfig() {
1520         testFlag(
1521                 "getAdServicesCelSamplingConfig",
1522                 DEFAULT_AD_SERVICES_CEL_SAMPLING_CONFIG,
1523                 Flags::getAdServicesCelSamplingConfig);
1524     }
1525 
1526     @Test
testGetMeasurementEnableDebugJoinKeysOpenAccess()1527     public void testGetMeasurementEnableDebugJoinKeysOpenAccess() {
1528         testFlag(
1529                 "getMeasurementEnableDebugJoinKeysOpenAccess",
1530                 MEASUREMENT_ENABLE_DEBUG_JOIN_KEYS_OPEN_ACCESS,
1531                 Flags::getMeasurementEnableDebugJoinKeysOpenAccess);
1532     }
1533 
1534     @Test
testGetMeasurementDebugJoinKeysNoncompliantAdtechs()1535     public void testGetMeasurementDebugJoinKeysNoncompliantAdtechs() {
1536         testFlag(
1537                 "getMeasurementDebugJoinKeysNoncompliantAdtechs",
1538                 MEASUREMENT_DEBUG_JOIN_KEYS_NONCOMPLIANT_ADTECHS,
1539                 Flags::getMeasurementDebugJoinKeysNoncompliantAdtechs);
1540     }
1541 
1542     @Test
testGetMeasurementDebugJoinKeysNoncompliantAdtechsSampleRate()1543     public void testGetMeasurementDebugJoinKeysNoncompliantAdtechsSampleRate() {
1544         testFloatFlag(
1545                 "getMeasurementDebugJoinKeysNoncompliantAdtechsSampleRate",
1546                 MEASUREMENT_DEBUG_JOIN_KEYS_NONCOMPLIANT_ADTECHS_SAMPLE_RATE,
1547                 Flags::getMeasurementDebugJoinKeysNoncompliantAdtechsSampleRate);
1548     }
1549 
hasAnnotation(Field field, Class<? extends Annotation> annotationClass)1550     private boolean hasAnnotation(Field field, Class<? extends Annotation> annotationClass) {
1551         String name = field.getName();
1552         Annotation annotation = field.getAnnotation(annotationClass);
1553         if (annotation != null) {
1554             mLog.d("Found annotation on field %s : %s", name, annotation);
1555             return true;
1556         }
1557         return false;
1558     }
1559 
testRampedUpKillSwitchGuardedByGlobalKillSwitch( String name, Flaginator<Flags, Boolean> flaginator)1560     private void testRampedUpKillSwitchGuardedByGlobalKillSwitch(
1561             String name, Flaginator<Flags, Boolean> flaginator) {
1562         internalHelperFortKillSwitchGuardedByGlobalKillSwitch(
1563                 name, flaginator, /* expectedValue= */ false);
1564     }
1565 
testNewKillSwitchGuardedByGlobalKillSwitch( String name, Flaginator<Flags, Boolean> flaginator)1566     private void testNewKillSwitchGuardedByGlobalKillSwitch(
1567             String name, Flaginator<Flags, Boolean> flaginator) {
1568         internalHelperFortKillSwitchGuardedByGlobalKillSwitch(
1569                 name, flaginator, /* expectedValue= */ true);
1570     }
1571 
testFeatureFlagGuardedByGlobalKillSwitch( String name, Flaginator<Flags, Boolean> flaginator)1572     private void testFeatureFlagGuardedByGlobalKillSwitch(
1573             String name, Flaginator<Flags, Boolean> flaginator) {
1574         boolean defaultValue = getConstantValue(name);
1575 
1576         // Getter
1577         expect.withMessage("getter for %s when global kill_switch is on", name)
1578                 .that(flaginator.getFlagValue(mGlobalKsOnFlags))
1579                 .isFalse();
1580 
1581         expect.withMessage("getter for %s when global kill_switch is off", name)
1582                 .that(flaginator.getFlagValue(mGlobalKsOffFlags))
1583                 .isEqualTo(defaultValue);
1584 
1585         // Constant
1586         expect.withMessage("%s", name).that(defaultValue).isFalse();
1587     }
1588 
testFeatureFlag(String name, Flaginator<Flags, Boolean> flaginator)1589     private void testFeatureFlag(String name, Flaginator<Flags, Boolean> flaginator) {
1590         boolean defaultValue = getConstantValue(name);
1591 
1592         // Getter
1593 
1594         expect.withMessage("getter for %s", name)
1595                 .that(flaginator.getFlagValue(mFlags))
1596                 .isEqualTo(defaultValue);
1597 
1598         // Since the flag doesn't depend on global kill switch, it shouldn't matter if it's on or
1599         // off
1600         expect.withMessage("getter for %s when global kill_switch is on", name)
1601                 .that(flaginator.getFlagValue(mGlobalKsOnFlags))
1602                 .isEqualTo(defaultValue);
1603         expect.withMessage("getter for %s when global kill_switch is off", name)
1604                 .that(flaginator.getFlagValue(mGlobalKsOffFlags))
1605                 .isEqualTo(defaultValue);
1606 
1607         // Constant
1608         expect.withMessage("%s", name).that(defaultValue).isFalse();
1609     }
1610 
testFlag( String getterName, long defaultValue, Flaginator<Flags, Long> flaginator)1611     private void testFlag(
1612             String getterName, long defaultValue, Flaginator<Flags, Long> flaginator) {
1613         expect.withMessage("%s", getterName)
1614                 .that(flaginator.getFlagValue(mFlags))
1615                 .isEqualTo(defaultValue);
1616     }
1617 
testFloatFlag( String getterName, float defaultValue, Flaginator<Flags, Float> flaginator)1618     private void testFloatFlag(
1619             String getterName, float defaultValue, Flaginator<Flags, Float> flaginator) {
1620         expect.withMessage("%s", getterName)
1621                 .that(flaginator.getFlagValue(mFlags))
1622                 .isEqualTo(defaultValue);
1623     }
1624 
testFlag( String getterName, int defaultValue, Flaginator<Flags, Integer> flaginator)1625     private void testFlag(
1626             String getterName, int defaultValue, Flaginator<Flags, Integer> flaginator) {
1627         expect.withMessage("%s", getterName)
1628                 .that(flaginator.getFlagValue(mFlags))
1629                 .isEqualTo(defaultValue);
1630     }
1631 
testFlag( String getterName, boolean defaultValue, Flaginator<Flags, Boolean> flaginator)1632     private void testFlag(
1633             String getterName, boolean defaultValue, Flaginator<Flags, Boolean> flaginator) {
1634         expect.withMessage("%s", getterName)
1635                 .that(flaginator.getFlagValue(mFlags))
1636                 .isEqualTo(defaultValue);
1637     }
1638 
testFlag( String getterName, String defaultValue, Flaginator<Flags, String> flaginator)1639     private void testFlag(
1640             String getterName, String defaultValue, Flaginator<Flags, String> flaginator) {
1641         expect.withMessage("%s", getterName)
1642                 .that(flaginator.getFlagValue(mFlags))
1643                 .isEqualTo(defaultValue);
1644     }
1645 
1646     /**
1647      * @deprecated TODO(b / 324077542) - remove once all kill-switches have been converted
1648      */
1649     @Deprecated
testKillSwitchBeingConvertedAndGuardedByGlobalKillSwitch( String name, Flaginator<Flags, Boolean> flaginator)1650     private void testKillSwitchBeingConvertedAndGuardedByGlobalKillSwitch(
1651             String name, Flaginator<Flags, Boolean> flaginator) {
1652         internalHelperFortKillSwitchGuardedByGlobalKillSwitch(
1653                 name, flaginator, /* expectedValue= */ false);
1654     }
1655 
testFeatureFlagBasedOnLegacyKillSwitchAndGuardedByGlobalKillSwitch( String getterName, boolean defaultKillSwitchValue, Flaginator<Flags, Boolean> flaginator)1656     private void testFeatureFlagBasedOnLegacyKillSwitchAndGuardedByGlobalKillSwitch(
1657             String getterName,
1658             boolean defaultKillSwitchValue,
1659             Flaginator<Flags, Boolean> flaginator) {
1660         expect.withMessage("%s when global kill_switch is on", getterName)
1661                 .that(flaginator.getFlagValue(mGlobalKsOnFlags))
1662                 .isFalse();
1663         expect.withMessage("%s when global kill_switch is off", getterName)
1664                 .that(flaginator.getFlagValue(mGlobalKsOffFlags))
1665                 .isEqualTo(!defaultKillSwitchValue);
1666     }
1667 
testMsmtFeatureFlagBackedByLegacyKillSwitchAndGuardedByMsmtEnabled( String getterName, String killSwitchName, Flaginator<Flags, Boolean> flaginator)1668     private void testMsmtFeatureFlagBackedByLegacyKillSwitchAndGuardedByMsmtEnabled(
1669             String getterName, String killSwitchName, Flaginator<Flags, Boolean> flaginator) {
1670         boolean defaultKillSwitchValue = getConstantValue(killSwitchName);
1671         boolean defaultValue = !defaultKillSwitchValue;
1672 
1673         // Getter
1674         expect.withMessage("%s when msmt_enabled is true", getterName)
1675                 .that(flaginator.getFlagValue(mMsmtEnabledFlags))
1676                 .isEqualTo(defaultValue);
1677         expect.withMessage("getter for %s when msmt enabled is false", getterName)
1678                 .that(flaginator.getFlagValue(mMsmtDisabledFlags))
1679                 .isFalse();
1680 
1681         // Constant
1682         expect.withMessage("%s", killSwitchName).that(defaultKillSwitchValue).isFalse();
1683     }
1684 
1685     @SuppressWarnings({"unused"}) // Might become unused if no flag currently needs it
testRetiredFeatureFlag(String name, Flaginator<Flags, Boolean> flaginator)1686     private void testRetiredFeatureFlag(String name, Flaginator<Flags, Boolean> flaginator) {
1687         boolean defaultValue = getConstantValue(name);
1688 
1689         // Getter
1690         expect.withMessage("getter for %s", name)
1691                 .that(flaginator.getFlagValue(mFlags))
1692                 .isEqualTo(defaultValue);
1693 
1694         // Constant
1695         expect.withMessage("%s", name).that(defaultValue).isTrue();
1696     }
1697 
getConstantValue(String name)1698     static <T> T getConstantValue(String name) {
1699         return getConstantValue(Flags.class, name);
1700     }
1701 
1702     // Not passing type (and using type.cast(value)) because most of the flags are primitive types
1703     // (like boolean) and T would be their object equivalent (like Boolean)
1704     @SuppressWarnings("TypeParameterUnusedInFormals")
getConstantValue(Class<?> clazz, String name)1705     static <T> T getConstantValue(Class<?> clazz, String name) {
1706         Field field;
1707         try {
1708             field = clazz.getDeclaredField(name);
1709         } catch (NoSuchFieldException | SecurityException e) {
1710             throw new IllegalArgumentException("Could not get field " + name + ": " + e);
1711         }
1712 
1713         int modifiers = field.getModifiers();
1714         Preconditions.checkArgument(
1715                 Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers),
1716                 "field %s is not static final",
1717                 name);
1718 
1719         Object value;
1720         try {
1721             value = field.get(null);
1722         } catch (IllegalArgumentException | IllegalAccessException e) {
1723             throw new IllegalArgumentException("Could not get value of field " + name + ": " + e);
1724         }
1725 
1726         Log.v(TAG, "getConstant(): " + name + "=" + value);
1727 
1728         @SuppressWarnings("unchecked")
1729         T castValue = (T) value;
1730 
1731         return castValue;
1732     }
1733 
1734     // Should not be called directly
internalHelperFortKillSwitchGuardedByGlobalKillSwitch( String name, Flaginator<Flags, Boolean> flaginator, boolean expectedValue)1735     private void internalHelperFortKillSwitchGuardedByGlobalKillSwitch(
1736             String name, Flaginator<Flags, Boolean> flaginator, boolean expectedValue) {
1737         boolean defaultValue = getConstantValue(name);
1738 
1739         // Getter
1740         expect.withMessage("getter for %s when global kill_switch is on", name)
1741                 .that(flaginator.getFlagValue(mGlobalKsOnFlags))
1742                 .isTrue();
1743 
1744         expect.withMessage("getter for %s when global kill_switch is off", name)
1745                 .that(flaginator.getFlagValue(mGlobalKsOffFlags))
1746                 .isEqualTo(defaultValue);
1747 
1748         // Constant
1749         expect.withMessage("%s", name).that(defaultValue).isEqualTo(expectedValue);
1750     }
1751 
1752     static class GlobalKillSwitchAwareFlags implements Flags {
1753         private final boolean mGlobalKsOnFlags;
1754 
GlobalKillSwitchAwareFlags(boolean globalKsEnabled)1755         GlobalKillSwitchAwareFlags(boolean globalKsEnabled) {
1756             mGlobalKsOnFlags = globalKsEnabled;
1757         }
1758 
1759         @Override
getGlobalKillSwitch()1760         public boolean getGlobalKillSwitch() {
1761             Log.d(TAG, this + ".getGlobalKillSwitch(): returning " + mGlobalKsOnFlags);
1762             return mGlobalKsOnFlags;
1763         }
1764 
1765         @Override
toString()1766         public String toString() {
1767             StringBuilder string = new StringBuilder(getClass().getSimpleName()).append('[');
1768             decorateToString(string);
1769             return string.append(']').toString();
1770         }
1771 
decorateToString(StringBuilder toString)1772         protected void decorateToString(StringBuilder toString) {
1773             toString.append("globalKsEnabled=").append(mGlobalKsOnFlags);
1774         }
1775     }
1776 
1777     private static final class MsmtFeatureAwareFlags extends GlobalKillSwitchAwareFlags {
1778         private final boolean mMsmtEnabled;
1779 
MsmtFeatureAwareFlags(boolean msmtEnabled)1780         MsmtFeatureAwareFlags(boolean msmtEnabled) {
1781             super(false);
1782             mMsmtEnabled = msmtEnabled;
1783         }
1784 
1785         @Override
getMeasurementEnabled()1786         public boolean getMeasurementEnabled() {
1787             Log.d(TAG, this + ".getMeasurementEnabled(): returning " + mMsmtEnabled);
1788             return mMsmtEnabled;
1789         }
1790 
1791         @Override
decorateToString(StringBuilder toString)1792         protected void decorateToString(StringBuilder toString) {
1793             super.decorateToString(toString);
1794             toString.append(", msmtEnabled=").append(mMsmtEnabled);
1795         }
1796     }
1797 
1798     /**
1799      * @deprecated - TODO(b/325074749): remove once all methods are changed to use
1800      *     !getMeasurementEnabled()
1801      */
1802     @Deprecated
1803     private static final class MsmtKillSwitchAwareFlags extends GlobalKillSwitchAwareFlags {
1804         private final boolean mMsmtKsEnabled;
1805 
MsmtKillSwitchAwareFlags(boolean msmtKsEnabled)1806         MsmtKillSwitchAwareFlags(boolean msmtKsEnabled) {
1807             super(false);
1808             mMsmtKsEnabled = msmtKsEnabled;
1809         }
1810 
1811         @Override
getLegacyMeasurementKillSwitch()1812         public boolean getLegacyMeasurementKillSwitch() {
1813             Log.d(TAG, this + ".getLegacyMeasurementKillSwitch(): returning " + mMsmtKsEnabled);
1814             return mMsmtKsEnabled;
1815         }
1816 
1817         @Override
decorateToString(StringBuilder toString)1818         protected void decorateToString(StringBuilder toString) {
1819             super.decorateToString(toString);
1820             toString.append(", msmtKsEnabled=").append(mMsmtKsEnabled);
1821         }
1822     }
1823 
1824     /**
1825      * Gets all fields defining flags.
1826      *
1827      * @param flagNames if set, only return fields with those names
1828      */
getAllFlagFields(String... flagNames)1829     private List<Field> getAllFlagFields(String... flagNames) throws IllegalAccessException {
1830         List<String> filter =
1831                 flagNames == null || flagNames.length == 0 ? null : Arrays.asList(flagNames);
1832         List<Field> fields = new ArrayList<>();
1833         for (Field field : Flags.class.getDeclaredFields()) {
1834             int modifiers = field.getModifiers();
1835             if (Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers)) {
1836                 String name = field.getName();
1837                 if (filter != null && !filter.contains(name)) {
1838                     mLog.v("Skipping %s because it matches filter (%s)", name, filter);
1839                     continue;
1840                 }
1841                 fields.add(field);
1842             }
1843         }
1844         return fields;
1845     }
1846 
requireFlagAnnotationsRuntimeRetention()1847     private static void requireFlagAnnotationsRuntimeRetention() throws Exception {
1848         Field field = FlagsTest.class.getField("fieldUsedToDetermineAnnotationRetention");
1849         boolean hasFeatureFlag = field.getAnnotation(FeatureFlag.class) != null;
1850         boolean hasConfigFlag = field.getAnnotation(ConfigFlag.class) != null;
1851         if (!(hasFeatureFlag && hasConfigFlag)) {
1852             throw new AssumptionViolatedException(
1853                     "Both @FeatureFlag and @ConfigFlag must be set with RUNTIME Retention, but"
1854                             + " @FeatureFlag="
1855                             + hasFeatureFlag
1856                             + " and @ConfigFlag="
1857                             + hasConfigFlag);
1858         }
1859     }
1860 
1861     // Used by requireFlagAnnotationsRuntimeRetention
1862     @FeatureFlag @ConfigFlag
1863     public final Object fieldUsedToDetermineAnnotationRetention = new Object();
1864 }
1865