Merge "Add new FeatureFlagsClassic alias" into main
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 f005bab..fae9fec 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 @@
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 927d4604b..7aacb4e 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 @@
])
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 b20e33a..83c239f 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 @@
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 95e7ad96..d48eb29 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 @@
*
* 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 @@
/** 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
similarity index 99%
rename from packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsDebug.java
rename to packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsClassicDebug.java
index 4c78e4c..126a1b5 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 @@
* 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 @@
};
@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
similarity index 98%
rename from packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsRelease.java
rename to packages/SystemUI/src/com/android/systemui/flags/FeatureFlagsClassicRelease.java
index e03b438..79ebf9c 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 @@
* 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 @@
};
@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 28c45b8..dd560b7 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 @@
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 f97112d..dfcc7ea 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 @@
) : 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 bd0ed48..e3cc2b0 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 @@
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 f0a048b..90e78c6 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 @@
* 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 3c50125..d13fa1e 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 @@
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 46e28a7..9f41b61 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 @@
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
similarity index 65%
rename from packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsDebugTest.kt
rename to packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsClassicDebugTest.kt
index ff15cb3..14c5ec0 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.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.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
+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
+ @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 @@
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()
- )
+ verify(mockContext).registerReceiver(capture(), any(), nullable(), nullable(), any())
}
- clearCacheAction = withArgCaptor {
- verify(flagManager).clearCacheAction = capture()
- }
+ clearCacheAction = withArgCaptor { verify(flagManager).clearCacheAction = capture() }
whenever(flagManager.nameToSettingsKey(any())).thenAnswer { "key-${it.arguments[0]}" }
}
@@ -117,45 +103,29 @@
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 @@
@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 @@
.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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
serverFlagReader.setFlagValue(flag.namespace, flag.name, false)
- assertThat(featureFlagsDebug.isEnabled(flag)).isFalse()
+ assertThat(mFeatureFlagsClassicDebug.isEnabled(flag)).isFalse()
}
@Test
@@ -454,32 +399,41 @@
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 @@
.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 @@
}
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 @@
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
similarity index 72%
rename from packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsReleaseTest.kt
rename to packages/SystemUI/tests/src/com/android/systemui/flags/FeatureFlagsClassicReleaseTest.kt
index 16b4595..70d6dd9 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.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 @@
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)
+ mFeatureFlagsClassicRelease =
+ FeatureFlagsClassicRelease(
+ mResources,
+ mSystemProperties,
+ serverFlagReader,
+ flagMap,
+ restarter
+ )
- featureFlagsRelease.init()
+ mFeatureFlagsClassicRelease.init()
}
@Test
@@ -67,7 +68,7 @@
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 @@
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 @@
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 @@
serverFlagReader.setFlagValue(flag.namespace, flag.name, false)
- assertThat(featureFlagsRelease.isEnabled(flag)).isFalse()
+ assertThat(mFeatureFlagsClassicRelease.isEnabled(flag)).isFalse()
}
@Test
@@ -116,32 +117,29 @@
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 b02baa7..7c1325e 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 @@
@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 013dbb4..43c9c99 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 @@
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 @@
* 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 @@
* 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 @@
}
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) }
}
}