Add new FeatureFlagsClassic alias

Deprecate the old FeatureFlags name.

This change is in preparation for the introduction of the new
aconfig-based flagging system, which also utilizes a class called
FeatureFlags. To prevent the need for qualified names, as well as
general naming confusion, we are moving usage of the "classic" feature
flags to a new name going forward.

Bug: 292511372
Test: make
Change-Id: Ieeb339c0311cd7a81aacd68e8808ee812b6bb018

16 files changed, 216 insertions, 239 deletions

diff --git a/packages/SystemUI/src-debug/com/android/systemui/flags/FlagsModule.kt b/packages/SystemUI/src-debug/com/android/systemui/flags/FlagsModule.kt
index f005bab55de6..fae9fec0c26d 100644
--- a/packages/SystemUI/src-debug/com/android/systemui/flags/FlagsModule.kt
+++ b/packages/SystemUI/src-debug/com/android/systemui/flags/FlagsModule.kt
@@ -33,8 +33,7 @@ import javax.inject.Named
     SettingsUtilModule::class,
 ])
 abstract class FlagsModule {
-    @Binds
-    abstract fun bindsFeatureFlagDebug(impl: FeatureFlagsDebug): FeatureFlags
+    @Binds abstract fun bindsFeatureFlagDebug(impl: FeatureFlagsClassicDebug): FeatureFlagsClassic
 
     @Binds
     @IntoSet
diff --git a/packages/SystemUI/src-release/com/android/systemui/flags/FlagsModule.kt b/packages/SystemUI/src-release/com/android/systemui/flags/FlagsModule.kt
index 927d4604b823..7aacb4efba8e 100644
--- a/packages/SystemUI/src-release/com/android/systemui/flags/FlagsModule.kt
+++ b/packages/SystemUI/src-release/com/android/systemui/flags/FlagsModule.kt
@@ -29,7 +29,7 @@ import javax.inject.Named
 ])
 abstract class FlagsModule {
     @Binds
-    abstract fun bindsFeatureFlagRelease(impl: FeatureFlagsRelease): FeatureFlags
+    abstract fun bindsFeatureFlagRelease(impl: FeatureFlagsClassicRelease): FeatureFlagsClassic
 
     @Binds
     @IntoSet
diff --git a/packages/SystemUI/src/com/android/systemui/flags/ConditionalRestarter.kt b/packages/SystemUI/src/com/android/systemui/flags/ConditionalRestarter.kt
index b20e33a63776..83c239f169ef 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/ConditionalRestarter.kt
+++ b/packages/SystemUI/src/com/android/systemui/flags/ConditionalRestarter.kt
@@ -44,12 +44,12 @@ constructor(
     private var androidRestartRequested = false
 
     override fun restartSystemUI(reason: String) {
-        Log.d(FeatureFlagsDebug.TAG, "SystemUI Restart requested. Restarting when idle.")
+        Log.d(FeatureFlagsClassicDebug.TAG, "SystemUI Restart requested. Restarting when idle.")
         scheduleRestart(reason)
     }
 
     override fun restartAndroid(reason: String) {
-        Log.d(FeatureFlagsDebug.TAG, "Android Restart requested. Restarting when idle.")
+        Log.d(FeatureFlagsClassicDebug.TAG, "Android Restart requested. Restarting when idle.")
         androidRestartRequested = true
         scheduleRestart(reason)
     }
diff --git a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlags.kt b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlags.kt
index 95e7ad969e35..d48eb2927a14 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlags.kt
+++ b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlags.kt
@@ -23,6 +23,21 @@ import android.util.Dumpable
  *
  * See [Flags] for instructions on defining new flags.
  */
+interface FeatureFlagsClassic : FeatureFlags
+
+/**
+ * Class to manage simple DeviceConfig-based feature flags.
+ *
+ * See [Flags] for instructions on defining new flags.
+ */
+@Deprecated(
+    message = "Use FeatureFlagsClassic instead.",
+    replaceWith =
+        ReplaceWith(
+            "FeatureFlagsClassic",
+            "com.android.systemui.flags.FeatureFlagsClassic",
+        ),
+)
 interface FeatureFlags : FlagListenable, Dumpable {
     /** Returns a boolean value for the given flag.  */
     fun isEnabled(flag: UnreleasedFlag): Boolean
@@ -47,4 +62,4 @@ interface FeatureFlags : FlagListenable, Dumpable {
 
     /** Returns an int value for a given flag/ */
     fun getInt(flag: ResourceIntFlag): Int
-}
+}
\ No newline at end of file
diff --git a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsDebug.java b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsClassicDebug.java
index 4c78e4ce4fe4..126a1b5e7115 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsDebug.java
+++ b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsClassicDebug.java
@@ -67,7 +67,7 @@ import javax.inject.Named;
  * To restore a flag back to its default, leave the `--ez value <0|1>` off of the command.
  */
 @SysUISingleton
-public class FeatureFlagsDebug implements FeatureFlags {
+public class FeatureFlagsClassicDebug implements FeatureFlagsClassic {
     static final String TAG = "SysUIFlags";
 
     private final FlagManager mFlagManager;
@@ -116,7 +116,7 @@ public class FeatureFlagsDebug implements FeatureFlags {
             };
 
     @Inject
-    public FeatureFlagsDebug(
+    public FeatureFlagsClassicDebug(
             FlagManager flagManager,
             Context context,
             GlobalSettings globalSettings,
diff --git a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsRelease.java b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsClassicRelease.java
index e03b43873e05..79ebf9c7d8df 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsRelease.java
+++ b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsClassicRelease.java
@@ -43,7 +43,7 @@ import javax.inject.Named;
  * how to set flags.
  */
 @SysUISingleton
-public class FeatureFlagsRelease implements FeatureFlags {
+public class FeatureFlagsClassicRelease implements FeatureFlagsClassic {
     static final String TAG = "SysUIFlags";
 
     private final Resources mResources;
@@ -89,7 +89,7 @@ public class FeatureFlagsRelease implements FeatureFlags {
             };
 
     @Inject
-    public FeatureFlagsRelease(
+    public FeatureFlagsClassicRelease(
             @Main Resources resources,
             SystemPropertiesHelper systemProperties,
             ServerFlagReader serverFlagReader,
diff --git a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsDebugStartable.kt b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsDebugStartable.kt
index 28c45b874b24..dd560b797c7e 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsDebugStartable.kt
+++ b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsDebugStartable.kt
@@ -34,13 +34,13 @@ constructor(
     dumpManager: DumpManager,
     private val commandRegistry: CommandRegistry,
     private val flagCommand: FlagCommand,
-    private val featureFlags: FeatureFlagsDebug,
+    private val featureFlags: FeatureFlagsClassicDebug,
     private val broadcastSender: BroadcastSender,
     private val initializationChecker: InitializationChecker,
 ) : CoreStartable {
 
     init {
-        dumpManager.registerCriticalDumpable(FeatureFlagsDebug.TAG) { pw, args ->
+        dumpManager.registerCriticalDumpable(FeatureFlagsClassicDebug.TAG) { pw, args ->
             featureFlags.dump(pw, args)
         }
     }
diff --git a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsReleaseStartable.kt b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsReleaseStartable.kt
index f97112d384be..dfcc7ead11d0 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsReleaseStartable.kt
+++ b/packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsReleaseStartable.kt
@@ -32,7 +32,7 @@ constructor(
 ) : CoreStartable {
 
     init {
-        dumpManager.registerCriticalDumpable(FeatureFlagsRelease.TAG) { pw, args ->
+        dumpManager.registerCriticalDumpable(FeatureFlagsClassicRelease.TAG) { pw, args ->
             featureFlags.dump(pw, args)
         }
     }
diff --git a/packages/SystemUI/src/com/android/systemui/flags/FlagCommand.java b/packages/SystemUI/src/com/android/systemui/flags/FlagCommand.java
index bd0ed482c961..e3cc2b02177c 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/FlagCommand.java
+++ b/packages/SystemUI/src/com/android/systemui/flags/FlagCommand.java
@@ -38,12 +38,12 @@ public class FlagCommand implements Command {
     private final List<String> mOnCommands = List.of("true", "on", "1", "enabled");
     private final List<String> mOffCommands = List.of("false", "off", "0", "disable");
     private final List<String> mSetCommands = List.of("set", "put");
-    private final FeatureFlagsDebug mFeatureFlags;
+    private final FeatureFlagsClassicDebug mFeatureFlags;
     private final Map<String, Flag<?>> mAllFlags;
 
     @Inject
     FlagCommand(
-            FeatureFlagsDebug featureFlags,
+            FeatureFlagsClassicDebug featureFlags,
             @Named(ALL_FLAGS) Map<String, Flag<?>> allFlags
     ) {
         mFeatureFlags = featureFlags;
diff --git a/packages/SystemUI/src/com/android/systemui/flags/Flags.kt b/packages/SystemUI/src/com/android/systemui/flags/Flags.kt
index 4a22a6732ce7..6a22041d372e 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/Flags.kt
+++ b/packages/SystemUI/src/com/android/systemui/flags/Flags.kt
@@ -33,7 +33,7 @@ import com.android.systemui.flags.FlagsFactory.unreleasedFlag
  * On public release builds, flags will always return their default value. There is no way to change
  * their value on release builds.
  *
- * See [FeatureFlagsDebug] for instructions on flipping the flags via adb.
+ * See [FeatureFlagsClassicDebug] for instructions on flipping the flags via adb.
  */
 object Flags {
     @JvmField val TEAMFOOD = unreleasedFlag("teamfood")
diff --git a/packages/SystemUI/src/com/android/systemui/flags/FlagsCommonModule.kt b/packages/SystemUI/src/com/android/systemui/flags/FlagsCommonModule.kt
index 3c5012559a89..d13fa1eb7628 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/FlagsCommonModule.kt
+++ b/packages/SystemUI/src/com/android/systemui/flags/FlagsCommonModule.kt
@@ -25,6 +25,8 @@ import javax.inject.Named
 interface FlagsCommonModule {
     @Binds fun bindsRestarter(impl: ConditionalRestarter): Restarter
 
+    @Binds fun bindsClassic(impl: FeatureFlagsClassic): FeatureFlags
+
     companion object {
         const val ALL_FLAGS = "all_flags"
 
diff --git a/packages/SystemUI/src/com/android/systemui/flags/SystemExitRestarter.kt b/packages/SystemUI/src/com/android/systemui/flags/SystemExitRestarter.kt
index 46e28a7d0ef2..9f41b61c6f4d 100644
--- a/packages/SystemUI/src/com/android/systemui/flags/SystemExitRestarter.kt
+++ b/packages/SystemUI/src/com/android/systemui/flags/SystemExitRestarter.kt
@@ -26,12 +26,12 @@ constructor(
     private val barService: IStatusBarService,
 ) : Restarter {
     override fun restartAndroid(reason: String) {
-        Log.d(FeatureFlagsDebug.TAG, "Restarting Android: " + reason)
+        Log.d(FeatureFlagsClassicDebug.TAG, "Restarting Android: " + reason)
         barService.restart()
     }
 
     override fun restartSystemUI(reason: String) {
-        Log.d(FeatureFlagsDebug.TAG, "Restarting SystemUI: " + reason)
+        Log.d(FeatureFlagsClassicDebug.TAG, "Restarting SystemUI: " + reason)
         System.exit(0)
     }
 }
diff --git a/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsDebugTest.kt b/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsClassicDebugTest.kt
index ff15cb39b640..14c5ec0361f6 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsDebugTest.kt
+++ b/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsClassicDebugTest.kt
@@ -29,6 +29,10 @@ import com.android.systemui.util.mockito.nullable
 import com.android.systemui.util.mockito.withArgCaptor
 import com.android.systemui.util.settings.GlobalSettings
 import com.google.common.truth.Truth.assertThat
+import java.io.PrintWriter
+import java.io.Serializable
+import java.io.StringWriter
+import java.util.function.Consumer
 import org.junit.Assert
 import org.junit.Before
 import org.junit.Test
@@ -41,44 +45,30 @@ import org.mockito.Mockito.never
 import org.mockito.Mockito.times
 import org.mockito.Mockito.verify
 import org.mockito.Mockito.verifyNoMoreInteractions
-import org.mockito.MockitoAnnotations
-import java.io.PrintWriter
-import java.io.Serializable
-import java.io.StringWriter
-import java.util.function.Consumer
 import org.mockito.Mockito.`when` as whenever
+import org.mockito.MockitoAnnotations
 
 /**
  * NOTE: This test is for the version of FeatureFlagManager in src-debug, which allows overriding
  * the default.
  */
 @SmallTest
-class FeatureFlagsDebugTest : SysuiTestCase() {
-    private lateinit var featureFlagsDebug: FeatureFlagsDebug
-
-    @Mock
-    private lateinit var flagManager: FlagManager
-    @Mock
-    private lateinit var mockContext: Context
-    @Mock
-    private lateinit var globalSettings: GlobalSettings
-    @Mock
-    private lateinit var systemProperties: SystemPropertiesHelper
-    @Mock
-    private lateinit var resources: Resources
-    @Mock
-    private lateinit var restarter: Restarter
+class FeatureFlagsClassicDebugTest : SysuiTestCase() {
+    private lateinit var mFeatureFlagsClassicDebug: FeatureFlagsClassicDebug
+
+    @Mock private lateinit var flagManager: FlagManager
+    @Mock private lateinit var mockContext: Context
+    @Mock private lateinit var globalSettings: GlobalSettings
+    @Mock private lateinit var systemProperties: SystemPropertiesHelper
+    @Mock private lateinit var resources: Resources
+    @Mock private lateinit var restarter: Restarter
     private val flagMap = mutableMapOf<String, Flag<*>>()
     private lateinit var broadcastReceiver: BroadcastReceiver
     private lateinit var clearCacheAction: Consumer<String>
     private val serverFlagReader = ServerFlagReaderFake()
 
-    private val teamfoodableFlagA = UnreleasedFlag(
-        name = "a", namespace = "test", teamfood = true
-    )
-    private val teamfoodableFlagB = ReleasedFlag(
-        name = "b", namespace = "test", teamfood = true
-    )
+    private val teamfoodableFlagA = UnreleasedFlag(name = "a", namespace = "test", teamfood = true)
+    private val teamfoodableFlagB = ReleasedFlag(name = "b", namespace = "test", teamfood = true)
 
     @Before
     fun setup() {
@@ -86,27 +76,23 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         flagMap.put(Flags.TEAMFOOD.name, Flags.TEAMFOOD)
         flagMap.put(teamfoodableFlagA.name, teamfoodableFlagA)
         flagMap.put(teamfoodableFlagB.name, teamfoodableFlagB)
-        featureFlagsDebug = FeatureFlagsDebug(
-            flagManager,
-            mockContext,
-            globalSettings,
-            systemProperties,
-            resources,
-            serverFlagReader,
-            flagMap,
-            restarter
-        )
-        featureFlagsDebug.init()
+        mFeatureFlagsClassicDebug =
+            FeatureFlagsClassicDebug(
+                flagManager,
+                mockContext,
+                globalSettings,
+                systemProperties,
+                resources,
+                serverFlagReader,
+                flagMap,
+                restarter
+            )
+        mFeatureFlagsClassicDebug.init()
         verify(flagManager).onSettingsChangedAction = any()
         broadcastReceiver = withArgCaptor {
-            verify(mockContext).registerReceiver(
-                capture(), any(), nullable(), nullable(),
-                any()
-            )
-        }
-        clearCacheAction = withArgCaptor {
-            verify(flagManager).clearCacheAction = capture()
+            verify(mockContext).registerReceiver(capture(), any(), nullable(), nullable(), any())
         }
+        clearCacheAction = withArgCaptor { verify(flagManager).clearCacheAction = capture() }
         whenever(flagManager.nameToSettingsKey(any())).thenAnswer { "key-${it.arguments[0]}" }
     }
 
@@ -117,45 +103,29 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         whenever(flagManager.readFlagValue<Boolean>(eq("4"), any())).thenReturn(false)
 
         assertThat(
-            featureFlagsDebug.isEnabled(
-                ReleasedFlag(
-                    name = "2",
-                    namespace = "test"
-                )
+                mFeatureFlagsClassicDebug.isEnabled(ReleasedFlag(name = "2", namespace = "test"))
             )
-        ).isTrue()
+            .isTrue()
         assertThat(
-            featureFlagsDebug.isEnabled(
-                UnreleasedFlag(
-                    name = "3",
-                    namespace = "test"
-                )
+                mFeatureFlagsClassicDebug.isEnabled(UnreleasedFlag(name = "3", namespace = "test"))
             )
-        ).isTrue()
+            .isTrue()
         assertThat(
-            featureFlagsDebug.isEnabled(
-                ReleasedFlag(
-                    name = "4",
-                    namespace = "test"
-                )
+                mFeatureFlagsClassicDebug.isEnabled(ReleasedFlag(name = "4", namespace = "test"))
             )
-        ).isFalse()
+            .isFalse()
         assertThat(
-            featureFlagsDebug.isEnabled(
-                UnreleasedFlag(
-                    name = "5",
-                    namespace = "test"
-                )
+                mFeatureFlagsClassicDebug.isEnabled(UnreleasedFlag(name = "5", namespace = "test"))
             )
-        ).isFalse()
+            .isFalse()
     }
 
     @Test
     fun teamFoodFlag_False() {
-        whenever(flagManager.readFlagValue<Boolean>(
-            eq(Flags.TEAMFOOD.name), any())).thenReturn(false)
-        assertThat(featureFlagsDebug.isEnabled(teamfoodableFlagA)).isFalse()
-        assertThat(featureFlagsDebug.isEnabled(teamfoodableFlagB)).isTrue()
+        whenever(flagManager.readFlagValue<Boolean>(eq(Flags.TEAMFOOD.name), any()))
+            .thenReturn(false)
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagA)).isFalse()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagB)).isTrue()
 
         // Regular boolean flags should still test the same.
         // Only our teamfoodableFlag should change.
@@ -164,10 +134,10 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
 
     @Test
     fun teamFoodFlag_True() {
-        whenever(flagManager.readFlagValue<Boolean>(
-            eq(Flags.TEAMFOOD.name), any())).thenReturn(true)
-        assertThat(featureFlagsDebug.isEnabled(teamfoodableFlagA)).isTrue()
-        assertThat(featureFlagsDebug.isEnabled(teamfoodableFlagB)).isTrue()
+        whenever(flagManager.readFlagValue<Boolean>(eq(Flags.TEAMFOOD.name), any()))
+            .thenReturn(true)
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagA)).isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagB)).isTrue()
 
         // Regular boolean flags should still test the same.
         // Only our teamfoodableFlag should change.
@@ -180,10 +150,10 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
             .thenReturn(true)
         whenever(flagManager.readFlagValue<Boolean>(eq(teamfoodableFlagB.name), any()))
             .thenReturn(false)
-        whenever(flagManager.readFlagValue<Boolean>(
-            eq(Flags.TEAMFOOD.name), any())).thenReturn(true)
-        assertThat(featureFlagsDebug.isEnabled(teamfoodableFlagA)).isTrue()
-        assertThat(featureFlagsDebug.isEnabled(teamfoodableFlagB)).isFalse()
+        whenever(flagManager.readFlagValue<Boolean>(eq(Flags.TEAMFOOD.name), any()))
+            .thenReturn(true)
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagA)).isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagB)).isFalse()
 
         // Regular boolean flags should still test the same.
         // Only our teamfoodableFlag should change.
@@ -201,25 +171,20 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         whenever(flagManager.readFlagValue<Boolean>(eq("3"), any())).thenReturn(true)
         whenever(flagManager.readFlagValue<Boolean>(eq("5"), any())).thenReturn(false)
 
-        assertThat(
-            featureFlagsDebug.isEnabled(
-                ResourceBooleanFlag(
-                    "1",
-                    "test",
-                    1001
-                )
-            )
-        ).isFalse()
-        assertThat(featureFlagsDebug.isEnabled(ResourceBooleanFlag("2", "test", 1002))).isTrue()
-        assertThat(featureFlagsDebug.isEnabled(ResourceBooleanFlag("3", "test", 1003))).isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(ResourceBooleanFlag("1", "test", 1001)))
+            .isFalse()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(ResourceBooleanFlag("2", "test", 1002)))
+            .isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(ResourceBooleanFlag("3", "test", 1003)))
+            .isTrue()
 
         Assert.assertThrows(NameNotFoundException::class.java) {
-            featureFlagsDebug.isEnabled(ResourceBooleanFlag("4", "test", 1004))
+            mFeatureFlagsClassicDebug.isEnabled(ResourceBooleanFlag("4", "test", 1004))
         }
         // Test that resource is loaded (and validated) even when the setting is set.
         //  This prevents developers from not noticing when they reference an invalid resource.
         Assert.assertThrows(NameNotFoundException::class.java) {
-            featureFlagsDebug.isEnabled(ResourceBooleanFlag("5", "test", 1005))
+            mFeatureFlagsClassicDebug.isEnabled(ResourceBooleanFlag("5", "test", 1005))
         }
     }
 
@@ -232,29 +197,27 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
             return@thenAnswer it.getArgument(1)
         }
 
-        assertThat(featureFlagsDebug.isEnabled(SysPropBooleanFlag("a", "test"))).isFalse()
-        assertThat(featureFlagsDebug.isEnabled(SysPropBooleanFlag("b", "test"))).isTrue()
-        assertThat(featureFlagsDebug.isEnabled(SysPropBooleanFlag("c", "test", true))).isTrue()
-        assertThat(
-            featureFlagsDebug.isEnabled(
-                SysPropBooleanFlag(
-                    "d",
-                    "test",
-                    false
-                )
-            )
-        ).isFalse()
-        assertThat(featureFlagsDebug.isEnabled(SysPropBooleanFlag("e", "test"))).isFalse()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(SysPropBooleanFlag("a", "test"))).isFalse()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(SysPropBooleanFlag("b", "test"))).isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(SysPropBooleanFlag("c", "test", true)))
+            .isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(SysPropBooleanFlag("d", "test", false)))
+            .isFalse()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(SysPropBooleanFlag("e", "test"))).isFalse()
     }
 
     @Test
     fun readStringFlag() {
         whenever(flagManager.readFlagValue<String>(eq("3"), any())).thenReturn("foo")
         whenever(flagManager.readFlagValue<String>(eq("4"), any())).thenReturn("bar")
-        assertThat(featureFlagsDebug.getString(StringFlag("1", "test", "biz"))).isEqualTo("biz")
-        assertThat(featureFlagsDebug.getString(StringFlag("2", "test", "baz"))).isEqualTo("baz")
-        assertThat(featureFlagsDebug.getString(StringFlag("3", "test", "buz"))).isEqualTo("foo")
-        assertThat(featureFlagsDebug.getString(StringFlag("4", "test", "buz"))).isEqualTo("bar")
+        assertThat(mFeatureFlagsClassicDebug.getString(StringFlag("1", "test", "biz")))
+            .isEqualTo("biz")
+        assertThat(mFeatureFlagsClassicDebug.getString(StringFlag("2", "test", "baz")))
+            .isEqualTo("baz")
+        assertThat(mFeatureFlagsClassicDebug.getString(StringFlag("3", "test", "buz")))
+            .isEqualTo("foo")
+        assertThat(mFeatureFlagsClassicDebug.getString(StringFlag("4", "test", "buz")))
+            .isEqualTo("bar")
     }
 
     @Test
