Merge "Migrate alarms and other interruptions to modes_ui" into main

2024-05-21 17:12:26 +00:00
parent 890eecf2e4 3f2bcf973a
commit a24c7183d2
10 changed files with 812 additions and 0 deletions
--- a/tests/robotests/src/com/android/settings/notification/modes/ZenModeOtherLinkPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/notification/modes/ZenModeOtherLinkPreferenceControllerTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.notification.modes;
+
+import static android.app.NotificationManager.INTERRUPTION_FILTER_PRIORITY;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.app.AutomaticZenRule;
+import android.app.Flags;
+import android.content.Context;
+import android.net.Uri;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
+import android.service.notification.ZenPolicy;
+import androidx.preference.Preference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(RobolectricTestRunner.class)
+@EnableFlags(Flags.FLAG_MODES_UI)
+public final class ZenModeOtherLinkPreferenceControllerTest {
+
+    private ZenModeOtherLinkPreferenceController mController;
+
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
+    private Context mContext;
+    @Mock
+    private ZenModesBackend mBackend;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+
+        mContext = RuntimeEnvironment.application;
+
+        mController = new ZenModeOtherLinkPreferenceController(
+                mContext, "something", mBackend);
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_MODES_UI)
+    public void testHasSummary() {
+        Preference pref = mock(Preference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                .setType(AutomaticZenRule.TYPE_DRIVING)
+                .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                .setZenPolicy(new ZenPolicy.Builder().allowAllSounds().build())
+                .build(), true);
+        mController.updateZenMode(pref, zenMode);
+        verify(pref).setSummary(any());
+    }
+}
--- a/tests/robotests/src/com/android/settings/notification/modes/ZenModeOtherPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/notification/modes/ZenModeOtherPreferenceControllerTest.java
@@ -0,0 +1,277 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.notification.modes;
+
+import static android.app.NotificationManager.INTERRUPTION_FILTER_PRIORITY;
+import static android.service.notification.ZenPolicy.STATE_ALLOW;
+import static android.service.notification.ZenPolicy.STATE_UNSET;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.app.AutomaticZenRule;
+import android.app.Flags;
+import android.content.Context;
+import android.net.Uri;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
+import android.service.notification.ZenPolicy;
+import androidx.preference.TwoStatePreference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(RobolectricTestRunner.class)
+@EnableFlags(Flags.FLAG_MODES_UI)
+public final class ZenModeOtherPreferenceControllerTest {
+
+    private Context mContext;
+    @Mock
+    private ZenModesBackend mBackend;
+
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mContext = RuntimeEnvironment.application;
+    }
+
+    @Test
+    public void testUpdateState_alarms() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowAlarms(true).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_alarm", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        verify(preference).setChecked(true);
+    }
+
+    @Test
+    public void testOnPreferenceChange_alarms() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowAlarms(false).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_alarm", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        controller.onPreferenceChange(preference, true);
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryAlarms())
+                .isEqualTo(STATE_ALLOW);
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryEvents())
+                .isEqualTo(STATE_UNSET);
+    }
+
+    @Test
+    public void testUpdateState_media() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowMedia(true).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_media", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        verify(preference).setChecked(true);
+    }
+
+    @Test
+    public void testOnPreferenceChange_media() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowMedia(false).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_media", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        controller.onPreferenceChange(preference, true);
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryMedia())
+                .isEqualTo(STATE_ALLOW);
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryEvents())
+                .isEqualTo(STATE_UNSET);
+    }
+
+    @Test
+    public void testUpdateState_system() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowSystem(true).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_system", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        verify(preference).setChecked(true);
+    }
+
+    @Test
+    public void testOnPreferenceChange_system() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowSystem(false).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_system", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        controller.onPreferenceChange(preference, true);
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCategorySystem())
+                .isEqualTo(STATE_ALLOW);
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryEvents())
+                .isEqualTo(STATE_UNSET);
+    }
+
+    @Test
+    public void testUpdateState_reminders() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowReminders(true).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_reminders",
+                        mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        verify(preference).setChecked(true);
+    }
+
+    @Test
+    public void testOnPreferenceChange_reminders() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowReminders(false).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_reminders",
+                        mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        controller.onPreferenceChange(preference, true);
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryReminders())
+                .isEqualTo(STATE_ALLOW);
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryEvents())
+                .isEqualTo(STATE_UNSET);
+    }
+
+    @Test
+    public void testUpdateState_events() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowEvents(true).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_events", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        verify(preference).setChecked(true);
+    }
+
+    @Test
+    public void testOnPreferenceChange_events() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowEvents(false).build())
+                        .build(), true);
+
+        ZenModeOtherPreferenceController controller =
+                new ZenModeOtherPreferenceController(mContext, "modes_category_events", mBackend);
+
+        controller.updateZenMode(preference, zenMode);
+
+        controller.onPreferenceChange(preference, true);
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryEvents())
+                .isEqualTo(STATE_ALLOW);
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryAlarms())
+                .isEqualTo(STATE_UNSET);
+    }
+}
--- a/tests/robotests/src/com/android/settings/notification/modes/ZenModeRepeatCallersPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/notification/modes/ZenModeRepeatCallersPreferenceControllerTest.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.notification.modes;
+
+import static android.app.NotificationManager.INTERRUPTION_FILTER_PRIORITY;
+import static android.service.notification.ZenPolicy.PEOPLE_TYPE_ANYONE;
+import static android.service.notification.ZenPolicy.PEOPLE_TYPE_STARRED;
+import static android.service.notification.ZenPolicy.STATE_ALLOW;
+import static android.service.notification.ZenPolicy.STATE_DISALLOW;
+import static android.service.notification.ZenPolicy.STATE_UNSET;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.app.AutomaticZenRule;
+import android.app.Flags;
+import android.content.Context;
+import android.net.Uri;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
+import android.service.notification.ZenPolicy;
+import androidx.preference.TwoStatePreference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(RobolectricTestRunner.class)
+@EnableFlags(Flags.FLAG_MODES_UI)
+public final class ZenModeRepeatCallersPreferenceControllerTest {
+
+    private Context mContext;
+    @Mock
+    private ZenModesBackend mBackend;
+
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mContext = RuntimeEnvironment.application;
+    }
+
+    @Test
+    public void testUpdateState_allCalls() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder()
+                                .allowCalls(PEOPLE_TYPE_ANYONE)
+                                .build())
+                        .build(), true);
+
+        ZenModeRepeatCallersPreferenceController controller =
+                new ZenModeRepeatCallersPreferenceController(mContext, "repeat", mBackend, 1);
+
+        controller.updateZenMode(preference, zenMode);
+
+        verify(preference).setChecked(true);
+        verify(preference).setEnabled(false);
+    }
+
+    @Test
+    public void testUpdateState_someCalls() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder()
+                                .allowCalls(PEOPLE_TYPE_STARRED)
+                                .allowRepeatCallers(true)
+                                .build())
+                        .build(), true);
+
+        ZenModeRepeatCallersPreferenceController controller =
+                new ZenModeRepeatCallersPreferenceController(mContext, "repeat", mBackend, 1);
+
+        controller.updateZenMode(preference, zenMode);
+
+        verify(preference).setChecked(true);
+        verify(preference).setEnabled(true);
+    }
+
+    @Test
+    public void testOnPreferenceChange() {
+        TwoStatePreference preference = mock(TwoStatePreference.class);
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder().allowRepeatCallers(true).build())
+                        .build(), true);
+
+        ZenModeRepeatCallersPreferenceController controller =
+                new ZenModeRepeatCallersPreferenceController(mContext, "repeat", mBackend, 1);
+
+        controller.updateZenMode(preference, zenMode);
+
+        controller.onPreferenceChange(preference, false);
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryRepeatCallers())
+                .isEqualTo(STATE_DISALLOW);
+        assertThat(captor.getValue().getPolicy().getPriorityCategoryEvents())
+                .isEqualTo(STATE_UNSET);
+        assertThat(captor.getValue().getPolicy().getPriorityCallSenders())
+                .isEqualTo(STATE_UNSET);
+    }
+}
--- a/tests/robotests/src/com/android/settings/notification/modes/ZenModesSummaryHelperTest.java
+++ b/tests/robotests/src/com/android/settings/notification/modes/ZenModesSummaryHelperTest.java
@@ -85,4 +85,84 @@ public class ZenModesSummaryHelperTest {

        assertThat(mSummaryHelper.getPeopleSummary(zenMode)).isEqualTo("All people can interrupt");
    }
