Merge "Refactor background optimization mode in Power Usage Detail page." into main

2023-11-01 05:04:56 +00:00
parent d624b575a6 81e028931a
commit bd01c83944
19 changed files with 1085 additions and 400 deletions
--- a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java
@@ -17,6 +17,7 @@
 package com.android.settings.fuelgauge;

 import static com.android.settings.SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS;
+import static com.android.settings.fuelgauge.BatteryOptimizeHistoricalLogEntry.Action;

 import static com.google.common.truth.Truth.assertThat;

@@ -53,13 +54,12 @@ import com.android.settings.testutils.FakeFeatureFactory;
 import com.android.settings.testutils.shadow.ShadowActivityManager;
 import com.android.settings.testutils.shadow.ShadowEntityHeaderController;
 import com.android.settings.widget.EntityHeaderController;
+import com.android.settingslib.PrimarySwitchPreference;
 import com.android.settingslib.applications.AppUtils;
 import com.android.settingslib.applications.ApplicationsState;
 import com.android.settingslib.applications.instantapps.InstantAppDataProvider;
 import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
-import com.android.settingslib.widget.FooterPreference;
 import com.android.settingslib.widget.LayoutPreference;
-import com.android.settingslib.widget.SelectorWithWidgetPreference;

 import org.junit.After;
 import org.junit.Before;