@@ -270,44 +233,23 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         whenever(flagManager.readFlagValue<String>(eq("4"), any())).thenReturn("override4")
         whenever(flagManager.readFlagValue<String>(eq("6"), any())).thenReturn("override6")
 
-        assertThat(
-            featureFlagsDebug.getString(
-                ResourceStringFlag(
-                    "1",
-                    "test",
-                    1001
-                )
-            )
-        ).isEqualTo("")
-        assertThat(
-            featureFlagsDebug.getString(
-                ResourceStringFlag(
-                    "2",
-                    "test",
-                    1002
-                )
-            )
-        ).isEqualTo("resource2")
-        assertThat(
-            featureFlagsDebug.getString(
-                ResourceStringFlag(
-                    "3",
-                    "test",
-                    1003
-                )
-            )
-        ).isEqualTo("override3")
+        assertThat(mFeatureFlagsClassicDebug.getString(ResourceStringFlag("1", "test", 1001)))
+            .isEqualTo("")
+        assertThat(mFeatureFlagsClassicDebug.getString(ResourceStringFlag("2", "test", 1002)))
+            .isEqualTo("resource2")
+        assertThat(mFeatureFlagsClassicDebug.getString(ResourceStringFlag("3", "test", 1003)))
+            .isEqualTo("override3")
 
         Assert.assertThrows(NullPointerException::class.java) {
-            featureFlagsDebug.getString(ResourceStringFlag("4", "test", 1004))
+            mFeatureFlagsClassicDebug.getString(ResourceStringFlag("4", "test", 1004))
         }
         Assert.assertThrows(NameNotFoundException::class.java) {
-            featureFlagsDebug.getString(ResourceStringFlag("5", "test", 1005))
+            mFeatureFlagsClassicDebug.getString(ResourceStringFlag("5", "test", 1005))
         }
         // Test that resource is loaded (and validated) even when the setting is set.
         //  This prevents developers from not noticing when they reference an invalid resource.
         Assert.assertThrows(NameNotFoundException::class.java) {
-            featureFlagsDebug.getString(ResourceStringFlag("6", "test", 1005))
+            mFeatureFlagsClassicDebug.getString(ResourceStringFlag("6", "test", 1005))
         }
     }
 