+
+    @Test
+    public void getOtherSoundCategoriesSummary_single() {
+        AutomaticZenRule rule = new AutomaticZenRule.Builder("Bedtime", Uri.parse("bed"))
+                .setType(AutomaticZenRule.TYPE_BEDTIME)
+                .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                .setZenPolicy(new ZenPolicy.Builder().allowAlarms(true).build())
+                .build();
+        ZenMode zenMode = new ZenMode("id", rule, true);
+
+        assertThat(mSummaryHelper.getOtherSoundCategoriesSummary(zenMode)).isEqualTo(
+                "Alarms can interrupt");
+    }
+
+    @Test
+    public void getOtherSoundCategoriesSummary_duo() {
+        AutomaticZenRule rule = new AutomaticZenRule.Builder("Bedtime", Uri.parse("bed"))
+                .setType(AutomaticZenRule.TYPE_BEDTIME)
+                .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                .setZenPolicy(new ZenPolicy.Builder().allowAlarms(true).allowMedia(true).build())
+                .build();
+        ZenMode zenMode = new ZenMode("id", rule, true);
+
+        assertThat(mSummaryHelper.getOtherSoundCategoriesSummary(zenMode)).isEqualTo(
+                "Alarms and media can interrupt");
+    }
+
+    @Test
+    public void getOtherSoundCategoriesSummary_trio() {
+        AutomaticZenRule rule = new AutomaticZenRule.Builder("Bedtime", Uri.parse("bed"))
+                .setType(AutomaticZenRule.TYPE_BEDTIME)
+                .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                .setZenPolicy(new ZenPolicy.Builder()
+                        .allowAlarms(true)
+                        .allowMedia(true)
+                        .allowSystem(true)
+                        .build())
+                .build();
+        ZenMode zenMode = new ZenMode("id", rule, true);
+
+        assertThat(mSummaryHelper.getOtherSoundCategoriesSummary(zenMode)).isEqualTo(
+                "Alarms, media, and touch sounds can interrupt");
+    }
+
+    @Test
+    public void getOtherSoundCategoriesSummary_quad() {
+        AutomaticZenRule rule = new AutomaticZenRule.Builder("Bedtime", Uri.parse("bed"))
+                .setType(AutomaticZenRule.TYPE_BEDTIME)
+                .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                .setZenPolicy(new ZenPolicy.Builder()
+                        .allowAlarms(true)
+                        .allowMedia(true)
+                        .allowSystem(true)
+                        .allowReminders(true)
+                        .build())
+                .build();
+        ZenMode zenMode = new ZenMode("id", rule, true);
+
+        assertThat(mSummaryHelper.getOtherSoundCategoriesSummary(zenMode)).isEqualTo(
+                "Alarms, media, and 2 more can interrupt");
+    }
+
+    @Test
+    public void getOtherSoundCategoriesSummary_all() {
+        AutomaticZenRule rule = new AutomaticZenRule.Builder("Bedtime", Uri.parse("bed"))
+                .setType(AutomaticZenRule.TYPE_BEDTIME)
+                .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                .setZenPolicy(new ZenPolicy.Builder()
+                        .allowAlarms(true)
+                        .allowMedia(true)
+                        .allowSystem(true)
+                        .allowReminders(true)
+                        .allowEvents(true)
+                        .build())
+                .build();
+        ZenMode zenMode = new ZenMode("id", rule, true);
+
+        assertThat(mSummaryHelper.getOtherSoundCategoriesSummary(zenMode)).isEqualTo(
+                "Alarms, media, and 3 more can interrupt");
+    }
 }