@@ -95,9 +95,7 @@ public class AdvancedPowerUsageDetailTest {
    private static final long FOREGROUND_SERVICE_TIME_MS = 444;
    private static final long FOREGROUND_TIME_MS =
            FOREGROUND_ACTIVITY_TIME_MS + FOREGROUND_SERVICE_TIME_MS;
-    private static final String KEY_PREF_UNRESTRICTED = "unrestricted_pref";
-    private static final String KEY_PREF_OPTIMIZED = "optimized_pref";
-    private static final String KEY_PREF_RESTRICTED = "restricted_pref";
+    private static final String KEY_ALLOW_BACKGROUND_USAGE = "allow_background_usage";

    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
    private FragmentActivity mActivity;
@@ -127,10 +125,7 @@ public class AdvancedPowerUsageDetailTest {
    private BackupManager mBackupManager;

    private Context mContext;
-    private FooterPreference mFooterPreference;
-    private SelectorWithWidgetPreference mRestrictedPreference;
-    private SelectorWithWidgetPreference mOptimizePreference;
-    private SelectorWithWidgetPreference mUnrestrictedPreference;
+    private PrimarySwitchPreference mAllowBackgroundUsagePreference;
    private AdvancedPowerUsageDetail mFragment;
    private SettingsActivity mTestActivity;
    private FakeFeatureFactory mFeatureFactory;
@@ -198,14 +193,9 @@ public class AdvancedPowerUsageDetailTest {
                nullable(UserHandle.class));
        doAnswer(callable).when(mActivity).startActivity(captor.capture());

-        mFooterPreference = new FooterPreference(mContext);
-        mRestrictedPreference = new SelectorWithWidgetPreference(mContext);
-        mOptimizePreference = new SelectorWithWidgetPreference(mContext);
-        mUnrestrictedPreference = new SelectorWithWidgetPreference(mContext);
-        mFragment.mFooterPreference = mFooterPreference;
-        mFragment.mRestrictedPreference = mRestrictedPreference;
-        mFragment.mOptimizePreference = mOptimizePreference;
-        mFragment.mUnrestrictedPreference = mUnrestrictedPreference;
+        mAllowBackgroundUsagePreference = new PrimarySwitchPreference(mContext);
+        mAllowBackgroundUsagePreference.setKey(KEY_ALLOW_BACKGROUND_USAGE);
+        mFragment.mAllowBackgroundUsagePreference = mAllowBackgroundUsagePreference;
    }

    @After
@@ -307,70 +297,60 @@ public class AdvancedPowerUsageDetailTest {
    }

    @Test
-    public void initPreferenceForTriState_isValidPackageName_hasCorrectString() {
+    public void initFooter_isValidPackageName_hasCorrectString() {
        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(true);

-        mFragment.initPreferenceForTriState(mContext);
+        mFragment.initFooter();

-        assertThat(mFooterPreference.getTitle().toString())
+        assertThat(mAllowBackgroundUsagePreference.getSummary().toString())
                .isEqualTo("This app requires optimized battery usage.");
    }

    @Test
-    public void initPreferenceForTriState_isSystemOrDefaultApp_hasCorrectString() {
+    public void initFooter_isSystemOrDefaultApp_hasCorrectString() {
        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);

-        mFragment.initPreferenceForTriState(mContext);
+        mFragment.initFooter();

-        assertThat(mFooterPreference.getTitle()
-                .toString()).isEqualTo("This app requires unrestricted battery usage.");
+        assertThat(mAllowBackgroundUsagePreference.getSummary().toString())
+                .isEqualTo("This app requires unrestricted battery usage.");
    }

    @Test
-    public void initPreferenceForTriState_hasCorrectString() {
+    public void initFooter_hasCorrectString() {
        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(false);

-        mFragment.initPreferenceForTriState(mContext);
+        mFragment.initFooter();

-        assertThat(mFooterPreference.getTitle().toString())
-                .isEqualTo("Changing how an app uses your battery can affect its performance.");
-    }
-
-    @Test
-    public void onRadioButtonClicked_clickOptimizePref_optimizePreferenceChecked() {
-        mOptimizePreference.setKey(KEY_PREF_OPTIMIZED);
-        mRestrictedPreference.setKey(KEY_PREF_RESTRICTED);
-        mUnrestrictedPreference.setKey(KEY_PREF_UNRESTRICTED);
-        mFragment.onRadioButtonClicked(mOptimizePreference);
-
-        assertThat(mOptimizePreference.isChecked()).isTrue();
-        assertThat(mRestrictedPreference.isChecked()).isFalse();
-        assertThat(mUnrestrictedPreference.isChecked()).isFalse();
+        assertThat(mAllowBackgroundUsagePreference.getSummary().toString())
+                .isEqualTo("Enable for real-time updates, disable to save battery");
    }

    @Test
    public void onPause_optimizationModeChanged_logPreference()
            throws PackageManager.NameNotFoundException, InterruptedException {
        final String packageName = "testPackageName";
-        final int mode = BatteryOptimizeUtils.MODE_RESTRICTED;
-        mFragment.mOptimizationMode = mode;
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(mode);
+        final int restrictedMode = BatteryOptimizeUtils.MODE_RESTRICTED;
+        final int optimizedMode = BatteryOptimizeUtils.MODE_OPTIMIZED;
+        mFragment.mOptimizationMode = restrictedMode;
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(restrictedMode);
        when(mBatteryOptimizeUtils.getPackageName()).thenReturn(packageName);
        when(mContext.getPackageManager()).thenReturn(mPackageManager);
        when(mPackageManager.getInstallSourceInfo(anyString())).thenReturn(mInstallSourceInfo);
        when(mInstallSourceInfo.getInitiatingPackageName()).thenReturn("com.android.vending");
-        mOptimizePreference.setKey(KEY_PREF_OPTIMIZED);

-        mFragment.onRadioButtonClicked(mOptimizePreference);
+        mFragment.onPreferenceChange(mAllowBackgroundUsagePreference, true);
+        verify(mBatteryOptimizeUtils).setAppUsageState(optimizedMode, Action.APPLY);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(optimizedMode);
        mFragment.onPause();

        TimeUnit.SECONDS.sleep(1);
        verify(mMetricsFeatureProvider)
                .action(
                        SettingsEnums.OPEN_APP_BATTERY_USAGE,
-                        SettingsEnums.ACTION_APP_BATTERY_USAGE_OPTIMIZED,
+                        SettingsEnums.ACTION_APP_BATTERY_USAGE_ALLOW_BACKGROUND,
                        SettingsEnums.OPEN_APP_BATTERY_USAGE,
                        packageName,
                        /* consumed battery */ 0);
@@ -379,15 +359,20 @@ public class AdvancedPowerUsageDetailTest {
    @Test
    public void onPause_optimizationModeIsNotChanged_notInvokeLogging()
            throws PackageManager.NameNotFoundException, InterruptedException {
-        final int mode = BatteryOptimizeUtils.MODE_OPTIMIZED;
-        mFragment.mOptimizationMode = mode;
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(mode);
+        final int restrictedMode = BatteryOptimizeUtils.MODE_RESTRICTED;
+        final int optimizedMode = BatteryOptimizeUtils.MODE_OPTIMIZED;
+        mFragment.mOptimizationMode = restrictedMode;
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(restrictedMode);
        when(mContext.getPackageManager()).thenReturn(mPackageManager);
        when(mPackageManager.getInstallSourceInfo(anyString())).thenReturn(mInstallSourceInfo);
        when(mInstallSourceInfo.getInitiatingPackageName()).thenReturn("com.android.vending");
-        mOptimizePreference.setKey(KEY_PREF_OPTIMIZED);

-        mFragment.onRadioButtonClicked(mOptimizePreference);
+        mFragment.onPreferenceChange(mAllowBackgroundUsagePreference, true);
+        verify(mBatteryOptimizeUtils).setAppUsageState(optimizedMode, Action.APPLY);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(optimizedMode);
+        mFragment.onPreferenceChange(mAllowBackgroundUsagePreference, false);
+        verify(mBatteryOptimizeUtils).setAppUsageState(restrictedMode, Action.APPLY);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(restrictedMode);
        mFragment.onPause();

        TimeUnit.SECONDS.sleep(1);
--- a/tests/robotests/src/com/android/settings/fuelgauge/AllowBackgroundPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/AllowBackgroundPreferenceControllerTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2023 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.fuelgauge;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import com.android.settingslib.widget.MainSwitchPreference;
+
+import org.junit.Before;
+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)
+public class AllowBackgroundPreferenceControllerTest {
+    private static final int UID = 12345;
+    private static final String PACKAGE_NAME = "com.android.app";
+
+    private AllowBackgroundPreferenceController mController;
+    private MainSwitchPreference mMainSwitchPreference;
+    private BatteryOptimizeUtils mBatteryOptimizeUtils;
+
+    @Mock private PackageManager mMockPackageManager;
+
+    @Before
+    public void setUp() throws Exception {
+        MockitoAnnotations.initMocks(this);
+
+        Context context = spy(RuntimeEnvironment.application);
+        BatteryUtils.getInstance(context).reset();
+        doReturn(UID)
+                .when(mMockPackageManager)
+                .getPackageUid(PACKAGE_NAME, PackageManager.GET_META_DATA);
+
+        mController = new AllowBackgroundPreferenceController(context, UID, PACKAGE_NAME);
+        mMainSwitchPreference = new MainSwitchPreference(RuntimeEnvironment.application);
+        mBatteryOptimizeUtils = spy(new BatteryOptimizeUtils(context, UID, PACKAGE_NAME));
+        mController.mBatteryOptimizeUtils = mBatteryOptimizeUtils;
+    }
+
+    @Test
+    public void testUpdateState_isValidPackage_prefEnabled() {
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(false);
+
+        mController.updateState(mMainSwitchPreference);
+
+        assertThat(mBatteryOptimizeUtils.isOptimizeModeMutable()).isTrue();
+        assertThat(mMainSwitchPreference.isEnabled()).isTrue();
+    }
+
+    @Test
+    public void testUpdateState_invalidPackage_prefDisabled() {
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(true);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(false);
+
+        mController.updateState(mMainSwitchPreference);
+
+        assertThat(mBatteryOptimizeUtils.isOptimizeModeMutable()).isFalse();
+        assertThat(mMainSwitchPreference.isEnabled()).isFalse();
+    }
+
+    @Test
+    public void testUpdateState_isSystemOrDefaultAppAndRestrictedStates_prefChecked() {
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+                BatteryOptimizeUtils.MODE_RESTRICTED);
+
+        mController.updateState(mMainSwitchPreference);
+
+        assertThat(mMainSwitchPreference.isEnabled()).isFalse();
+        assertThat(mMainSwitchPreference.isChecked()).isFalse();
+    }
+
+    @Test
+    public void testUpdateState_isSystemOrDefaultApp_prefUnchecked() {
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+                BatteryOptimizeUtils.MODE_OPTIMIZED);
+
+        mController.updateState(mMainSwitchPreference);
+
+        assertThat(mMainSwitchPreference.isEnabled()).isFalse();
+        assertThat(mMainSwitchPreference.isChecked()).isTrue();
+    }
+
+    @Test
+    public void testUpdateState_isRestrictedStates_prefChecked() {
+        when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+                BatteryOptimizeUtils.MODE_RESTRICTED);
+
+        mController.updateState(mMainSwitchPreference);
+
+        assertThat(mMainSwitchPreference.isEnabled()).isTrue();
+        assertThat(mMainSwitchPreference.isChecked()).isFalse();
+    }
+
+    @Test
+    public void testUpdateState_prefUnchecked() {
+        when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+                BatteryOptimizeUtils.MODE_OPTIMIZED);
+
+        mController.updateState(mMainSwitchPreference);
+
+        assertThat(mMainSwitchPreference.isEnabled()).isTrue();
+        assertThat(mMainSwitchPreference.isChecked()).isTrue();
+    }
+
+    @Test
+    public void testHandlePreferenceTreeClick_samePrefKey_verifyAction() {
+        mMainSwitchPreference.setKey(
+                AllowBackgroundPreferenceController.KEY_ALLOW_BACKGROUND_USAGE);
+        mController.handlePreferenceTreeClick(mMainSwitchPreference);
+
+        assertThat(mController.handlePreferenceTreeClick(mMainSwitchPreference)).isTrue();
+    }
+
+    @Test
+    public void testHandlePreferenceTreeClick_incorrectPrefKey_noAction() {
+        assertThat(mController.handlePreferenceTreeClick(mMainSwitchPreference)).isFalse();
+    }
+}
--- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryBackupHelperTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryBackupHelperTest.java
@@ -121,6 +121,7 @@ public final class BatteryBackupHelperTest {
        mContext = spy(RuntimeEnvironment.application);
        mStringWriter = new StringWriter();
        mPrintWriter = new PrintWriter(mStringWriter);
+        BatteryUtils.getInstance(mContext).reset();
        doReturn(mContext).when(mContext).getApplicationContext();
        doReturn(mAppOpsManager).when(mContext).getSystemService(AppOpsManager.class);
        doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
--- a/tests/robotests/src/com/android/settings/fuelgauge/BatterySettingsMigrateCheckerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/BatterySettingsMigrateCheckerTest.java
@@ -31,10 +31,8 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.os.UserHandle;
-import android.os.UserManager;

 import com.android.settings.TestUtils;
-import com.android.settings.fuelgauge.BatteryOptimizeHistoricalLogEntry;
 import com.android.settings.fuelgauge.batterysaver.BatterySaverScheduleRadioButtonsController;

 import org.junit.After;
@@ -75,6 +73,7 @@ public final class BatterySettingsMigrateCheckerTest {
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
        mContext = spy(RuntimeEnvironment.application);
+        BatteryUtils.getInstance(mContext).reset();
        doReturn(mContext).when(mContext).getApplicationContext();
        doReturn(mPackageManager).when(mContext).getPackageManager();
        doReturn(UID).when(mPackageManager)
--- a/tests/robotests/src/com/android/settings/fuelgauge/OptimizedPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/OptimizedPreferenceControllerTest.java
@@ -18,8 +18,13 @@ package com.android.settings.fuelgauge;

 import static com.google.common.truth.Truth.assertThat;

+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;

+import android.content.Context;
+import android.content.pm.PackageManager;
+
 import com.android.settingslib.widget.SelectorWithWidgetPreference;

 import org.junit.Before;
@@ -37,34 +42,41 @@ public class OptimizedPreferenceControllerTest {

    private OptimizedPreferenceController mController;
    private SelectorWithWidgetPreference mPreference;
+    private BatteryOptimizeUtils mBatteryOptimizeUtils;

-    @Mock BatteryOptimizeUtils mockBatteryOptimizeUtils;
+    @Mock PackageManager mMockPackageManager;

    @Before
-    public void setUp() {
+    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);

-        mController = new OptimizedPreferenceController(
-                RuntimeEnvironment.application, UID, PACKAGE_NAME);
+        Context context = spy(RuntimeEnvironment.application);
+        BatteryUtils.getInstance(context).reset();
+        doReturn(UID)
+                .when(mMockPackageManager)
+                .getPackageUid(PACKAGE_NAME, PackageManager.GET_META_DATA);
+
+        mController = new OptimizedPreferenceController(context, UID, PACKAGE_NAME);
        mPreference = new SelectorWithWidgetPreference(RuntimeEnvironment.application);
-        mController.mBatteryOptimizeUtils = mockBatteryOptimizeUtils;
+        mBatteryOptimizeUtils = spy(new BatteryOptimizeUtils(context, UID, PACKAGE_NAME));
+        mController.mBatteryOptimizeUtils = mBatteryOptimizeUtils;
    }

    @Test
    public void testUpdateState_invalidPackage_prefEnabled() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(true);
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(true);

        mController.updateState(mPreference);

-        assertThat(mPreference.isEnabled()).isTrue();
+        assertThat(mPreference.isEnabled()).isFalse();
        assertThat(mPreference.isChecked()).isTrue();
    }

    @Test
    public void testUpdateState_isSystemOrDefaultAppAndOptimizeStates_prefChecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mockBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
                BatteryOptimizeUtils.MODE_OPTIMIZED);

        mController.updateState(mPreference);
@@ -74,8 +86,8 @@ public class OptimizedPreferenceControllerTest {

    @Test
    public void testUpdateState_isSystemOrDefaultApp_prefUnchecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);

        mController.updateState(mPreference);

@@ -85,8 +97,8 @@ public class OptimizedPreferenceControllerTest {

    @Test
    public void testUpdateState_isOptimizedStates_prefChecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
                BatteryOptimizeUtils.MODE_OPTIMIZED);

        mController.updateState(mPreference);
@@ -96,7 +108,7 @@ public class OptimizedPreferenceControllerTest {

    @Test
    public void testUpdateState_prefUnchecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);

        mController.updateState(mPreference);

--- a/tests/robotests/src/com/android/settings/fuelgauge/PowerBackgroundUsageDetailTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerBackgroundUsageDetailTest.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2023 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.fuelgauge;
+
+import static com.android.settings.SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS;
+import static com.android.settings.fuelgauge.BatteryOptimizeHistoricalLogEntry.Action;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.AppOpsManager;
+import android.app.backup.BackupManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.os.UserHandle;
+import android.widget.Switch;
+
+import androidx.fragment.app.FragmentActivity;
+import androidx.loader.app.LoaderManager;
+
+import com.android.settings.SettingsActivity;
+import com.android.settings.fuelgauge.batteryusage.BatteryEntry;
+import com.android.settings.testutils.shadow.ShadowActivityManager;
+import com.android.settings.testutils.shadow.ShadowEntityHeaderController;
+import com.android.settings.widget.EntityHeaderController;
+import com.android.settingslib.applications.AppUtils;
+import com.android.settingslib.applications.ApplicationsState;
+import com.android.settingslib.applications.instantapps.InstantAppDataProvider;
+import com.android.settingslib.widget.FooterPreference;
+import com.android.settingslib.widget.LayoutPreference;
+import com.android.settingslib.widget.MainSwitchPreference;
+import com.android.settingslib.widget.SelectorWithWidgetPreference;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.stubbing.Answer;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.util.ReflectionHelpers;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = {
+        ShadowEntityHeaderController.class,
+        ShadowActivityManager.class,
+        com.android.settings.testutils.shadow.ShadowFragment.class,
+})
+public class PowerBackgroundUsageDetailTest {
+    private static final String APP_LABEL = "app label";
+    private static final String SUMMARY = "summary";
+    private static final int ICON_ID = 123;
+    private static final int UID = 1;
+    private static final String KEY_PREF_UNRESTRICTED = "unrestricted_preference";
+    private static final String KEY_PREF_OPTIMIZED = "optimized_preference";
+    private static final String KEY_ALLOW_BACKGROUND_USAGE = "allow_background_usage";
+
+    private Context mContext;
+    private PowerBackgroundUsageDetail mFragment;
+    private FooterPreference mFooterPreference;
+    private MainSwitchPreference mMainSwitchPreference;
+    private SelectorWithWidgetPreference mOptimizePreference;
+    private SelectorWithWidgetPreference mUnrestrictedPreference;
+    private SettingsActivity mTestActivity;
+
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private FragmentActivity mActivity;
+    @Mock
+    private EntityHeaderController mEntityHeaderController;
+    @Mock
+    private BatteryOptimizeUtils mBatteryOptimizeUtils;
+    @Mock
+    private LayoutPreference mHeaderPreference;
+    @Mock
+    private ApplicationsState mState;
+    @Mock
+    private Bundle mBundle;
+    @Mock
+    private LoaderManager mLoaderManager;
+    @Mock
+    private ApplicationsState.AppEntry mAppEntry;
+    @Mock
+    private BatteryEntry mBatteryEntry;
+    @Mock
+    private BackupManager mBackupManager;
+    @Mock
+    private PackageManager mPackageManager;
+    @Mock
+    private AppOpsManager mAppOpsManager;
+    @Mock
+    private Switch mMockSwitch;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageName()).thenReturn("foo");
+
+        mFragment = spy(new PowerBackgroundUsageDetail());
+        doReturn(mContext).when(mFragment).getContext();
+        doReturn(mActivity).when(mFragment).getActivity();
+        doReturn(SUMMARY).when(mFragment).getString(anyInt());
+        doReturn(APP_LABEL).when(mBundle).getString(nullable(String.class));
+        when(mFragment.getArguments()).thenReturn(mBundle);
+        doReturn(mLoaderManager).when(mFragment).getLoaderManager();
+
+        ShadowEntityHeaderController.setUseMock(mEntityHeaderController);
+        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setButtonActions(anyInt(), anyInt());
+        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setIcon(nullable(Drawable.class));
+        doReturn(mEntityHeaderController).when(mEntityHeaderController).setIcon(nullable(
+                ApplicationsState.AppEntry.class));
+        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setLabel(nullable(String.class));
+        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setLabel(nullable(String.class));
+        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setLabel(nullable(ApplicationsState.AppEntry.class));
+        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setSummary(nullable(String.class));
+
+        when(mBatteryEntry.getUid()).thenReturn(UID);
+        when(mBatteryEntry.getLabel()).thenReturn(APP_LABEL);
+        mBatteryEntry.mIconId = ICON_ID;
+
+        mFragment.mHeaderPreference = mHeaderPreference;
+        mFragment.mState = mState;
+        mFragment.mBatteryOptimizeUtils = mBatteryOptimizeUtils;
+        mFragment.mBackupManager = mBackupManager;
+        mAppEntry.info = mock(ApplicationInfo.class);
+
+        mTestActivity = spy(new SettingsActivity());
+        doReturn(mPackageManager).when(mTestActivity).getPackageManager();
+        doReturn(mPackageManager).when(mActivity).getPackageManager();
+        doReturn(mAppOpsManager).when(mTestActivity).getSystemService(Context.APP_OPS_SERVICE);
+
+        final ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+
+        Answer<Void> callable = invocation -> {
+            mBundle = captor.getValue().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
+            System.out.println("mBundle = " + mBundle);
+            return null;
+        };
+        doAnswer(callable).when(mActivity).startActivityAsUser(captor.capture(),
+                nullable(UserHandle.class));
+        doAnswer(callable).when(mActivity).startActivity(captor.capture());
+
+        mFooterPreference = spy(new FooterPreference(mContext));
+        mMainSwitchPreference = spy(new MainSwitchPreference(mContext));
+        mMainSwitchPreference.setKey(KEY_ALLOW_BACKGROUND_USAGE);
+        mOptimizePreference = spy(new SelectorWithWidgetPreference(mContext));
+        mOptimizePreference.setKey(KEY_PREF_OPTIMIZED);
+        mUnrestrictedPreference = spy(new SelectorWithWidgetPreference(mContext));
+        mUnrestrictedPreference.setKey(KEY_PREF_UNRESTRICTED);
+        mFragment.mFooterPreference = mFooterPreference;
+        mFragment.mMainSwitchPreference = mMainSwitchPreference;
+        mFragment.mOptimizePreference = mOptimizePreference;
+        mFragment.mUnrestrictedPreference = mUnrestrictedPreference;
+    }
+
+    @After
+    public void reset() {
+        ShadowEntityHeaderController.reset();
+    }
+
+    @Test
+    public void initHeader_NoAppEntry_BuildByBundle() {
+        mFragment.mAppEntry = null;
+        mFragment.initHeader();
+
+        verify(mEntityHeaderController).setIcon(nullable(Drawable.class));
+        verify(mEntityHeaderController).setLabel(APP_LABEL);
+    }
+
+    @Test
+    public void initHeader_HasAppEntry_BuildByAppEntry() {
+        ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
+                new InstantAppDataProvider() {
+                    @Override
+                    public boolean isInstantApp(ApplicationInfo info) {
+                        return false;
+                    }
+                });
+        mFragment.mAppEntry = mAppEntry;
+        mFragment.initHeader();
+
+        verify(mEntityHeaderController).setIcon(mAppEntry);
+        verify(mEntityHeaderController).setLabel(mAppEntry);
+        verify(mEntityHeaderController).setIsInstantApp(false);
+    }
+
+    @Test
+    public void initHeader_HasAppEntry_InstantApp() {
+        ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
+                new InstantAppDataProvider() {
+                    @Override
+                    public boolean isInstantApp(ApplicationInfo info) {
+                        return true;
+                    }
+                });
+        mFragment.mAppEntry = mAppEntry;
+        mFragment.initHeader();
+
+        verify(mEntityHeaderController).setIcon(mAppEntry);
+        verify(mEntityHeaderController).setLabel(mAppEntry);
+        verify(mEntityHeaderController).setIsInstantApp(true);
+    }
+
+    @Test
+    public void initFooter_hasCorrectString() {
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(false);
+
+        mFragment.initFooter();
+
+        assertThat(mFooterPreference.getTitle().toString())
+                .isEqualTo("Changing how an app uses your battery can affect its performance.");
+    }
+
+    @Test
+    public void onSwitchChanged_fromUnrestrictedModeSetDisabled_becomeRestrictedMode() {
+        final int restrictedMode = BatteryOptimizeUtils.MODE_RESTRICTED;
+        final int optimizedMode = BatteryOptimizeUtils.MODE_OPTIMIZED;
+        mFragment.mOptimizationMode = optimizedMode;
+
+        mFragment.onSwitchChanged(mMockSwitch, /*isChecked=*/ false);
+
+        verify(mOptimizePreference).setEnabled(false);
+        verify(mUnrestrictedPreference).setEnabled(false);
+        verify(mFragment).onRadioButtonClicked(null);
+        verify(mMainSwitchPreference).setChecked(false);
+        assertThat(mFragment.getSelectedPreference()).isEqualTo(restrictedMode);
+        verify(mBatteryOptimizeUtils).setAppUsageState(restrictedMode, Action.APPLY);
+    }
+
+    @Test
+    public void onSwitchChanged_fromRestrictedModeSetEnabled_becomeOptimizedMode() {
+        final int restrictedMode = BatteryOptimizeUtils.MODE_RESTRICTED;
+        final int optimizedMode = BatteryOptimizeUtils.MODE_OPTIMIZED;
+        mFragment.mOptimizationMode = restrictedMode;
+
+        mFragment.onSwitchChanged(mMockSwitch, /*isChecked=*/ true);
+
+        verify(mOptimizePreference).setEnabled(true);
+        verify(mUnrestrictedPreference).setEnabled(true);
+        verify(mFragment).onRadioButtonClicked(mOptimizePreference);
+        verify(mMainSwitchPreference).setChecked(true);
+        verify(mOptimizePreference).setChecked(true);
+        assertThat(mFragment.getSelectedPreference()).isEqualTo(optimizedMode);
+        verify(mBatteryOptimizeUtils).setAppUsageState(optimizedMode, Action.APPLY);
+    }
+}
--- a/tests/robotests/src/com/android/settings/fuelgauge/RestrictedPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/RestrictedPreferenceControllerTest.java
@@ -1,126 +0,0 @@
-/*
- * Copyright (C) 2021 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.fuelgauge;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.mockito.Mockito.when;
-
-import com.android.settingslib.widget.SelectorWithWidgetPreference;
-
-import org.junit.Before;
-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)
-public class RestrictedPreferenceControllerTest {
-    private static final int UID = 12345;
-    private static final String PACKAGE_NAME = "com.android.app";
-
-    private RestrictedPreferenceController mController;
-    private SelectorWithWidgetPreference mPreference;
-
-    @Mock BatteryOptimizeUtils mockBatteryOptimizeUtils;
-
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-
-        mController = new RestrictedPreferenceController(
-                RuntimeEnvironment.application, UID, PACKAGE_NAME);
-        mPreference = new SelectorWithWidgetPreference(RuntimeEnvironment.application);
-        mController.mBatteryOptimizeUtils = mockBatteryOptimizeUtils;
-    }
-
-    @Test
-    public void testUpdateState_isValidPackage_prefEnabled() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.isEnabled()).isTrue();
-    }
-
-    @Test
-    public void testUpdateState_invalidPackage_prefDisabled() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(true);
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.isEnabled()).isFalse();
-    }
-
-    @Test
-    public void testUpdateState_isSystemOrDefaultAppAndRestrictedStates_prefChecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mockBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
-                BatteryOptimizeUtils.MODE_RESTRICTED);
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.isChecked()).isTrue();
-    }
-
-    @Test
-    public void testUpdateState_isSystemOrDefaultApp_prefUnchecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.isChecked()).isFalse();
-        assertThat(mPreference.isEnabled()).isFalse();
-    }
-
-    @Test
-    public void testUpdateState_isRestrictedStates_prefChecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
-                BatteryOptimizeUtils.MODE_RESTRICTED);
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.isChecked()).isTrue();
-    }
-
-    @Test
-    public void testUpdateState_prefUnchecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.isChecked()).isFalse();
-    }
-
-    @Test
-    public void testHandlePreferenceTreeClick_samePrefKey_verifyAction() {
-        mPreference.setKey(mController.KEY_RESTRICTED_PREF);
-        mController.handlePreferenceTreeClick(mPreference);
-
-        assertThat(mController.handlePreferenceTreeClick(mPreference)).isTrue();
-    }
-
-    @Test
-    public void testHandlePreferenceTreeClick_incorrectPrefKey_noAction() {
-        assertThat(mController.handlePreferenceTreeClick(mPreference)).isFalse();
-    }
-}
--- a/tests/robotests/src/com/android/settings/fuelgauge/UnrestrictedPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/UnrestrictedPreferenceControllerTest.java
@@ -18,8 +18,13 @@ package com.android.settings.fuelgauge;

 import static com.google.common.truth.Truth.assertThat;

+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;

+import android.content.Context;
+import android.content.pm.PackageManager;
+
 import com.android.settingslib.widget.SelectorWithWidgetPreference;

 import org.junit.Before;
@@ -37,42 +42,53 @@ public class UnrestrictedPreferenceControllerTest {

    private UnrestrictedPreferenceController mController;
    private SelectorWithWidgetPreference mPreference;
+    private BatteryOptimizeUtils mBatteryOptimizeUtils;

-    @Mock BatteryOptimizeUtils mockBatteryOptimizeUtils;
+    @Mock PackageManager mMockPackageManager;

    @Before
-    public void setUp() {
+    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);

-        mController = new UnrestrictedPreferenceController(
-                RuntimeEnvironment.application, UID, PACKAGE_NAME);
+        Context context = spy(RuntimeEnvironment.application);
+        BatteryUtils.getInstance(context).reset();
+        doReturn(UID)
+                .when(mMockPackageManager)
+                .getPackageUid(PACKAGE_NAME, PackageManager.GET_META_DATA);
+
+        mController = new UnrestrictedPreferenceController(context, UID, PACKAGE_NAME);
        mPreference = new SelectorWithWidgetPreference(RuntimeEnvironment.application);
-        mController.mBatteryOptimizeUtils = mockBatteryOptimizeUtils;
+        mBatteryOptimizeUtils = spy(new BatteryOptimizeUtils(context, UID, PACKAGE_NAME));
+        mController.mBatteryOptimizeUtils = mBatteryOptimizeUtils;
    }

    @Test
    public void testUpdateState_isValidPackage_prefEnabled() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(false);

        mController.updateState(mPreference);

+        assertThat(mBatteryOptimizeUtils.isOptimizeModeMutable()).isTrue();
        assertThat(mPreference.isEnabled()).isTrue();
    }

    @Test
    public void testUpdateState_invalidPackage_prefDisabled() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(true);
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(true);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(false);

        mController.updateState(mPreference);

+        assertThat(mBatteryOptimizeUtils.isOptimizeModeMutable()).isFalse();
        assertThat(mPreference.isEnabled()).isFalse();
    }

    @Test
    public void testUpdateState_isSystemOrDefaultAppAndUnrestrictedStates_prefChecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mockBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
                BatteryOptimizeUtils.MODE_UNRESTRICTED);

        mController.updateState(mPreference);
@@ -82,32 +98,38 @@ public class UnrestrictedPreferenceControllerTest {

    @Test
    public void testUpdateState_isSystemOrDefaultApp_prefUnchecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
+        when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+                BatteryOptimizeUtils.MODE_OPTIMIZED);

        mController.updateState(mPreference);

-        assertThat(mPreference.isChecked()).isFalse();
        assertThat(mPreference.isEnabled()).isFalse();
+        assertThat(mPreference.isChecked()).isFalse();
    }

    @Test
    public void testUpdateState_isUnrestrictedStates_prefChecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mockBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
                BatteryOptimizeUtils.MODE_UNRESTRICTED);

        mController.updateState(mPreference);

+        assertThat(mPreference.isEnabled()).isTrue();
        assertThat(mPreference.isChecked()).isTrue();
    }

    @Test
    public void testUpdateState_prefUnchecked() {
-        when(mockBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
+        when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
+        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+                BatteryOptimizeUtils.MODE_OPTIMIZED);

        mController.updateState(mPreference);

+        assertThat(mPreference.isEnabled()).isTrue();
        assertThat(mPreference.isChecked()).isFalse();
    }

--- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java
@@ -82,6 +82,7 @@ public final class BatteryDiffEntryTest {
        MockitoAnnotations.initMocks(this);
        ShadowUserHandle.reset();
        mContext = spy(RuntimeEnvironment.application);
+        BatteryUtils.getInstance(mContext).reset();
        doReturn(mContext).when(mContext).getApplicationContext();
        doReturn(mMockUserManager).when(mContext).getSystemService(UserManager.class);
        doReturn(mMockPackageManager).when(mContext).getPackageManager();
@@ -461,9 +462,6 @@ public final class BatteryDiffEntryTest {

    @Test
    public void testIsUninstalledEntry_uninstalledApp_returnTrue() throws Exception {
-        doReturn(BatteryUtils.UID_NULL)
-                .when(mMockPackageManager)
-                .getPackageUid(PACKAGE_NAME, PackageManager.GET_META_DATA);
        final ContentValues values =
                getContentValuesWithType(ConvertUtils.CONSUMER_TYPE_UID_BATTERY);
        values.put(BatteryHistEntry.KEY_UID, UNINSTALLED_UID);