@@ -315,10 +257,10 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
     fun readIntFlag() {
         whenever(flagManager.readFlagValue<Int>(eq("3"), any())).thenReturn(22)
         whenever(flagManager.readFlagValue<Int>(eq("4"), any())).thenReturn(48)
-        assertThat(featureFlagsDebug.getInt(IntFlag("1", "test", 12))).isEqualTo(12)
-        assertThat(featureFlagsDebug.getInt(IntFlag("2", "test", 93))).isEqualTo(93)
-        assertThat(featureFlagsDebug.getInt(IntFlag("3", "test", 8))).isEqualTo(22)
-        assertThat(featureFlagsDebug.getInt(IntFlag("4", "test", 234))).isEqualTo(48)
+        assertThat(mFeatureFlagsClassicDebug.getInt(IntFlag("1", "test", 12))).isEqualTo(12)
+        assertThat(mFeatureFlagsClassicDebug.getInt(IntFlag("2", "test", 93))).isEqualTo(93)
+        assertThat(mFeatureFlagsClassicDebug.getInt(IntFlag("3", "test", 8))).isEqualTo(22)
+        assertThat(mFeatureFlagsClassicDebug.getInt(IntFlag("4", "test", 234))).isEqualTo(48)
     }
 
     @Test
@@ -334,17 +276,20 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         whenever(flagManager.readFlagValue<Int>(eq("4"), any())).thenReturn(500)
         whenever(flagManager.readFlagValue<Int>(eq("5"), any())).thenReturn(9519)
 
