Merge "Add controllers for default app shortcut preferences."

tests/robotests/src/com/android/settings/applications/AppInfoDashboardFragmentTest.java

@@ -73,8 +73,7 @@ import java.util.HashSet;
 @RunWith(SettingsRobolectricTestRunner.class)
 @Config(
     manifest = TestConfig.MANIFEST_PATH,
-    sdk = TestConfig.SDK_VERSION_O,
-    shadows = AppInfoDashboardFragmentTest.ShadowUtils.class
+    sdk = TestConfig.SDK_VERSION_O
 )
 public final class AppInfoDashboardFragmentTest {
 
@@ -369,6 +368,7 @@ public final class AppInfoDashboardFragmentTest {
     }
 
     @Test
+    @Config(shadows = ShadowUtils.class)
     public void handleDisableable_appIsEnabled_buttonShouldWork() {
         final ApplicationInfo info = new ApplicationInfo();
         info.packageName = "pkg";
@@ -411,6 +411,7 @@ public final class AppInfoDashboardFragmentTest {
     }
 
     @Test
+    @Config(shadows = ShadowUtils.class)
     public void handleDisableable_appIsEnabledAndInKeepEnabledWhitelist_buttonShouldNotWork() {
         final ApplicationInfo info = new ApplicationInfo();
         info.packageName = "pkg";

tests/robotests/src/com/android/settings/applications/appinfo/DefaultAppShortcutPreferenceControllerBaseTest.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2017 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.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.os.UserManager;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settings.SettingsActivity;
+import com.android.settings.TestConfig;
+import com.android.settings.applications.AppInfoDashboardFragment;
+import com.android.settings.applications.DefaultAppSettings;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultAppShortcutPreferenceControllerBaseTest {
+
+    @Mock
+    private UserManager mUserManager;
+    @Mock
+    private AppInfoDashboardFragment mFragment;
+    @Mock
+    private PreferenceScreen mScreen;
+    @Mock
+    private Preference mPreference;
+
+    private Context mContext;
+    private TestPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);
+        mController = new TestPreferenceController(mContext, mFragment);
+        final String key = mController.getPreferenceKey();
+        when(mPreference.getKey()).thenReturn(key);
+    }
+
+    @Test
+    public void getAvailabilityStatus_managedProfile_shouldReturnDisabled() {
+        when(mUserManager.isManagedProfile()).thenReturn(true);
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(mController.DISABLED_FOR_USER);
+    }
+
+    @Test
+    public void getAvailabilityStatus_hasAppCapability_shouldReturnAvailable() {
+        mController.capable = true;
+        when(mUserManager.isManagedProfile()).thenReturn(false);
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(mController.AVAILABLE);
+    }
+
+    @Test
+    public void getAvailabilityStatus_noAppCapability_shouldReturnDisabled() {
+        mController.capable = false;
+        when(mUserManager.isManagedProfile()).thenReturn(false);
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(mController.DISABLED_UNSUPPORTED);
+    }
+
+    @Test
+    public void updateState_isDefaultApp_shouldSetSummaryToYes() {
+        mController.isDefault = true;
+
+        mController.updateState(mPreference);
+
+        verify(mPreference).setSummary(R.string.yes);
+    }
+
+    @Test
+    public void updateState_notDefaultApp_shouldSetSummaryToNo() {
+        mController.isDefault = false;
+
+        mController.updateState(mPreference);
+
+        verify(mPreference).setSummary(R.string.no);
+    }
+
+    @Test
+    public void handlePreferenceTreeClick_shouldStartDefaultAppSettings() {
+        mController.handlePreferenceTreeClick(mPreference);
+
+        verify(mContext).startActivity(argThat(intent-> intent != null
+                && intent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT).equals(
+                        DefaultAppSettings.class.getName())
+                && intent.getBundleExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS)
+                .getString(SettingsActivity.EXTRA_FRAGMENT_ARG_KEY).equals("TestKey")));
+    }
+
+    private class TestPreferenceController extends DefaultAppShortcutPreferenceControllerBase {
+
+        private boolean isDefault;
+        private boolean capable;
+
+        public TestPreferenceController(Context context, AppInfoDashboardFragment parent) {
+            super(context, "TestKey", "TestPackage");
+        }
+
+        @Override
+        protected boolean hasAppCapability() {
+            return capable;
+        }
+
+        @Override
+        protected boolean isDefaultApp() {
+            return isDefault;
+        }
+
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultBrowserShortcutPreferenceControllerTest.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2017 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.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+
+import com.android.settings.TestConfig;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultBrowserShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultBrowserShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultBrowserShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultBrowser() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_browser");
+    }
+
+    @Test
+    public void hasAppCapability_hasBrowserCapability_shouldReturnTrue() {
+        List<ResolveInfo> resolveInfos = new ArrayList<>();
+        resolveInfos.add(new ResolveInfo());
+        when(mPackageManager.queryIntentActivities(argThat(intent-> intent != null
+                && intent.getCategories().contains(Intent.CATEGORY_BROWSABLE)), anyInt()))
+                .thenReturn(resolveInfos);
+
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noBrowserCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    public void isDefaultApp_isDefaultBrowser_shouldReturnTrue() {
+        when(mPackageManager.getDefaultBrowserPackageNameAsUser(anyInt())).thenReturn("Package1");
+
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultBrowser_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultEmergencyShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.provider.Settings;
+import android.telephony.TelephonyManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultEmergencyShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultEmergencyShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultEmergencyShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultEmergency() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_emergency_app");
+    }
+
+    @Test
+    public void hasAppCapability_hasEmergencyCapability_shouldReturnTrue() {
+        List<ResolveInfo> resolveInfos = new ArrayList<>();
+        resolveInfos.add(new ResolveInfo());
+        when(mPackageManager.queryIntentActivities(argThat(intent-> intent != null
+                && intent.getAction().equals(TelephonyManager.ACTION_EMERGENCY_ASSISTANCE)),
+                anyInt())).thenReturn(resolveInfos);
+
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noEmergencyCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    public void isDefaultApp_isDefaultEmergency_shouldReturnTrue() {
+        Settings.Secure.putString(mContext.getContentResolver(),
+                Settings.Secure.EMERGENCY_ASSISTANCE_APPLICATION, "Package1");
+
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultEmergency_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultHomeShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.applications.defaultapps.DefaultHomePreferenceController;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultHomeShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultHomeShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultHomeShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultHome() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_home");
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultHomePreferenceController.class)
+    public void hasAppCapability_hasHomeCapability_shouldReturnTrue() {
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noHomeCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    public void isDefaultApp_isDefaultHome_shouldReturnTrue() {
+        when(mPackageManager.getHomeActivities(anyList()))
+                .thenReturn(new ComponentName("Package1", "cls1"));
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultHome_shouldReturnFalse() {
+        when(mPackageManager.getHomeActivities(anyList()))
+                .thenReturn(new ComponentName("pkg2", "cls1"));
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+    @Implements(DefaultHomePreferenceController.class)
+    public static class ShadowDefaultHomePreferenceController {
+        @Implementation
+        public static boolean hasHomePreference(String pkg, Context context) {
+            return true;
+        }
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultPhoneShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.applications.defaultapps.DefaultPhonePreferenceController;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultPhoneShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultPhoneShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultPhoneShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultPhone() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_phone_app");
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultPhonePreferenceController.class)
+    public void hasAppCapability_hasPhoneCapability_shouldReturnTrue() {
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noPhoneCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultPhonePreferenceController.class)
+    public void isDefaultApp_isDefaultPhone_shouldReturnTrue() {
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultPhone_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+    @Implements(DefaultPhonePreferenceController.class)
+    public static class ShadowDefaultPhonePreferenceController {
+        @Implementation
+        public static boolean hasPhonePreference(String pkg, Context context) {
+            return true;
+        }
+
+        @Implementation
+        public static boolean isPhoneDefault(String pkg, Context context) {
+            return true;
+        }
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultSmsShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.applications.defaultapps.DefaultSmsPreferenceController;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultSmsShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultSmsShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultSmsShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultSms() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_sms_app");
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultSmsPreferenceController.class)
+    public void hasAppCapability_hasSmsCapability_shouldReturnTrue() {
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noSmsCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultSmsPreferenceController.class)
+    public void isDefaultApp_isDefaultSms_shouldReturnTrue() {
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultSms_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+    @Implements(DefaultSmsPreferenceController.class)
+    public static class ShadowDefaultSmsPreferenceController {
+        @Implementation
+        public static boolean hasSmsPreference(String pkg, Context context) {
+            return true;
+        }
+
+        @Implementation
+        public static boolean isSmsDefault(String pkg, Context context) {
+            return true;
+        }
+    }
+
+}