-        assertThat(featureFlagsDebug.getInt(ResourceIntFlag("1", "test", 1001))).isEqualTo(88)
-        assertThat(featureFlagsDebug.getInt(ResourceIntFlag("2", "test", 1002))).isEqualTo(61)
-        assertThat(featureFlagsDebug.getInt(ResourceIntFlag("3", "test", 1003))).isEqualTo(20)
+        assertThat(mFeatureFlagsClassicDebug.getInt(ResourceIntFlag("1", "test", 1001)))
+            .isEqualTo(88)
+        assertThat(mFeatureFlagsClassicDebug.getInt(ResourceIntFlag("2", "test", 1002)))
+            .isEqualTo(61)
+        assertThat(mFeatureFlagsClassicDebug.getInt(ResourceIntFlag("3", "test", 1003)))
+            .isEqualTo(20)
 
         Assert.assertThrows(NotFoundException::class.java) {
-            featureFlagsDebug.getInt(ResourceIntFlag("4", "test", 1004))
+            mFeatureFlagsClassicDebug.getInt(ResourceIntFlag("4", "test", 1004))
         }
         // Test that resource is loaded (and validated) even when the setting is set.
         //  This prevents developers from not noticing when they reference an invalid resource.
         Assert.assertThrows(NotFoundException::class.java) {
-            featureFlagsDebug.getInt(ResourceIntFlag("5", "test", 1005))
+            mFeatureFlagsClassicDebug.getInt(ResourceIntFlag("5", "test", 1005))
         }
     }
 
@@ -424,11 +369,11 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         whenever(flagManager.readFlagValue<String>(eq("1"), any())).thenReturn("original")
 
         // gets the flag & cache it
-        assertThat(featureFlagsDebug.getString(flag1)).isEqualTo("original")
+        assertThat(mFeatureFlagsClassicDebug.getString(flag1)).isEqualTo("original")
         verify(flagManager, times(1)).readFlagValue(eq("1"), eq(StringFlagSerializer))
 
         // hit the cache
-        assertThat(featureFlagsDebug.getString(flag1)).isEqualTo("original")
+        assertThat(mFeatureFlagsClassicDebug.getString(flag1)).isEqualTo("original")
         verifyNoMoreInteractions(flagManager)
 
         // set the flag
@@ -436,7 +381,7 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         verifyPutData("1", "{\"type\":\"string\",\"value\":\"new\"}", numReads = 2)
         whenever(flagManager.readFlagValue<String>(eq("1"), any())).thenReturn("new")
 
-        assertThat(featureFlagsDebug.getString(flag1)).isEqualTo("new")
+        assertThat(mFeatureFlagsClassicDebug.getString(flag1)).isEqualTo("new")
         verify(flagManager, times(3)).readFlagValue(eq("1"), eq(StringFlagSerializer))
     }
 
@@ -446,7 +391,7 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
 
         serverFlagReader.setFlagValue(flag.namespace, flag.name, false)
 
-        assertThat(featureFlagsDebug.isEnabled(flag)).isFalse()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(flag)).isFalse()
     }
 
     @Test
@@ -454,32 +399,41 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
         val flag = UnreleasedFlag(name = "100", namespace = "test")
 
         serverFlagReader.setFlagValue(flag.namespace, flag.name, true)
-        assertThat(featureFlagsDebug.isEnabled(flag)).isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(flag)).isTrue()
     }
 
     @Test
     fun serverSide_OverrideUncached_NoRestart() {
         // No one has read the flag, so it's not in the cache.
         serverFlagReader.setFlagValue(
-            teamfoodableFlagA.namespace, teamfoodableFlagA.name, !teamfoodableFlagA.default)
+            teamfoodableFlagA.namespace,
+            teamfoodableFlagA.name,
+            !teamfoodableFlagA.default
+        )
         verify(restarter, never()).restartSystemUI(anyString())
     }
 
     @Test
     fun serverSide_Override_Restarts() {
         // Read it to put it in the cache.
-        featureFlagsDebug.isEnabled(teamfoodableFlagA)
+        mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagA)
         serverFlagReader.setFlagValue(
-            teamfoodableFlagA.namespace, teamfoodableFlagA.name, !teamfoodableFlagA.default)
+            teamfoodableFlagA.namespace,
+            teamfoodableFlagA.name,
+            !teamfoodableFlagA.default
+        )
         verify(restarter).restartSystemUI(anyString())
     }
 
     @Test
     fun serverSide_RedundantOverride_NoRestart() {
         // Read it to put it in the cache.
-        featureFlagsDebug.isEnabled(teamfoodableFlagA)
+        mFeatureFlagsClassicDebug.isEnabled(teamfoodableFlagA)
         serverFlagReader.setFlagValue(
-            teamfoodableFlagA.namespace, teamfoodableFlagA.name, teamfoodableFlagA.default)
+            teamfoodableFlagA.namespace,
+            teamfoodableFlagA.name,
+            teamfoodableFlagA.default
+        )
         verify(restarter, never()).restartSystemUI(anyString())
     }
 
@@ -500,13 +454,13 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
             .thenReturn("override7")
 
         // WHEN the flags have been accessed
-        assertThat(featureFlagsDebug.isEnabled(flag1)).isTrue()
-        assertThat(featureFlagsDebug.isEnabled(flag2)).isTrue()
-        assertThat(featureFlagsDebug.isEnabled(flag3)).isFalse()
-        assertThat(featureFlagsDebug.getString(flag4)).isEmpty()
-        assertThat(featureFlagsDebug.getString(flag5)).isEqualTo("flag5default")
-        assertThat(featureFlagsDebug.getString(flag6)).isEqualTo("resource1006")
-        assertThat(featureFlagsDebug.getString(flag7)).isEqualTo("override7")
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(flag1)).isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(flag2)).isTrue()
+        assertThat(mFeatureFlagsClassicDebug.isEnabled(flag3)).isFalse()
+        assertThat(mFeatureFlagsClassicDebug.getString(flag4)).isEmpty()
+        assertThat(mFeatureFlagsClassicDebug.getString(flag5)).isEqualTo("flag5default")
+        assertThat(mFeatureFlagsClassicDebug.getString(flag6)).isEqualTo("resource1006")
+        assertThat(mFeatureFlagsClassicDebug.getString(flag7)).isEqualTo("override7")
 
         // THEN the dump contains the flags and the default values
         val dump = dumpToString()
@@ -520,12 +474,15 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
     }
 
     private fun verifyPutData(name: String, data: String, numReads: Int = 1) {
-        inOrder(flagManager, globalSettings).apply {
-            verify(flagManager, times(numReads)).readFlagValue(eq(name), any<FlagSerializer<*>>())
-            verify(flagManager).nameToSettingsKey(eq(name))
-            verify(globalSettings).putStringForUser(eq("key-$name"), eq(data), anyInt())
-            verify(flagManager).dispatchListenersAndMaybeRestart(eq(name), any())
-        }.verifyNoMoreInteractions()
+        inOrder(flagManager, globalSettings)
+            .apply {
+                verify(flagManager, times(numReads))
+                    .readFlagValue(eq(name), any<FlagSerializer<*>>())
+                verify(flagManager).nameToSettingsKey(eq(name))
+                verify(globalSettings).putStringForUser(eq("key-$name"), eq(data), anyInt())
+                verify(flagManager).dispatchListenersAndMaybeRestart(eq(name), any())
+            }
+            .verifyNoMoreInteractions()
         verifyNoMoreInteractions(flagManager, globalSettings)
     }
 
@@ -545,7 +502,7 @@ class FeatureFlagsDebugTest : SysuiTestCase() {
     private fun dumpToString(): String {
         val sw = StringWriter()
         val pw = PrintWriter(sw)
-        featureFlagsDebug.dump(pw, emptyArray<String>())
+        mFeatureFlagsClassicDebug.dump(pw, emptyArray<String>())
         pw.flush()
         return sw.toString()
     }
diff --git a/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsReleaseTest.kt b/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsClassicReleaseTest.kt
index 16b459556cb9..70d6dd93459e 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsReleaseTest.kt
+++ b/packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsClassicReleaseTest.kt
@@ -26,16 +26,16 @@ import org.junit.Test
 import org.mockito.Mock
 import org.mockito.Mockito
 import org.mockito.Mockito.never
-import org.mockito.MockitoAnnotations
 import org.mockito.Mockito.`when` as whenever
+import org.mockito.MockitoAnnotations
 
 /**
  * NOTE: This test is for the version of FeatureFlagManager in src-release, which should not allow
  * overriding, and should never return any value other than the one provided as the default.
  */
 @SmallTest
-class FeatureFlagsReleaseTest : SysuiTestCase() {
-    private lateinit var featureFlagsRelease: FeatureFlagsRelease
+class FeatureFlagsClassicReleaseTest : SysuiTestCase() {
+    private lateinit var mFeatureFlagsClassicRelease: FeatureFlagsClassicRelease
 
     @Mock private lateinit var mResources: Resources
     @Mock private lateinit var mSystemProperties: SystemPropertiesHelper
@@ -43,21 +43,22 @@ class FeatureFlagsReleaseTest : SysuiTestCase() {
     private val flagMap = mutableMapOf<String, Flag<*>>()
     private val serverFlagReader = ServerFlagReaderFake()
 
-
     private val flagA = ReleasedFlag(name = "a", namespace = "test")
 
     @Before
     fun setup() {
         MockitoAnnotations.initMocks(this)
         flagMap.put(flagA.name, flagA)
-        featureFlagsRelease = FeatureFlagsRelease(
-            mResources,
-            mSystemProperties,
-            serverFlagReader,
-            flagMap,
-            restarter)
-
-        featureFlagsRelease.init()
+        mFeatureFlagsClassicRelease =
+            FeatureFlagsClassicRelease(
+                mResources,
+                mSystemProperties,
+                serverFlagReader,
+                flagMap,
+                restarter
+            )
+
+        mFeatureFlagsClassicRelease.init()
     }
 
     @Test
@@ -67,7 +68,7 @@ class FeatureFlagsReleaseTest : SysuiTestCase() {
         val flagNamespace = "test"
         val flag = ResourceBooleanFlag(flagName, flagNamespace, flagResourceId)
         whenever(mResources.getBoolean(flagResourceId)).thenReturn(true)
-        assertThat(featureFlagsRelease.isEnabled(flag)).isTrue()
+        assertThat(mFeatureFlagsClassicRelease.isEnabled(flag)).isTrue()
     }
 
     @Test
@@ -77,16 +78,16 @@ class FeatureFlagsReleaseTest : SysuiTestCase() {
         whenever(mResources.getString(1003)).thenReturn(null)
         whenever(mResources.getString(1004)).thenAnswer { throw NameNotFoundException() }
 
-        assertThat(featureFlagsRelease.getString(
-            ResourceStringFlag("1", "test", 1001))).isEqualTo("")
-        assertThat(featureFlagsRelease.getString(
-            ResourceStringFlag("2", "test", 1002))).isEqualTo("res2")
+        assertThat(mFeatureFlagsClassicRelease.getString(ResourceStringFlag("1", "test", 1001)))
+            .isEqualTo("")
+        assertThat(mFeatureFlagsClassicRelease.getString(ResourceStringFlag("2", "test", 1002)))
+            .isEqualTo("res2")
 
         assertThrows(NullPointerException::class.java) {
-            featureFlagsRelease.getString(ResourceStringFlag("3", "test", 1003))
+            mFeatureFlagsClassicRelease.getString(ResourceStringFlag("3", "test", 1003))
         }
         assertThrows(NameNotFoundException::class.java) {
-            featureFlagsRelease.getString(ResourceStringFlag("4", "test", 1004))
+            mFeatureFlagsClassicRelease.getString(ResourceStringFlag("4", "test", 1004))
         }
     }
 
@@ -98,7 +99,7 @@ class FeatureFlagsReleaseTest : SysuiTestCase() {
 
         val flag = SysPropBooleanFlag(flagName, flagNamespace, flagDefault)
         whenever(mSystemProperties.getBoolean(flagName, flagDefault)).thenReturn(flagDefault)
-        assertThat(featureFlagsRelease.isEnabled(flag)).isEqualTo(flagDefault)
+        assertThat(mFeatureFlagsClassicRelease.isEnabled(flag)).isEqualTo(flagDefault)
     }
 
     @Test
@@ -107,7 +108,7 @@ class FeatureFlagsReleaseTest : SysuiTestCase() {
 
         serverFlagReader.setFlagValue(flag.namespace, flag.name, false)
 
-        assertThat(featureFlagsRelease.isEnabled(flag)).isFalse()
+        assertThat(mFeatureFlagsClassicRelease.isEnabled(flag)).isFalse()
     }
 
     @Test
@@ -116,32 +117,29 @@ class FeatureFlagsReleaseTest : SysuiTestCase() {
 
         serverFlagReader.setFlagValue(flag.namespace, flag.name, true)
 
-        assertThat(featureFlagsRelease.isEnabled(flag)).isFalse()
+        assertThat(mFeatureFlagsClassicRelease.isEnabled(flag)).isFalse()
     }
 
     @Test
     fun serverSide_OverrideUncached_NoRestart() {
         // No one has read the flag, so it's not in the cache.
-        serverFlagReader.setFlagValue(
-            flagA.namespace, flagA.name, !flagA.default)
+        serverFlagReader.setFlagValue(flagA.namespace, flagA.name, !flagA.default)
         Mockito.verify(restarter, never()).restartSystemUI(Mockito.anyString())
     }
 
     @Test
     fun serverSide_Override_Restarts() {
         // Read it to put it in the cache.
-        featureFlagsRelease.isEnabled(flagA)
-        serverFlagReader.setFlagValue(
-            flagA.namespace, flagA.name, !flagA.default)
+        mFeatureFlagsClassicRelease.isEnabled(flagA)
+        serverFlagReader.setFlagValue(flagA.namespace, flagA.name, !flagA.default)
         Mockito.verify(restarter).restartSystemUI(Mockito.anyString())
     }
 
     @Test
     fun serverSide_RedundantOverride_NoRestart() {
         // Read it to put it in the cache.
-        featureFlagsRelease.isEnabled(flagA)
-        serverFlagReader.setFlagValue(
-            flagA.namespace, flagA.name, flagA.default)
+        mFeatureFlagsClassicRelease.isEnabled(flagA)
+        serverFlagReader.setFlagValue(flagA.namespace, flagA.name, flagA.default)
         Mockito.verify(restarter, never()).restartSystemUI(Mockito.anyString())
     }
 }
diff --git a/packages/SystemUI/tests/src/com/android/systemui/flags/FlagCommandTest.kt b/packages/SystemUI/tests/src/com/android/systemui/flags/FlagCommandTest.kt
index b02baa7fd1b5..7c1325e2b355 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/flags/FlagCommandTest.kt
+++ b/packages/SystemUI/tests/src/com/android/systemui/flags/FlagCommandTest.kt
@@ -30,7 +30,7 @@ import org.mockito.MockitoAnnotations
 @SmallTest
 class FlagCommandTest : SysuiTestCase() {
 
-    @Mock private lateinit var featureFlags: FeatureFlagsDebug
+    @Mock private lateinit var featureFlags: FeatureFlagsClassicDebug
     @Mock private lateinit var pw: PrintWriter
     private val flagMap = mutableMapOf<String, Flag<*>>()
     private val flagA = UnreleasedFlag("500", "test")
diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/flags/FakeFeatureFlags.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/flags/FakeFeatureFlags.kt
index 013dbb458c22..43c9c99744c5 100644
--- a/packages/SystemUI/tests/utils/src/com/android/systemui/flags/FakeFeatureFlags.kt
+++ b/packages/SystemUI/tests/utils/src/com/android/systemui/flags/FakeFeatureFlags.kt
@@ -18,7 +18,17 @@ package com.android.systemui.flags
 
 import java.io.PrintWriter
 
-class FakeFeatureFlags : FeatureFlags {
+class FakeFeatureFlagsClassic : FakeFeatureFlags()
+
+@Deprecated(
+    message = "Use FakeFeatureFlagsClassic instead.",
+    replaceWith =
+        ReplaceWith(
+            "FakeFeatureFlagsClassic",
+            "com.android.systemui.flags.FakeFeatureFlagsClassic",
+        ),
+)
+open class FakeFeatureFlags : FeatureFlagsClassic {
     private val booleanFlags = mutableMapOf<String, Boolean>()
     private val stringFlags = mutableMapOf<String, String>()
     private val intFlags = mutableMapOf<String, Int>()
@@ -66,12 +76,11 @@ class FakeFeatureFlags : FeatureFlags {
      * Set the given flag's default value if no other value has been set.
      *
      * REMINDER: You should always test your code with your flag in both configurations, so
-     *  generally you should be setting a particular value.  This method should be reserved for
-     *  situations where the flag needs to be read (e.g. in the class constructor), but its
-     *  value shouldn't affect the actual test cases. In those cases, it's mildly safer to use
-     *  this method than to hard-code `false` or `true` because then at least if you're wrong,
-     *  and the flag value *does* matter, you'll notice when the flag is flipped and tests
-     *  start failing.
+     * generally you should be setting a particular value. This method should be reserved for
+     * situations where the flag needs to be read (e.g. in the class constructor), but its value
+     * shouldn't affect the actual test cases. In those cases, it's mildly safer to use this method
+     * than to hard-code `false` or `true` because then at least if you're wrong, and the flag value
+     * *does* matter, you'll notice when the flag is flipped and tests start failing.
      */
     fun setDefault(flag: BooleanFlag) = booleanFlags.putIfAbsent(flag.name, flag.default)
 
@@ -79,12 +88,11 @@ class FakeFeatureFlags : FeatureFlags {
      * Set the given flag's default value if no other value has been set.
      *
      * REMINDER: You should always test your code with your flag in both configurations, so
-     *  generally you should be setting a particular value.  This method should be reserved for
-     *  situations where the flag needs to be read (e.g. in the class constructor), but its
-     *  value shouldn't affect the actual test cases. In those cases, it's mildly safer to use
-     *  this method than to hard-code `false` or `true` because then at least if you're wrong,
-     *  and the flag value *does* matter, you'll notice when the flag is flipped and tests
-     *  start failing.
+     * generally you should be setting a particular value. This method should be reserved for
+     * situations where the flag needs to be read (e.g. in the class constructor), but its value
+     * shouldn't affect the actual test cases. In those cases, it's mildly safer to use this method
+     * than to hard-code `false` or `true` because then at least if you're wrong, and the flag value
+     * *does* matter, you'll notice when the flag is flipped and tests start failing.
      */
     fun setDefault(flag: SysPropBooleanFlag) = booleanFlags.putIfAbsent(flag.name, flag.default)
 
@@ -123,10 +131,8 @@ class FakeFeatureFlags : FeatureFlags {
     }
 
     override fun removeListener(listener: FlagListenable.Listener) {
-        listenerflagNames.remove(listener)?.let {
-                flagNames -> flagNames.forEach {
-                        id -> flagListeners[id]?.remove(listener)
-                }
+        listenerflagNames.remove(listener)?.let { flagNames ->
+            flagNames.forEach { id -> flagListeners[id]?.remove(listener) }
         }
     }