Format battery java test code

context:go/pixel-energizer-java-format

Test: manual
Bug: 304439460
Fix: 304439460
Change-Id: I5be0ee41afb3a7018bc7e25cceccc25669924d6c

tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java

@@ -78,11 +78,12 @@ import org.robolectric.util.ReflectionHelpers;
 import java.util.concurrent.TimeUnit;
 
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {
+@Config(
-        ShadowEntityHeaderController.class,
+        shadows = {
-        ShadowActivityManager.class,
+            ShadowEntityHeaderController.class,
-        com.android.settings.testutils.shadow.ShadowFragment.class,
+            ShadowActivityManager.class,
-})
+            com.android.settings.testutils.shadow.ShadowFragment.class,
+        })
 public class AdvancedPowerUsageDetailTest {
     private static final String APP_LABEL = "app label";
     private static final String SUMMARY = "summary";
@@ -99,30 +100,19 @@ public class AdvancedPowerUsageDetailTest {
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private FragmentActivity mActivity;
-    @Mock
+
-    private EntityHeaderController mEntityHeaderController;
+    @Mock private EntityHeaderController mEntityHeaderController;
-    @Mock
+    @Mock private LayoutPreference mHeaderPreference;
-    private LayoutPreference mHeaderPreference;
+    @Mock private ApplicationsState mState;
-    @Mock
+    @Mock private ApplicationsState.AppEntry mAppEntry;
-    private ApplicationsState mState;
+    @Mock private Bundle mBundle;
-    @Mock
+    @Mock private BatteryEntry mBatteryEntry;
-    private ApplicationsState.AppEntry mAppEntry;
+    @Mock private PackageManager mPackageManager;
-    @Mock
+    @Mock private InstallSourceInfo mInstallSourceInfo;
-    private Bundle mBundle;
+    @Mock private AppOpsManager mAppOpsManager;
-    @Mock
+    @Mock private LoaderManager mLoaderManager;
-    private BatteryEntry mBatteryEntry;
+    @Mock private BatteryOptimizeUtils mBatteryOptimizeUtils;
-    @Mock
+    @Mock private BackupManager mBackupManager;
-    private PackageManager mPackageManager;
-    @Mock
-    private InstallSourceInfo mInstallSourceInfo;
-    @Mock
-    private AppOpsManager mAppOpsManager;
-    @Mock
-    private LoaderManager mLoaderManager;
-    @Mock
-    private BatteryOptimizeUtils mBatteryOptimizeUtils;
-    @Mock
-    private BackupManager mBackupManager;
 
     private Context mContext;
     private PrimarySwitchPreference mAllowBackgroundUsagePreference;
@@ -149,19 +139,26 @@ public class AdvancedPowerUsageDetailTest {
         doReturn(mLoaderManager).when(mFragment).getLoaderManager();
 
         ShadowEntityHeaderController.setUseMock(mEntityHeaderController);
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setButtonActions(anyInt(), anyInt());
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setIcon(nullable(Drawable.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController).setIcon(nullable(
+        doReturn(mEntityHeaderController)
-                ApplicationsState.AppEntry.class));
+                .when(mEntityHeaderController)
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setIcon(nullable(ApplicationsState.AppEntry.class));
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setLabel(nullable(String.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setLabel(nullable(String.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setLabel(nullable(ApplicationsState.AppEntry.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setSummary(nullable(String.class));
 
         when(mBatteryEntry.getUid()).thenReturn(UID);
@@ -184,13 +181,15 @@ public class AdvancedPowerUsageDetailTest {
 
         final ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
 
-        Answer<Void> callable = invocation -> {
+        Answer<Void> callable =
-            mBundle = captor.getValue().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
+                invocation -> {
-            System.out.println("mBundle = " + mBundle);
+                    mBundle = captor.getValue().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
-            return null;
+                    System.out.println("mBundle = " + mBundle);
-        };
+                    return null;
-        doAnswer(callable).when(mActivity).startActivityAsUser(captor.capture(),
+                };
-                nullable(UserHandle.class));
+        doAnswer(callable)
+                .when(mActivity)
+                .startActivityAsUser(captor.capture(), nullable(UserHandle.class));
         doAnswer(callable).when(mActivity).startActivity(captor.capture());
 
         mAllowBackgroundUsagePreference = new PrimarySwitchPreference(mContext);
@@ -219,7 +218,9 @@ public class AdvancedPowerUsageDetailTest {
 
     @Test
     public void initHeader_HasAppEntry_BuildByAppEntry() {
-        ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
+        ReflectionHelpers.setStaticField(
+                AppUtils.class,
+                "sInstantAppDataProvider",
                 new InstantAppDataProvider() {
                     @Override
                     public boolean isInstantApp(ApplicationInfo info) {
@@ -236,7 +237,9 @@ public class AdvancedPowerUsageDetailTest {
 
     @Test
     public void initHeader_HasAppEntry_InstantApp() {
-        ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
+        ReflectionHelpers.setStaticField(
+                AppUtils.class,
+                "sInstantAppDataProvider",
                 new InstantAppDataProvider() {
                     @Override
                     public boolean isInstantApp(ApplicationInfo info) {
@@ -253,16 +256,13 @@ public class AdvancedPowerUsageDetailTest {
 
     @Test
     public void startBatteryDetailPage_invalidToShowSummary_noFGBDData() {
-        AdvancedPowerUsageDetail.startBatteryDetailPage(mActivity, mFragment,
+        AdvancedPowerUsageDetail.startBatteryDetailPage(
-                mBatteryEntry, USAGE_PERCENT);
+                mActivity, mFragment, mBatteryEntry, USAGE_PERCENT);
 
         assertThat(mBundle.getInt(AdvancedPowerUsageDetail.EXTRA_UID)).isEqualTo(UID);
-        assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME))
+        assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME)).isEqualTo(0);
-                .isEqualTo(0);
+        assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME)).isEqualTo(0);
-        assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME))
+        assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME)).isEqualTo(0);
-                .isEqualTo(0);
-        assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME))
-                .isEqualTo(0);
         assertThat(mBundle.getString(AdvancedPowerUsageDetail.EXTRA_POWER_USAGE_PERCENT))
                 .isEqualTo(USAGE_PERCENT);
     }
@@ -276,18 +276,22 @@ public class AdvancedPowerUsageDetailTest {
 
         verify(mActivity).startActivity(captor.capture());
 
-        assertThat(captor.getValue().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS)
+        assertThat(
-                .getString(AdvancedPowerUsageDetail.EXTRA_PACKAGE_NAME))
+                        captor.getValue()
+                                .getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS)
+                                .getString(AdvancedPowerUsageDetail.EXTRA_PACKAGE_NAME))
                 .isEqualTo(PACKAGE_NAME[0]);
 
-        assertThat(captor.getValue().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS)
+        assertThat(
-                .getString(AdvancedPowerUsageDetail.EXTRA_POWER_USAGE_PERCENT))
+                        captor.getValue()
+                                .getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS)
+                                .getString(AdvancedPowerUsageDetail.EXTRA_POWER_USAGE_PERCENT))
                 .isEqualTo("0%");
     }
 
     @Test
-    public void startBatteryDetailPage_batteryEntryNotExisted_extractUidFromPackageName() throws
+    public void startBatteryDetailPage_batteryEntryNotExisted_extractUidFromPackageName()
-            PackageManager.NameNotFoundException {
+            throws PackageManager.NameNotFoundException {
         doReturn(UID).when(mPackageManager).getPackageUid(PACKAGE_NAME[0], 0 /* no flag */);
 
         AdvancedPowerUsageDetail.startBatteryDetailPage(

tests/robotests/src/com/android/settings/fuelgauge/AllowBackgroundPreferenceControllerTest.java

@@ -88,8 +88,8 @@ public class AllowBackgroundPreferenceControllerTest {
     public void testUpdateState_isSystemOrDefaultAppAndRestrictedStates_prefChecked() {
         when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
         when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_RESTRICTED);
+                .thenReturn(BatteryOptimizeUtils.MODE_RESTRICTED);
 
         mController.updateState(mMainSwitchPreference);
 
@@ -101,8 +101,8 @@ public class AllowBackgroundPreferenceControllerTest {
     public void testUpdateState_isSystemOrDefaultApp_prefUnchecked() {
         when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
         when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_OPTIMIZED);
+                .thenReturn(BatteryOptimizeUtils.MODE_OPTIMIZED);
 
         mController.updateState(mMainSwitchPreference);
 
@@ -113,8 +113,8 @@ public class AllowBackgroundPreferenceControllerTest {
     @Test
     public void testUpdateState_isRestrictedStates_prefChecked() {
         when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_RESTRICTED);
+                .thenReturn(BatteryOptimizeUtils.MODE_RESTRICTED);
 
         mController.updateState(mMainSwitchPreference);
 
@@ -125,8 +125,8 @@ public class AllowBackgroundPreferenceControllerTest {
     @Test
     public void testUpdateState_prefUnchecked() {
         when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_OPTIMIZED);
+                .thenReturn(BatteryOptimizeUtils.MODE_OPTIMIZED);
 
         mController.updateState(mMainSwitchPreference);
 

tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java

@@ -91,26 +91,25 @@ public class AutoRestrictionPreferenceControllerTest {
     public void testGetAvailabilityStatus_smartBatterySupported_returnDisabled() {
         doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
 
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+        assertThat(mController.getAvailabilityStatus())
-                BasePreferenceController.UNSUPPORTED_ON_DEVICE);
+                .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
     }
 
     @Test
     public void testGetAvailabilityStatus_smartBatteryUnSupported_returnAvailable() {
         doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
 
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+        assertThat(mController.getAvailabilityStatus())
-                BasePreferenceController.AVAILABLE);
+                .isEqualTo(BasePreferenceController.AVAILABLE);
     }
 
     private void putAutoRestrictionValue(int value) {
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.APP_AUTO_RESTRICTION_ENABLED,
+                mContext.getContentResolver(), Settings.Global.APP_AUTO_RESTRICTION_ENABLED, value);
-                value);
     }
 
     private int getAutoRestrictionValue() {
-        return Settings.Global.getInt(mContext.getContentResolver(),
+        return Settings.Global.getInt(
-                Settings.Global.APP_AUTO_RESTRICTION_ENABLED, ON);
+                mContext.getContentResolver(), Settings.Global.APP_AUTO_RESTRICTION_ENABLED, ON);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/BatteryBackupHelperTest.java

@@ -94,30 +94,20 @@ public final class BatteryBackupHelperTest {
     private BatteryBackupHelper mBatteryBackupHelper;
     private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
 
-    @Mock
+    @Mock private PackageManager mPackageManager;
-    private PackageManager mPackageManager;
+    @Mock private BackupDataOutput mBackupDataOutput;
-    @Mock
+    @Mock private BackupDataInputStream mBackupDataInputStream;
-    private BackupDataOutput mBackupDataOutput;
+    @Mock private IDeviceIdleController mDeviceController;
-    @Mock
+    @Mock private IPackageManager mIPackageManager;
-    private BackupDataInputStream mBackupDataInputStream;
+    @Mock private AppOpsManager mAppOpsManager;
-    @Mock
+    @Mock private UserManager mUserManager;
-    private IDeviceIdleController mDeviceController;
+    @Mock private PowerAllowlistBackend mPowerAllowlistBackend;
-    @Mock
+    @Mock private BatteryOptimizeUtils mBatteryOptimizeUtils;
-    private IPackageManager mIPackageManager;
-    @Mock
-    private AppOpsManager mAppOpsManager;
-    @Mock
-    private UserManager mUserManager;
-    @Mock
-    private PowerAllowlistBackend mPowerAllowlistBackend;
-    @Mock
-    private BatteryOptimizeUtils mBatteryOptimizeUtils;
 
     @Before
     public void setUp() throws Exception {
         MockitoAnnotations.initMocks(this);
-        mPowerUsageFeatureProvider =
+        mPowerUsageFeatureProvider = FakeFeatureFactory.setupForTest().powerUsageFeatureProvider;
-                FakeFeatureFactory.setupForTest().powerUsageFeatureProvider;
         mContext = spy(RuntimeEnvironment.application);
         mStringWriter = new StringWriter();
         mPrintWriter = new PrintWriter(mStringWriter);
@@ -173,7 +163,7 @@ public final class BatteryBackupHelperTest {
     public void backupOptimizationMode_nullInstalledApps_ignoreBackupOptimization()
             throws Exception {
         final UserInfo userInfo =
-                new UserInfo(/*userId=*/ 0, /*userName=*/ "google", /*flag=*/ 0);
+                new UserInfo(/* userId= */ 0, /* userName= */ "google", /* flag= */ 0);
         doReturn(Arrays.asList(userInfo)).when(mUserManager).getProfiles(anyInt());
         doThrow(new RuntimeException())
                 .when(mIPackageManager)
@@ -199,8 +189,7 @@ public final class BatteryBackupHelperTest {
     }
 
     @Test
-    public void backupOptimizationMode_backupOptimizationModeAndIgnoreSystemApp()
+    public void backupOptimizationMode_backupOptimizationModeAndIgnoreSystemApp() throws Exception {
-            throws Exception {
         final List<String> allowlistedApps = Arrays.asList(PACKAGE_NAME1);
         createTestingData(PACKAGE_NAME1, UID1, PACKAGE_NAME2, PACKAGE_NAME3);
         // Sets "com.android.testing.1" as system app.
@@ -294,8 +283,7 @@ public final class BatteryBackupHelperTest {
         // Invoke the restoreEntity() method 2nd time.
         mBatteryBackupHelper.restoreEntity(mBackupDataInputStream);
 
-        assertThat(TestUtils.getScheduledLevel(mContext))
+        assertThat(TestUtils.getScheduledLevel(mContext)).isEqualTo(invalidScheduledLevel);
-                .isEqualTo(invalidScheduledLevel);
     }
 
     @Test
@@ -313,9 +301,14 @@ public final class BatteryBackupHelperTest {
     @Test
     public void restoreOptimizationMode_invalidModeFormat_skipRestore() throws Exception {
         final String invalidNumberFormat = "google";
-        final String packageModes =
+        final String package1Mode = PACKAGE_NAME1
-                PACKAGE_NAME1 + DELIMITER_MODE + MODE_RESTRICTED + DELIMITER +
+                + DELIMITER_MODE
-                PACKAGE_NAME2 + DELIMITER_MODE + invalidNumberFormat;
+                + MODE_RESTRICTED
+                + DELIMITER;
+        final String package2Mode = PACKAGE_NAME2
+                + DELIMITER_MODE
+                + invalidNumberFormat;
+        final String packageModes = package1Mode + package2Mode;
 
         mBatteryBackupHelper.restoreOptimizationMode(packageModes.getBytes());
         TimeUnit.SECONDS.sleep(1);
@@ -328,10 +321,19 @@ public final class BatteryBackupHelperTest {
 
     @Test
     public void restoreOptimizationMode_restoreExpectedModes() throws Exception {
-        final String packageModes =
+        final String package1Mode = PACKAGE_NAME1
-                PACKAGE_NAME1 + DELIMITER_MODE + MODE_RESTRICTED + DELIMITER +
+                + DELIMITER_MODE
-                PACKAGE_NAME2 + DELIMITER_MODE + MODE_UNRESTRICTED + DELIMITER +
+                + MODE_RESTRICTED
-                PACKAGE_NAME3 + DELIMITER_MODE + MODE_RESTRICTED + DELIMITER;
+                + DELIMITER;
+        final String package2Mode = PACKAGE_NAME2
+                + DELIMITER_MODE
+                + MODE_UNRESTRICTED
+                + DELIMITER;
+        final String package3Mode = PACKAGE_NAME3
+                + DELIMITER_MODE
+                + MODE_RESTRICTED
+                + DELIMITER;
+        final String packageModes = package1Mode + package2Mode + package3Mode;
 
         mBatteryBackupHelper.restoreOptimizationMode(packageModes.getBytes());
         TimeUnit.SECONDS.sleep(1);
@@ -358,13 +360,14 @@ public final class BatteryBackupHelperTest {
         verifyBackupData(inOrder, BatteryBackupHelper.KEY_BUILD_PRODUCT, Build.PRODUCT);
         verifyBackupData(inOrder, BatteryBackupHelper.KEY_BUILD_MANUFACTURER, Build.MANUFACTURER);
         verifyBackupData(inOrder, BatteryBackupHelper.KEY_BUILD_FINGERPRINT, Build.FINGERPRINT);
-        inOrder.verify(mBackupDataOutput, never()).writeEntityHeader(
+        inOrder.verify(mBackupDataOutput, never())
-                eq(BatteryBackupHelper.KEY_BUILD_METADATA_1), anyInt());
+                .writeEntityHeader(eq(BatteryBackupHelper.KEY_BUILD_METADATA_1), anyInt());
         verifyBackupData(inOrder, BatteryBackupHelper.KEY_BUILD_METADATA_2, deviceMetadata);
     }
 
     private void mockUid(int uid, String packageName) throws Exception {
-        doReturn(uid).when(mPackageManager)
+        doReturn(uid)
+                .when(mPackageManager)
                 .getPackageUid(packageName, PackageManager.GET_META_DATA);
     }
 
@@ -384,8 +387,8 @@ public final class BatteryBackupHelperTest {
         final Set<String> expectedResultSet =
                 Set.of(expectedResult.split(BatteryBackupHelper.DELIMITER));
 
-        verify(mBackupDataOutput).writeEntityHeader(
+        verify(mBackupDataOutput)
-                BatteryBackupHelper.KEY_OPTIMIZATION_LIST, expectedBytes.length);
+                .writeEntityHeader(BatteryBackupHelper.KEY_OPTIMIZATION_LIST, expectedBytes.length);
         verify(mBackupDataOutput).writeEntityData(captor.capture(), eq(expectedBytes.length));
         final String actualResult = new String(captor.getValue());
         final Set<String> actualResultSet =
@@ -393,11 +396,12 @@ public final class BatteryBackupHelperTest {
         assertThat(actualResultSet).isEqualTo(expectedResultSet);
     }
 
-    private void createTestingData(String packageName1, int uid1, String packageName2,
+    private void createTestingData(
-            String packageName3) throws Exception {
+            String packageName1, int uid1, String packageName2, String packageName3)
+            throws Exception {
         // Sets the getInstalledApplications() method for testing.
         final UserInfo userInfo =
-                new UserInfo(/*userId=*/ 0, /*userName=*/ "google", /*flag=*/ 0);
+                new UserInfo(/* userId= */ 0, /* userName= */ "google", /* flag= */ 0);
         doReturn(Arrays.asList(userInfo)).when(mUserManager).getProfiles(anyInt());
         final ApplicationInfo applicationInfo1 = new ApplicationInfo();
         applicationInfo1.enabled = true;
@@ -413,10 +417,12 @@ public final class BatteryBackupHelperTest {
         applicationInfo3.uid = 3;
         applicationInfo3.packageName = packageName3;
         applicationInfo3.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
-        doReturn(new ParceledListSlice<ApplicationInfo>(
+        doReturn(
-                Arrays.asList(applicationInfo1, applicationInfo2, applicationInfo3)))
+                        new ParceledListSlice<ApplicationInfo>(
-            .when(mIPackageManager)
+                                Arrays.asList(
-            .getInstalledApplications(anyLong(), anyInt());
+                                        applicationInfo1, applicationInfo2, applicationInfo3)))
+                .when(mIPackageManager)
+                .getInstalledApplications(anyLong(), anyInt());
         // Sets the AppOpsManager for checkOpNoThrow() method.
         doReturn(AppOpsManager.MODE_ALLOWED)
                 .when(mAppOpsManager)
@@ -434,8 +440,8 @@ public final class BatteryBackupHelperTest {
                 new ArraySet<>(Arrays.asList(applicationInfo1, applicationInfo2, applicationInfo3));
     }
 
-    private void verifyBackupData(
+    private void verifyBackupData(InOrder inOrder, String dataKey, String dataContent)
-            InOrder inOrder, String dataKey, String dataContent) throws Exception {
+            throws Exception {
         final byte[] expectedBytes = dataContent.getBytes();
         inOrder.verify(mBackupDataOutput).writeEntityHeader(dataKey, expectedBytes.length);
         inOrder.verify(mBackupDataOutput).writeEntityData(expectedBytes, expectedBytes.length);

tests/robotests/src/com/android/settings/fuelgauge/BatteryBroadcastReceiverTest.java

@@ -54,8 +54,7 @@ public class BatteryBroadcastReceiverTest {
     private static final int BATTERY_INTENT_LEVEL = 80;
     private static final int BATTERY_INTENT_SCALE = 100;
 
-    @Mock
+    @Mock private BatteryBroadcastReceiver.OnBatteryChangedListener mBatteryListener;
-    private BatteryBroadcastReceiver.OnBatteryChangedListener mBatteryListener;
     private BatteryBroadcastReceiver mBatteryBroadcastReceiver;
     private Context mContext;
     private Intent mChargingIntent;
@@ -75,8 +74,8 @@ public class BatteryBroadcastReceiverTest {
         mChargingIntent = new Intent(Intent.ACTION_BATTERY_CHANGED);
         mChargingIntent.putExtra(BatteryManager.EXTRA_LEVEL, BATTERY_INTENT_LEVEL);
         mChargingIntent.putExtra(BatteryManager.EXTRA_SCALE, BATTERY_INTENT_SCALE);
-        mChargingIntent
+        mChargingIntent.putExtra(
-                .putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_CHARGING);
+                BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_CHARGING);
     }
 
     @Test
@@ -85,8 +84,10 @@ public class BatteryBroadcastReceiverTest {
 
         assertThat(mBatteryBroadcastReceiver.mBatteryLevel)
                 .isEqualTo(Utils.getBatteryPercentage(mChargingIntent));
-        assertThat(mBatteryBroadcastReceiver.mBatteryStatus).isEqualTo(
+        assertThat(mBatteryBroadcastReceiver.mBatteryStatus)
-                Utils.getBatteryStatus(mContext, mChargingIntent, /* compactStatus= */ false));
+                .isEqualTo(
+                        Utils.getBatteryStatus(
+                                mContext, mChargingIntent, /* compactStatus= */ false));
         verify(mBatteryListener).onBatteryChanged(BatteryUpdateType.BATTERY_LEVEL);
     }
 
@@ -103,7 +104,8 @@ public class BatteryBroadcastReceiverTest {
 
     @Test
     public void onReceive_chargingStatusChanged_dataUpdated() {
-        mChargingIntent.putExtra(BatteryManager.EXTRA_CHARGING_STATUS,
+        mChargingIntent.putExtra(
+                BatteryManager.EXTRA_CHARGING_STATUS,
                 BatteryManager.CHARGING_POLICY_ADAPTIVE_LONGLIFE);
         mBatteryBroadcastReceiver.onReceive(mContext, mChargingIntent);
 
@@ -123,8 +125,8 @@ public class BatteryBroadcastReceiverTest {
 
     @Test
     public void onReceive_powerSaveModeChanged_listenerInvoked() {
-        mBatteryBroadcastReceiver.onReceive(mContext,
+        mBatteryBroadcastReceiver.onReceive(
-                new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED));
+                mContext, new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED));
 
         verify(mBatteryListener).onBatteryChanged(BatteryUpdateType.BATTERY_SAVER);
     }
@@ -150,16 +152,16 @@ public class BatteryBroadcastReceiverTest {
 
     @Test
     public void onReceive_dockDefenderBypassed_listenerInvoked() {
-        mBatteryBroadcastReceiver.onReceive(mContext,
+        mBatteryBroadcastReceiver.onReceive(
-                new Intent(BatteryUtils.BYPASS_DOCK_DEFENDER_ACTION));
+                mContext, new Intent(BatteryUtils.BYPASS_DOCK_DEFENDER_ACTION));
 
         verify(mBatteryListener).onBatteryChanged(BatteryUpdateType.BATTERY_STATUS);
     }
 
     @Test
     public void onReceive_usbPortComplianceChanged_listenerInvoked() {
-        mBatteryBroadcastReceiver.onReceive(mContext,
+        mBatteryBroadcastReceiver.onReceive(
-                new Intent(UsbManager.ACTION_USB_PORT_COMPLIANCE_CHANGED));
+                mContext, new Intent(UsbManager.ACTION_USB_PORT_COMPLIANCE_CHANGED));
 
         verify(mBatteryListener).onBatteryChanged(BatteryUpdateType.BATTERY_STATUS);
     }
@@ -173,8 +175,10 @@ public class BatteryBroadcastReceiverTest {
 
         assertThat(mBatteryBroadcastReceiver.mBatteryLevel)
                 .isEqualTo(Utils.getBatteryPercentage(mChargingIntent));
-        assertThat(mBatteryBroadcastReceiver.mBatteryStatus).isEqualTo(
+        assertThat(mBatteryBroadcastReceiver.mBatteryStatus)
-                Utils.getBatteryStatus(mContext, mChargingIntent, /* compactStatus= */ false));
+                .isEqualTo(
+                        Utils.getBatteryStatus(
+                                mContext, mChargingIntent, /* compactStatus= */ false));
         assertThat(mBatteryBroadcastReceiver.mBatteryHealth)
                 .isEqualTo(BatteryManager.BATTERY_HEALTH_UNKNOWN);
         assertThat(mBatteryBroadcastReceiver.mChargingStatus)
@@ -188,10 +192,11 @@ public class BatteryBroadcastReceiverTest {
         mBatteryBroadcastReceiver.register();
 
         ArgumentCaptor<IntentFilter> captor = ArgumentCaptor.forClass(IntentFilter.class);
-        verify(mContext).registerReceiver(
+        verify(mContext)
-                eq(mBatteryBroadcastReceiver),
+                .registerReceiver(
-                captor.capture(),
+                        eq(mBatteryBroadcastReceiver),
-                eq(Context.RECEIVER_EXPORTED));
+                        captor.capture(),
+                        eq(Context.RECEIVER_EXPORTED));
         assertAction(captor, Intent.ACTION_BATTERY_CHANGED);
         assertAction(captor, PowerManager.ACTION_POWER_SAVE_MODE_CHANGED);
         assertAction(captor, BatteryUtils.BYPASS_DOCK_DEFENDER_ACTION);

tests/robotests/src/com/android/settings/fuelgauge/BatteryHeaderPreferenceControllerTest.java

@@ -68,22 +68,14 @@ public class BatteryHeaderPreferenceControllerTest {
     private static final String TIME_LEFT = "2h30min";
     private static final String BATTERY_STATUS = "Charging";
 
-    @Mock
+    @Mock private PreferenceScreen mPreferenceScreen;
-    private PreferenceScreen mPreferenceScreen;
+    @Mock private BatteryInfo mBatteryInfo;
-    @Mock
+    @Mock private EntityHeaderController mEntityHeaderController;
-    private BatteryInfo mBatteryInfo;
+    @Mock private UsageProgressBarPreference mBatteryUsageProgressBarPref;
-    @Mock
+    @Mock private BatteryStatusFeatureProvider mBatteryStatusFeatureProvider;
-    private EntityHeaderController mEntityHeaderController;
+    @Mock private UsbPort mUsbPort;
-    @Mock
+    @Mock private UsbManager mUsbManager;
-    private UsageProgressBarPreference mBatteryUsageProgressBarPref;
+    @Mock private UsbPortStatus mUsbPortStatus;
-    @Mock
-    private BatteryStatusFeatureProvider mBatteryStatusFeatureProvider;
-    @Mock
-    private UsbPort mUsbPort;
-    @Mock
-    private UsbManager mUsbManager;
-    @Mock
-    private UsbPortStatus mUsbPortStatus;
 
     private BatteryHeaderPreferenceController mController;
     private Context mContext;
@@ -104,8 +96,9 @@ public class BatteryHeaderPreferenceControllerTest {
         mBatteryIntent.putExtra(BatteryManager.EXTRA_PLUGGED, 1);
         doReturn(mBatteryIntent).when(mContext).registerReceiver(any(), any());
 
-        doReturn(mBatteryUsageProgressBarPref).when(mPreferenceScreen)
+        doReturn(mBatteryUsageProgressBarPref)
-            .findPreference(BatteryHeaderPreferenceController.KEY_BATTERY_HEADER);
+                .when(mPreferenceScreen)
+                .findPreference(BatteryHeaderPreferenceController.KEY_BATTERY_HEADER);
 
         mBatteryInfo.batteryLevel = BATTERY_LEVEL;
 
@@ -235,8 +228,8 @@ public class BatteryHeaderPreferenceControllerTest {
     @Test
     public void updateHeaderByBatteryTips_lowBatteryTip_showLowBattery() {
         setChargingState(/* isDischarging */ true, /* updatedByStatusFeature */ false);
-        BatteryTip lowBatteryTip = new LowBatteryTip(
+        BatteryTip lowBatteryTip =
-                BatteryTip.StateType.NEW, /* powerSaveModeOn */false);
+                new LowBatteryTip(BatteryTip.StateType.NEW, /* powerSaveModeOn */ false);
 
         mController.updateHeaderByBatteryTips(lowBatteryTip, mBatteryInfo);
 
@@ -265,8 +258,8 @@ public class BatteryHeaderPreferenceControllerTest {
 
     @Test
     public void updateHeaderByBatteryTips_noBatteryInfo_noAction() {
-        BatteryTip lowBatteryTip = new LowBatteryTip(
+        BatteryTip lowBatteryTip =
-                BatteryTip.StateType.NEW, /* powerSaveModeOn */false);
+                new LowBatteryTip(BatteryTip.StateType.NEW, /* powerSaveModeOn */ false);
 
         mController.updateHeaderByBatteryTips(lowBatteryTip, null);
 
@@ -288,8 +281,10 @@ public class BatteryHeaderPreferenceControllerTest {
 
         mController.updateHeaderPreference(mBatteryInfo);
 
-        verify(mBatteryUsageProgressBarPref).setBottomSummary(mContext.getString(
+        verify(mBatteryUsageProgressBarPref)
-                com.android.settingslib.R.string.battery_info_status_not_charging));
+                .setBottomSummary(
+                        mContext.getString(
+                                com.android.settingslib.R.string.battery_info_status_not_charging));
     }
 
     @Test
@@ -302,8 +297,8 @@ public class BatteryHeaderPreferenceControllerTest {
 
     @Test
     public void getAvailabilityStatus_returnAvailableUnsearchable() {
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+        assertThat(mController.getAvailabilityStatus())
-                BasePreferenceController.AVAILABLE_UNSEARCHABLE);
+                .isEqualTo(BasePreferenceController.AVAILABLE_UNSEARCHABLE);
     }
 
     @Test
@@ -319,12 +314,13 @@ public class BatteryHeaderPreferenceControllerTest {
     public void displayPreference_init_showLoading() {
         mController.displayPreference(mPreferenceScreen);
 
-        verify(mBatteryUsageProgressBarPref).setBottomSummary(
+        verify(mBatteryUsageProgressBarPref)
-                mContext.getString(R.string.settings_license_activity_loading));
+                .setBottomSummary(mContext.getString(R.string.settings_license_activity_loading));
     }
 
     private CharSequence formatBatteryPercentageText() {
-        return TextUtils.expandTemplate(mContext.getText(R.string.battery_header_title_alternate),
+        return TextUtils.expandTemplate(
+                mContext.getText(R.string.battery_header_title_alternate),
                 NumberFormat.getIntegerInstance().format(BATTERY_LEVEL));
     }
 
@@ -333,7 +329,7 @@ public class BatteryHeaderPreferenceControllerTest {
         mBatteryInfo.statusLabel = BATTERY_STATUS;
         mBatteryInfo.discharging = isDischarging;
 
-        when(mBatteryStatusFeatureProvider.triggerBatteryStatusUpdate(
+        when(mBatteryStatusFeatureProvider.triggerBatteryStatusUpdate(mController, mBatteryInfo))
-                mController, mBatteryInfo)).thenReturn(updatedByStatusFeature);
+                .thenReturn(updatedByStatusFeature);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/BatteryInfoLoaderTest.java

@@ -46,10 +46,8 @@ public class BatteryInfoLoaderTest {
 
     private static final long TEST_TIME_REMAINING = 1000L;
 
-    @Mock
+    @Mock private BatteryStatsManager mBatteryStatsManager;
-    private BatteryStatsManager mBatteryStatsManager;
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    @Mock
-    private BatteryUsageStats mBatteryUsageStats;
 
     private Context mContext;
 

tests/robotests/src/com/android/settings/fuelgauge/BatteryInfoTest.java

@@ -72,21 +72,20 @@ public class BatteryInfoTest {
     private static final String ENHANCED_STRING_SUFFIX = "based on your usage";
     private static final String BATTERY_RUN_OUT_PREFIX = "Battery may run out by";
     private static final long TEST_CHARGE_TIME_REMAINING = TimeUnit.MINUTES.toMicros(1);
-    private static final String TEST_CHARGE_TIME_REMAINING_STRINGIFIED =
+    private static final String TEST_CHARGE_TIME_REMAINING_STRINGIFIED = "1 min left until full";
-            "1 min left until full";
     private static final String TEST_BATTERY_LEVEL_10 = "10%";
     private static final String FIFTEEN_MIN_FORMATTED = "15 min";
-    private static final Estimate MOCK_ESTIMATE = new Estimate(
+    private static final Estimate MOCK_ESTIMATE =
-            1000, /* estimateMillis */
+            new Estimate(
-            false, /* isBasedOnUsage */
+                    1000, /* estimateMillis */
-            1000 /* averageDischargeTime */);
+                    false, /* isBasedOnUsage */
+                    1000 /* averageDischargeTime */);
 
     private Intent mDisChargingBatteryBroadcast;
     private Intent mChargingBatteryBroadcast;
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
-    @Mock
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    private BatteryUsageStats mBatteryUsageStats;
 
     @Before
     public void setUp() {
@@ -99,17 +98,22 @@ public class BatteryInfoTest {
         mChargingBatteryBroadcast = BatteryTestUtils.getChargingIntent();
 
         doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isExtraDefend();
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS, 0);
+                mContext.getContentResolver(),
+                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS,
+                0);
     }
 
     @Test
     public void testGetBatteryInfo_hasStatusLabel() {
         doReturn(REMAINING_TIME_NULL).when(mBatteryUsageStats).getBatteryTimeRemainingMs();
-        BatteryInfo info = BatteryInfo.getBatteryInfoOld(mContext,
+        BatteryInfo info =
-                mDisChargingBatteryBroadcast, mBatteryUsageStats,
+                BatteryInfo.getBatteryInfoOld(
-                SystemClock.elapsedRealtime() * 1000,
+                        mContext,
-                true /* shortString */);
+                        mDisChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        SystemClock.elapsedRealtime() * 1000,
+                        true /* shortString */);
 
         assertThat(info.statusLabel).isEqualTo(STATUS_NOT_CHARGING);
     }
@@ -117,8 +121,13 @@ public class BatteryInfoTest {
     @Test
     public void testGetBatteryInfo_doNotShowChargingMethod_hasRemainingTime() {
         doReturn(REMAINING_TIME).when(mBatteryUsageStats).getChargeTimeRemainingMs();
-        BatteryInfo info = BatteryInfo.getBatteryInfoOld(mContext, mChargingBatteryBroadcast,
+        BatteryInfo info =
-                mBatteryUsageStats, SystemClock.elapsedRealtime() * 1000, false /* shortString */);
+                BatteryInfo.getBatteryInfoOld(
+                        mContext,
+                        mChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.chargeLabel.toString()).isEqualTo(STATUS_CHARGING_TIME);
     }
@@ -126,8 +135,13 @@ public class BatteryInfoTest {
     @Test
     public void testGetBatteryInfo_doNotShowChargingMethod_noRemainingTime() {
         doReturn(REMAINING_TIME_NULL).when(mBatteryUsageStats).getChargeTimeRemainingMs();
-        BatteryInfo info = BatteryInfo.getBatteryInfoOld(mContext, mChargingBatteryBroadcast,
+        BatteryInfo info =
-                mBatteryUsageStats, SystemClock.elapsedRealtime() * 1000, false /* shortString */);
+                BatteryInfo.getBatteryInfoOld(
+                        mContext,
+                        mChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.chargeLabel.toString()).ignoringCase().isEqualTo(STATUS_CHARGING_NO_TIME);
     }
@@ -135,9 +149,15 @@ public class BatteryInfoTest {
     @Test
     public void testGetBatteryInfo_pluggedInUsingShortString_usesCorrectData() {
         doReturn(TEST_CHARGE_TIME_REMAINING / 1000)
-                .when(mBatteryUsageStats).getChargeTimeRemainingMs();
+                .when(mBatteryUsageStats)
-        BatteryInfo info = BatteryInfo.getBatteryInfoOld(mContext, mChargingBatteryBroadcast,
+                .getChargeTimeRemainingMs();
-                mBatteryUsageStats, SystemClock.elapsedRealtime() * 1000, true /* shortString */);
+        BatteryInfo info =
+                BatteryInfo.getBatteryInfoOld(
+                        mContext,
+                        mChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        SystemClock.elapsedRealtime() * 1000,
+                        true /* shortString */);
 
         assertThat(info.discharging).isEqualTo(false);
         assertThat(info.chargeLabel.toString()).isEqualTo("50% - 1 min left until full");
@@ -145,15 +165,27 @@ public class BatteryInfoTest {
 
     @Test
     public void testGetBatteryInfo_basedOnUsageTrueMoreThanFifteenMinutes_usesCorrectString() {
-        Estimate estimate = new Estimate(Duration.ofHours(4).toMillis(),
+        Estimate estimate =
-                true /* isBasedOnUsage */,
+                new Estimate(
-                1000 /* averageDischargeTime */);
+                        Duration.ofHours(4).toMillis(),
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext, mDisChargingBatteryBroadcast,
+                        true /* isBasedOnUsage */,
-                mBatteryUsageStats, estimate, SystemClock.elapsedRealtime() * 1000,
+                        1000 /* averageDischargeTime */);
-                false /* shortString */);
+        BatteryInfo info =
-        BatteryInfo info2 = BatteryInfo.getBatteryInfo(mContext, mDisChargingBatteryBroadcast,
+                BatteryInfo.getBatteryInfo(
-                mBatteryUsageStats, estimate, SystemClock.elapsedRealtime() * 1000,
+                        mContext,
-                true /* shortString */);
+                        mDisChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        estimate,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
+        BatteryInfo info2 =
+                BatteryInfo.getBatteryInfo(
+                        mContext,
+                        mDisChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        estimate,
+                        SystemClock.elapsedRealtime() * 1000,
+                        true /* shortString */);
 
         // Both long and short strings should not have extra text
         assertThat(info.remainingLabel.toString()).doesNotContain(ENHANCED_STRING_SUFFIX);
@@ -165,24 +197,41 @@ public class BatteryInfoTest {
     @Test
     @Ignore
     public void getBatteryInfo_MoreThanOneDay_suggestionLabelIsCorrectString() {
-        Estimate estimate = new Estimate(Duration.ofDays(3).toMillis(),
+        Estimate estimate =
-                true /* isBasedOnUsage */,
+                new Estimate(
-                1000 /* averageDischargeTime */);
+                        Duration.ofDays(3).toMillis(),
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext, mDisChargingBatteryBroadcast,
+                        true /* isBasedOnUsage */,
-                mBatteryUsageStats, estimate, SystemClock.elapsedRealtime() * 1000,
+                        1000 /* averageDischargeTime */);
-                false /* shortString */);
+        BatteryInfo info =
+                BatteryInfo.getBatteryInfo(
+                        mContext,
+                        mDisChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        estimate,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.suggestionLabel).doesNotContain(BATTERY_RUN_OUT_PREFIX);
     }
 
     @Test
     public void testGetBatteryInfo_basedOnUsageFalse_usesDefaultString() {
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext, mDisChargingBatteryBroadcast,
+        BatteryInfo info =
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                BatteryInfo.getBatteryInfo(
-                false /* shortString */);
+                        mContext,
-        BatteryInfo info2 = BatteryInfo.getBatteryInfo(mContext, mDisChargingBatteryBroadcast,
+                        mDisChargingBatteryBroadcast,
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                        mBatteryUsageStats,
-                true /* shortString */);
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
+        BatteryInfo info2 =
+                BatteryInfo.getBatteryInfo(
+                        mContext,
+                        mDisChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        true /* shortString */);
 
         assertThat(info.remainingLabel.toString()).doesNotContain(ENHANCED_STRING_SUFFIX);
         assertThat(info2.remainingLabel.toString()).doesNotContain(ENHANCED_STRING_SUFFIX);
@@ -191,11 +240,17 @@ public class BatteryInfoTest {
     @Test
     public void testGetBatteryInfo_charging_usesChargeTime() {
         doReturn(TEST_CHARGE_TIME_REMAINING / 1000)
-                .when(mBatteryUsageStats).getChargeTimeRemainingMs();
+                .when(mBatteryUsageStats)
+                .getChargeTimeRemainingMs();
 
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext, mChargingBatteryBroadcast,
+        BatteryInfo info =
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                BatteryInfo.getBatteryInfo(
-                false /* shortString */);
+                        mContext,
+                        mChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.remainingTimeUs).isEqualTo(TEST_CHARGE_TIME_REMAINING);
         assertThat(info.remainingLabel.toString())
@@ -206,24 +261,33 @@ public class BatteryInfoTest {
     public void testGetBatteryInfo_pluggedInWithFullBattery_onlyShowBatteryLevel() {
         mChargingBatteryBroadcast.putExtra(BatteryManager.EXTRA_LEVEL, 100);
 
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext, mChargingBatteryBroadcast,
+        BatteryInfo info =
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                BatteryInfo.getBatteryInfo(
-                false /* shortString */);
+                        mContext,
+                        mChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.chargeLabel).isEqualTo("100%");
     }
 
     @Test
     public void testGetBatteryInfo_chargingWithDefender_updateChargeLabel() {
-        doReturn(TEST_CHARGE_TIME_REMAINING)
+        doReturn(TEST_CHARGE_TIME_REMAINING).when(mBatteryUsageStats).getChargeTimeRemainingMs();
-                .when(mBatteryUsageStats)
+        mChargingBatteryBroadcast.putExtra(
-                .getChargeTimeRemainingMs();
+                BatteryManager.EXTRA_CHARGING_STATUS,
-        mChargingBatteryBroadcast.putExtra(BatteryManager.EXTRA_CHARGING_STATUS,
                 BatteryManager.CHARGING_POLICY_ADAPTIVE_LONGLIFE);
 
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext, mChargingBatteryBroadcast,
+        BatteryInfo info =
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                BatteryInfo.getBatteryInfo(
-                false /* shortString */);
+                        mContext,
+                        mChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.isBatteryDefender).isTrue();
         assertThat(info.chargeLabel.toString()).contains(STATUS_CHARGING_PAUSED);
@@ -231,30 +295,32 @@ public class BatteryInfoTest {
 
     @Test
     public void testGetBatteryInfo_getChargeTimeRemaining_updateSettingsGlobal() {
-        doReturn(TEST_CHARGE_TIME_REMAINING)
+        doReturn(TEST_CHARGE_TIME_REMAINING).when(mBatteryUsageStats).getChargeTimeRemainingMs();
-                .when(mBatteryUsageStats)
-                .getChargeTimeRemainingMs();
 
-        BatteryInfo.getBatteryInfo(mContext, mChargingBatteryBroadcast,
+        BatteryInfo.getBatteryInfo(
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                mContext,
+                mChargingBatteryBroadcast,
+                mBatteryUsageStats,
+                MOCK_ESTIMATE,
+                SystemClock.elapsedRealtime() * 1000,
                 false /* shortString */);
 
-        assertThat(BatteryInfo.getSettingsChargeTimeRemaining(mContext)).isEqualTo(
+        assertThat(BatteryInfo.getSettingsChargeTimeRemaining(mContext))
-                TEST_CHARGE_TIME_REMAINING);
+                .isEqualTo(TEST_CHARGE_TIME_REMAINING);
     }
 
     @Test
     public void testGetBatteryInfo_differentChargeTimeRemaining_updateSettingsGlobal() {
-        doReturn(TEST_CHARGE_TIME_REMAINING)
+        doReturn(TEST_CHARGE_TIME_REMAINING).when(mBatteryUsageStats).getChargeTimeRemainingMs();
-                .when(mBatteryUsageStats)
-                .getChargeTimeRemainingMs();
         final long newTimeToFull = 300L;
-        doReturn(newTimeToFull)
+        doReturn(newTimeToFull).when(mBatteryUsageStats).getChargeTimeRemainingMs();
-                .when(mBatteryUsageStats)
-                .getChargeTimeRemainingMs();
 
-        BatteryInfo.getBatteryInfo(mContext, mChargingBatteryBroadcast,
+        BatteryInfo.getBatteryInfo(
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                mContext,
+                mChargingBatteryBroadcast,
+                mBatteryUsageStats,
+                MOCK_ESTIMATE,
+                SystemClock.elapsedRealtime() * 1000,
                 false /* shortString */);
 
         assertThat(BatteryInfo.getSettingsChargeTimeRemaining(mContext)).isEqualTo(newTimeToFull);
@@ -263,18 +329,27 @@ public class BatteryInfoTest {
     @Test
     public void testGetBatteryInfo_dockDefenderActive_updateChargeString() {
         doReturn(TEST_CHARGE_TIME_REMAINING / 1000)
-                .when(mBatteryUsageStats).getChargeTimeRemainingMs();
+                .when(mBatteryUsageStats)
+                .getChargeTimeRemainingMs();
         doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isExtraDefend();
-        Intent intent = BatteryTestUtils.getCustomBatteryIntent(BatteryManager.BATTERY_PLUGGED_DOCK,
+        Intent intent =
-                        50 /* level */,
+                BatteryTestUtils.getCustomBatteryIntent(
-                        100 /* scale */,
+                                BatteryManager.BATTERY_PLUGGED_DOCK,
-                        BatteryManager.BATTERY_STATUS_CHARGING)
+                                50 /* level */,
-                .putExtra(BatteryManager.EXTRA_CHARGING_STATUS,
+                                100 /* scale */,
-                        BatteryManager.CHARGING_POLICY_ADAPTIVE_LONGLIFE);
+                                BatteryManager.BATTERY_STATUS_CHARGING)
+                        .putExtra(
+                                BatteryManager.EXTRA_CHARGING_STATUS,
+                                BatteryManager.CHARGING_POLICY_ADAPTIVE_LONGLIFE);
 
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext, intent,
+        BatteryInfo info =
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                BatteryInfo.getBatteryInfo(
-                false /* shortString */);
+                        mContext,
+                        intent,
+                        mBatteryUsageStats,
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.chargeLabel.toString()).contains(STATUS_CHARGING_PAUSED);
     }
@@ -282,18 +357,25 @@ public class BatteryInfoTest {
     @Test
     public void testGetBatteryInfo_dockDefenderTemporarilyBypassed_updateChargeLabel() {
         doReturn(REMAINING_TIME).when(mBatteryUsageStats).getChargeTimeRemainingMs();
-        mChargingBatteryBroadcast.putExtra(BatteryManager.EXTRA_CHARGING_STATUS,
+        mChargingBatteryBroadcast.putExtra(
-                BatteryManager.CHARGING_POLICY_DEFAULT);
+                BatteryManager.EXTRA_CHARGING_STATUS, BatteryManager.CHARGING_POLICY_DEFAULT);
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS, 1);
+                mContext.getContentResolver(),
+                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS,
+                1);
 
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext,
+        BatteryInfo info =
-                BatteryTestUtils.getCustomBatteryIntent(BatteryManager.BATTERY_PLUGGED_DOCK,
+                BatteryInfo.getBatteryInfo(
-                        50 /* level */,
+                        mContext,
-                        100 /* scale */,
+                        BatteryTestUtils.getCustomBatteryIntent(
-                        BatteryManager.BATTERY_STATUS_CHARGING),
+                                BatteryManager.BATTERY_PLUGGED_DOCK,
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                                50 /* level */,
-                false /* shortString */);
+                                100 /* scale */,
+                                BatteryManager.BATTERY_STATUS_CHARGING),
+                        mBatteryUsageStats,
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.chargeLabel.toString()).contains(STATUS_CHARGING_TIME);
     }
@@ -301,16 +383,21 @@ public class BatteryInfoTest {
     @Test
     public void testGetBatteryInfo_dockDefenderFutureBypass_updateChargeLabel() {
         doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isExtraDefend();
-        mChargingBatteryBroadcast.putExtra(BatteryManager.EXTRA_CHARGING_STATUS,
+        mChargingBatteryBroadcast.putExtra(
-                BatteryManager.CHARGING_POLICY_DEFAULT);
+                BatteryManager.EXTRA_CHARGING_STATUS, BatteryManager.CHARGING_POLICY_DEFAULT);
 
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext,
+        BatteryInfo info =
-                BatteryTestUtils.getCustomBatteryIntent(BatteryManager.BATTERY_PLUGGED_DOCK,
+                BatteryInfo.getBatteryInfo(
-                        50 /* level */,
+                        mContext,
-                        100 /* scale */,
+                        BatteryTestUtils.getCustomBatteryIntent(
-                        BatteryManager.BATTERY_STATUS_CHARGING),
+                                BatteryManager.BATTERY_PLUGGED_DOCK,
-                mBatteryUsageStats, MOCK_ESTIMATE, SystemClock.elapsedRealtime() * 1000,
+                                50 /* level */,
-                false /* shortString */);
+                                100 /* scale */,
+                                BatteryManager.BATTERY_STATUS_CHARGING),
+                        mBatteryUsageStats,
+                        MOCK_ESTIMATE,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false /* shortString */);
 
         assertThat(info.chargeLabel.toString()).contains(STATUS_CHARGING_FUTURE_BYPASS);
     }
@@ -318,15 +405,20 @@ public class BatteryInfoTest {
     // Make our battery stats return a sequence of battery events.
     private void mockBatteryStatsHistory() {
         // Mock out new data every time iterateBatteryStatsHistory is called.
-        doAnswer(invocation -> {
+        doAnswer(
-            BatteryStatsHistoryIterator iterator = mock(BatteryStatsHistoryIterator.class);
+                        invocation -> {
-            when(iterator.next()).thenReturn(
+                            BatteryStatsHistoryIterator iterator =
-                    makeHistoryIterm(1000, 99),
+                                    mock(BatteryStatsHistoryIterator.class);
-                    makeHistoryIterm(1500, 98),
+                            when(iterator.next())
-                    makeHistoryIterm(2000, 97),
+                                    .thenReturn(
-                    null);
+                                            makeHistoryIterm(1000, 99),
-            return iterator;
+                                            makeHistoryIterm(1500, 98),
-        }).when(mBatteryUsageStats).iterateBatteryStatsHistory();
+                                            makeHistoryIterm(2000, 97),
+                                            null);
+                            return iterator;
+                        })
+                .when(mBatteryUsageStats)
+                .iterateBatteryStatsHistory();
     }
 
     private BatteryStats.HistoryItem makeHistoryIterm(long time, int batteryLevel) {
@@ -373,7 +465,8 @@ public class BatteryInfoTest {
         pointsExpected.append(2000, 96);
         pointsExpected.append(2500, 95);
         pointsExpected.append(3000, 94);
-        doReturn(pointsExpected).when(mFeatureFactory.powerUsageFeatureProvider)
+        doReturn(pointsExpected)
+                .when(mFeatureFactory.powerUsageFeatureProvider)
                 .getEnhancedBatteryPredictionCurve(any(Context.class), anyLong());
 
         info.bindHistory(view);
@@ -390,14 +483,21 @@ public class BatteryInfoTest {
         } else {
             doReturn(0L).when(mBatteryUsageStats).getChargeTimeRemainingMs();
         }
-        Estimate batteryEstimate = new Estimate(
+        Estimate batteryEstimate =
-                estimate ? 1000 : 0,
+                new Estimate(
-                false /* isBasedOnUsage */,
+                        estimate ? 1000 : 0,
-                1000 /* averageDischargeTime */);
+                        false /* isBasedOnUsage */,
-        BatteryInfo info = BatteryInfo.getBatteryInfo(mContext,
+                        1000 /* averageDischargeTime */);
-                charging ? mChargingBatteryBroadcast : mDisChargingBatteryBroadcast,
+        BatteryInfo info =
-                mBatteryUsageStats, batteryEstimate, SystemClock.elapsedRealtime() * 1000, false);
+                BatteryInfo.getBatteryInfo(
-        doReturn(enhanced).when(mFeatureFactory.powerUsageFeatureProvider)
+                        mContext,
+                        charging ? mChargingBatteryBroadcast : mDisChargingBatteryBroadcast,
+                        mBatteryUsageStats,
+                        batteryEstimate,
+                        SystemClock.elapsedRealtime() * 1000,
+                        false);
+        doReturn(enhanced)
+                .when(mFeatureFactory.powerUsageFeatureProvider)
                 .isEnhancedBatteryPredictionEnabled(mContext);
         return info;
     }

tests/robotests/src/com/android/settings/fuelgauge/BatteryMeterViewTest.java

@@ -39,12 +39,9 @@ public class BatteryMeterViewTest {
     private static final int BATTERY_CRITICAL_LEVEL = 15;
     private static final int BATTERY_LOW_LEVEL = 3;
 
-    @Mock
+    @Mock private ColorFilter mErrorColorFilter;
-    private ColorFilter mErrorColorFilter;
+    @Mock private ColorFilter mAccentColorFilter;
-    @Mock
+    @Mock private ColorFilter mForegroundColorFilter;
-    private ColorFilter mAccentColorFilter;
-    @Mock
-    private ColorFilter mForegroundColorFilter;
     private Context mContext;
     private BatteryMeterView mBatteryMeterView;
     private BatteryMeterView.BatteryMeterDrawable mDrawable;

tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeLogUtilsTest.java

@@ -57,8 +57,7 @@ public final class BatteryOptimizeLogUtilsTest {
         BatteryOptimizeLogUtils.writeLog(mContext, Action.APPLY, "pkg1", "logs");
         BatteryOptimizeLogUtils.printBatteryOptimizeHistoricalLog(mContext, mTestPrintWriter);
 
-        assertThat(mTestStringWriter.toString()).contains(
+        assertThat(mTestStringWriter.toString()).contains("pkg1\taction:APPLY\tevent:logs");
-                "pkg1\taction:APPLY\tevent:logs");
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java

@@ -98,8 +98,7 @@ public class BatteryOptimizeUtilsTest {
         when(mMockAppOpsManager.checkOpNoThrow(anyInt(), anyInt(), anyString()))
                 .thenReturn(AppOpsManager.MODE_IGNORED);
 
-        assertThat(mBatteryOptimizeUtils.getAppOptimizationMode())
+        assertThat(mBatteryOptimizeUtils.getAppOptimizationMode()).isEqualTo(MODE_RESTRICTED);
-                .isEqualTo(MODE_RESTRICTED);
     }
 
     @Test
@@ -108,8 +107,7 @@ public class BatteryOptimizeUtilsTest {
         when(mMockAppOpsManager.checkOpNoThrow(anyInt(), anyInt(), anyString()))
                 .thenReturn(AppOpsManager.MODE_ALLOWED);
 
-        assertThat(mBatteryOptimizeUtils.getAppOptimizationMode())
+        assertThat(mBatteryOptimizeUtils.getAppOptimizationMode()).isEqualTo(MODE_UNRESTRICTED);
-                .isEqualTo(MODE_UNRESTRICTED);
     }
 
     @Test
@@ -118,8 +116,7 @@ public class BatteryOptimizeUtilsTest {
         when(mMockAppOpsManager.checkOpNoThrow(anyInt(), anyInt(), anyString()))
                 .thenReturn(AppOpsManager.MODE_ALLOWED);
 
-        assertThat(mBatteryOptimizeUtils.getAppOptimizationMode())
+        assertThat(mBatteryOptimizeUtils.getAppOptimizationMode()).isEqualTo(MODE_OPTIMIZED);
-                .isEqualTo(MODE_OPTIMIZED);
     }
 
     @Test
@@ -168,7 +165,6 @@ public class BatteryOptimizeUtilsTest {
         when(mMockAppOpsManager.checkOpNoThrow(anyInt(), anyInt(), anyString()))
                 .thenReturn(AppOpsManager.MODE_IGNORED);
 
-
         mBatteryOptimizeUtils.setAppUsageState(MODE_UNRESTRICTED, Action.UNKNOWN);
         TimeUnit.SECONDS.sleep(1);
 
@@ -205,18 +201,19 @@ public class BatteryOptimizeUtilsTest {
 
     @Test
     public void testGetInstalledApplications_returnEmptyArray() {
-        assertTrue(BatteryOptimizeUtils.getInstalledApplications(mContext, mMockIPackageManager)
+        assertTrue(
-                .isEmpty());
+                BatteryOptimizeUtils.getInstalledApplications(mContext, mMockIPackageManager)
+                        .isEmpty());
     }
 
     @Test
     public void testGetInstalledApplications_returnNull() throws Exception {
         final UserInfo userInfo =
-                new UserInfo(/*userId=*/ 0, /*userName=*/ "google", /*flag=*/ 0);
+                new UserInfo(/* userId= */ 0, /* userName= */ "google", /* flag= */ 0);
         doReturn(Arrays.asList(userInfo)).when(mMockUserManager).getProfiles(anyInt());
         doThrow(new RuntimeException())
-            .when(mMockIPackageManager)
+                .when(mMockIPackageManager)
-            .getInstalledApplications(anyLong(), anyInt());
+                .getInstalledApplications(anyLong(), anyInt());
 
         assertNull(BatteryOptimizeUtils.getInstalledApplications(mContext, mMockIPackageManager));
     }
@@ -224,7 +221,7 @@ public class BatteryOptimizeUtilsTest {
     @Test
     public void testGetInstalledApplications_returnInstalledApps() throws Exception {
         final UserInfo userInfo =
-                new UserInfo(/*userId=*/ 0, /*userName=*/ "google", /*flag=*/ 0);
+                new UserInfo(/* userId= */ 0, /* userName= */ "google", /* flag= */ 0);
         doReturn(Arrays.asList(userInfo)).when(mMockUserManager).getProfiles(anyInt());
 
         final ApplicationInfo applicationInfo1 = new ApplicationInfo();
@@ -242,10 +239,15 @@ public class BatteryOptimizeUtilsTest {
         applicationInfo4.enabled = true;
         applicationInfo4.uid = 4;
         applicationInfo4.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
-        doReturn(new ParceledListSlice<ApplicationInfo>(
+        doReturn(
-            Arrays.asList(applicationInfo1, applicationInfo2, applicationInfo3, applicationInfo4)))
+                        new ParceledListSlice<ApplicationInfo>(
-            .when(mMockIPackageManager)
+                                Arrays.asList(
-            .getInstalledApplications(anyLong(), anyInt());
+                                        applicationInfo1,
+                                        applicationInfo2,
+                                        applicationInfo3,
+                                        applicationInfo4)))
+                .when(mMockIPackageManager)
+                .getInstalledApplications(anyLong(), anyInt());
 
         final ArraySet<ApplicationInfo> applications =
                 BatteryOptimizeUtils.getInstalledApplications(mContext, mMockIPackageManager);
@@ -260,7 +262,8 @@ public class BatteryOptimizeUtilsTest {
     @Test
     public void testResetAppOptimizationMode_Optimized_verifyAction() throws Exception {
         runTestForResetWithMode(
-                AppOpsManager.MODE_ALLOWED, /* allowListed */ false,
+                AppOpsManager.MODE_ALLOWED, /* allowListed */
+                false,
                 /* isSystemOrDefaultApp */ false);
 
         verifyNoInteractions(mMockBatteryUtils);
@@ -274,7 +277,8 @@ public class BatteryOptimizeUtilsTest {
     @Test
     public void testResetAppOptimizationMode_SystemOrDefault_verifyAction() throws Exception {
         runTestForResetWithMode(
-                AppOpsManager.MODE_ALLOWED, /* allowListed */ true,
+                AppOpsManager.MODE_ALLOWED, /* allowListed */
+                true,
                 /* isSystemOrDefaultApp */ true);
 
         verifyNoInteractions(mMockBatteryUtils);
@@ -289,7 +293,8 @@ public class BatteryOptimizeUtilsTest {
     @Test
     public void testResetAppOptimizationMode_Restricted_verifyAction() throws Exception {
         runTestForResetWithMode(
-                AppOpsManager.MODE_IGNORED, /* allowListed */ false,
+                AppOpsManager.MODE_IGNORED, /* allowListed */
+                false,
                 /* isSystemOrDefaultApp */ false);
 
         verifySetAppOptimizationMode(AppOpsManager.MODE_ALLOWED, /* allowListed */ false);
@@ -298,7 +303,8 @@ public class BatteryOptimizeUtilsTest {
     @Test
     public void testResetAppOptimizationMode_Unrestricted_verifyAction() throws Exception {
         runTestForResetWithMode(
-                AppOpsManager.MODE_ALLOWED, /* allowListed */ true,
+                AppOpsManager.MODE_ALLOWED, /* allowListed */
+                true,
                 /* isSystemOrDefaultApp */ false);
 
         verifySetAppOptimizationMode(AppOpsManager.MODE_ALLOWED, /* allowListed */ false);
@@ -308,32 +314,28 @@ public class BatteryOptimizeUtilsTest {
             int appStandbyMode, boolean allowListed, boolean isSystemOrDefaultApp)
             throws Exception {
         final UserInfo userInfo =
-                new UserInfo(/*userId=*/ 0, /*userName=*/ "google", /*flag=*/ 0);
+                new UserInfo(/* userId= */ 0, /* userName= */ "google", /* flag= */ 0);
         doReturn(Arrays.asList(userInfo)).when(mMockUserManager).getProfiles(anyInt());
         final ApplicationInfo applicationInfo = new ApplicationInfo();
         applicationInfo.uid = UID;
         applicationInfo.packageName = PACKAGE_NAME;
         applicationInfo.enabled = true;
-        doReturn(new ParceledListSlice<ApplicationInfo>(
+        doReturn(new ParceledListSlice<ApplicationInfo>(Arrays.asList(applicationInfo)))
-                Arrays.asList(applicationInfo)))
                 .when(mMockIPackageManager)
                 .getInstalledApplications(anyLong(), anyInt());
 
         doReturn(appStandbyMode)
                 .when(mMockAppOpsManager)
                 .checkOpNoThrow(anyInt(), anyInt(), anyString());
-        doReturn(allowListed)
+        doReturn(allowListed).when(mMockBackend).isAllowlisted(anyString(), anyInt());
-                .when(mMockBackend)
+        doReturn(isSystemOrDefaultApp).when(mMockBackend).isSysAllowlisted(anyString());
-                .isAllowlisted(anyString(), anyInt());
+        doReturn(isSystemOrDefaultApp).when(mMockBackend).isDefaultActiveApp(anyString(), anyInt());
-        doReturn(isSystemOrDefaultApp)
-                .when(mMockBackend)
-                .isSysAllowlisted(anyString());
-        doReturn(isSystemOrDefaultApp)
-                .when(mMockBackend)
-                .isDefaultActiveApp(anyString(), anyInt());
 
         BatteryOptimizeUtils.resetAppOptimizationMode(
-                mContext, mMockIPackageManager, mMockAppOpsManager, mMockBackend,
+                mContext,
+                mMockIPackageManager,
+                mMockAppOpsManager,
+                mMockBackend,
                 mMockBatteryUtils);
         TimeUnit.SECONDS.sleep(1);
     }

tests/robotests/src/com/android/settings/fuelgauge/BatterySaverControllerTest.java

@@ -21,11 +21,9 @@ import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import android.app.settings.SettingsEnums;
 import android.content.Context;
 import android.os.PowerManager;
 import android.provider.Settings;
-import android.util.Pair;
 
 import androidx.preference.Preference;
 
@@ -41,10 +39,8 @@ import org.robolectric.util.ReflectionHelpers;
 @RunWith(RobolectricTestRunner.class)
 public class BatterySaverControllerTest {
 
-    @Mock
+    @Mock private Preference mBatterySaverPref;
-    private Preference mBatterySaverPref;
+    @Mock private PowerManager mPowerManager;
-    @Mock
-    private PowerManager mPowerManager;
 
     private BatterySaverController mBatterySaverController;
     private Context mContext;
@@ -58,8 +54,8 @@ public class BatterySaverControllerTest {
         ReflectionHelpers.setField(mBatterySaverController, "mPowerManager", mPowerManager);
         ReflectionHelpers.setField(mBatterySaverController, "mBatterySaverPref", mBatterySaverPref);
 
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0);
+                mContext.getContentResolver(), Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0);
     }
 
     @Test
@@ -84,8 +80,8 @@ public class BatterySaverControllerTest {
     @Test
     public void getSummary_batterySaverOffButScheduled_showSummaryScheduled() {
         when(mPowerManager.isPowerSaveMode()).thenReturn(false);
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 15);
+                mContext.getContentResolver(), Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 15);
 
         assertThat(mBatterySaverController.getSummary()).isEqualTo("Will turn on at 15%");
     }
@@ -93,8 +89,8 @@ public class BatterySaverControllerTest {
     @Test
     public void getSummary_batterySaverOffButScheduledZeroPercent_showSummaryOff() {
         when(mPowerManager.isPowerSaveMode()).thenReturn(false);
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0);
+                mContext.getContentResolver(), Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0);
 
         assertThat(mBatterySaverController.getSummary()).isEqualTo("Off");
     }
@@ -107,8 +103,8 @@ public class BatterySaverControllerTest {
                 Settings.Global.AUTOMATIC_POWER_SAVE_MODE,
                 PowerManager.POWER_SAVE_MODE_TRIGGER_DYNAMIC);
 
-        assertThat(mBatterySaverController.getSummary()).
+        assertThat(mBatterySaverController.getSummary())
-                isEqualTo("Will turn on based on your routine");
+                .isEqualTo("Will turn on based on your routine");
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/BatterySaverReceiverTest.java

@@ -32,10 +32,8 @@ import org.robolectric.RobolectricTestRunner;
 @RunWith(RobolectricTestRunner.class)
 public class BatterySaverReceiverTest {
 
-    @Mock
+    @Mock private BatterySaverReceiver.BatterySaverListener mBatterySaverListener;
-    private BatterySaverReceiver.BatterySaverListener mBatterySaverListener;
+    @Mock private Context mContext;
-    @Mock
-    private Context mContext;
     private BatterySaverReceiver mBatterySaverReceiver;
 
     @Before

tests/robotests/src/com/android/settings/fuelgauge/BatterySettingsMigrateCheckerTest.java

@@ -56,18 +56,15 @@ import java.util.Arrays;
 @Config(shadows = {BatterySettingsMigrateCheckerTest.ShadowUserHandle.class})
 public final class BatterySettingsMigrateCheckerTest {
 
-    private static final Intent BOOT_COMPLETED_INTENT =
+    private static final Intent BOOT_COMPLETED_INTENT = new Intent(Intent.ACTION_BOOT_COMPLETED);
-            new Intent(Intent.ACTION_BOOT_COMPLETED);
     private static final int UID = 2003;
     private static final String PACKAGE_NAME = "com.android.test.app";
 
     private Context mContext;
     private BatterySettingsMigrateChecker mBatterySettingsMigrateChecker;
 
-    @Mock
+    @Mock private PackageManager mPackageManager;
-    private PackageManager mPackageManager;
+    @Mock private BatteryOptimizeUtils mBatteryOptimizeUtils;
-    @Mock
-    private BatteryOptimizeUtils mBatteryOptimizeUtils;
 
     @Before
     public void setUp() throws Exception {
@@ -76,7 +73,8 @@ public final class BatterySettingsMigrateCheckerTest {
         BatteryUtils.getInstance(mContext).reset();
         doReturn(mContext).when(mContext).getApplicationContext();
         doReturn(mPackageManager).when(mContext).getPackageManager();
-        doReturn(UID).when(mPackageManager)
+        doReturn(UID)
+                .when(mPackageManager)
                 .getPackageUid(PACKAGE_NAME, PackageManager.GET_META_DATA);
         BatterySettingsMigrateChecker.sBatteryOptimizeUtils = mBatteryOptimizeUtils;
         mBatterySettingsMigrateChecker = new BatterySettingsMigrateChecker();
@@ -150,45 +148,42 @@ public final class BatterySettingsMigrateCheckerTest {
     }
 
     @Test
-    public void verifyBatteryOptimizeModeApps_inAllowList_resetOptimizationMode()
+    public void verifyBatteryOptimizeModeApps_inAllowList_resetOptimizationMode() throws Exception {
-            throws Exception {
+        doReturn(BatteryOptimizeUtils.MODE_RESTRICTED)
-        doReturn(BatteryOptimizeUtils.MODE_RESTRICTED).when(mBatteryOptimizeUtils)
+                .when(mBatteryOptimizeUtils)
                 .getAppOptimizationMode();
 
         mBatterySettingsMigrateChecker.verifyBatteryOptimizeModeApps(
-                mContext,
+                mContext, BatteryOptimizeUtils.MODE_OPTIMIZED, Arrays.asList(PACKAGE_NAME));
-                BatteryOptimizeUtils.MODE_OPTIMIZED,
-                Arrays.asList(PACKAGE_NAME));
 
         final InOrder inOrder = inOrder(mBatteryOptimizeUtils);
         inOrder.verify(mBatteryOptimizeUtils).getAppOptimizationMode();
-        inOrder.verify(mBatteryOptimizeUtils).setAppUsageState(
+        inOrder.verify(mBatteryOptimizeUtils)
-                BatteryOptimizeUtils.MODE_OPTIMIZED,
+                .setAppUsageState(
-                BatteryOptimizeHistoricalLogEntry.Action.FORCE_RESET);
+                        BatteryOptimizeUtils.MODE_OPTIMIZED,
+                        BatteryOptimizeHistoricalLogEntry.Action.FORCE_RESET);
     }
 
     @Test
     public void verifyBatteryOptimizeModeApps_optimizedMode_noAction() throws Exception {
-        doReturn(BatteryOptimizeUtils.MODE_OPTIMIZED).when(mBatteryOptimizeUtils)
+        doReturn(BatteryOptimizeUtils.MODE_OPTIMIZED)
+                .when(mBatteryOptimizeUtils)
                 .getAppOptimizationMode();
 
         mBatterySettingsMigrateChecker.verifyBatteryOptimizeModeApps(
-                mContext,
+                mContext, BatteryOptimizeUtils.MODE_OPTIMIZED, Arrays.asList(PACKAGE_NAME));
-                BatteryOptimizeUtils.MODE_OPTIMIZED,
-                Arrays.asList(PACKAGE_NAME));
 
         verify(mBatteryOptimizeUtils, never()).setAppUsageState(anyInt(), any());
     }
 
     @Test
     public void verifyBatteryOptimizeModeApps_notInAllowList_noAction() throws Exception {
-        doReturn(BatteryOptimizeUtils.MODE_RESTRICTED).when(mBatteryOptimizeUtils)
+        doReturn(BatteryOptimizeUtils.MODE_RESTRICTED)
+                .when(mBatteryOptimizeUtils)
                 .getAppOptimizationMode();
 
         mBatterySettingsMigrateChecker.verifyBatteryOptimizeModeApps(
-                mContext,
+                mContext, BatteryOptimizeUtils.MODE_OPTIMIZED, new ArrayList<String>());
-                BatteryOptimizeUtils.MODE_OPTIMIZED,
-                new ArrayList<String>());
 
         verifyNoInteractions(mBatteryOptimizeUtils);
     }

tests/robotests/src/com/android/settings/fuelgauge/BatteryUtilsTest.java

@@ -106,32 +106,22 @@ public class BatteryUtilsTest {
     private static final String INFO_EXCESSIVE = "anomaly_type=4,auto_restriction=false";
     private static final String INFO_WAKELOCK = "anomaly_type=1,auto_restriction=false";
 
-    @Mock
+    @Mock private BatteryStats.Uid mUid;
-    private BatteryStats.Uid mUid;
+    @Mock private BatteryStats.Timer mTimer;
-    @Mock
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    private BatteryStats.Timer mTimer;
+    @Mock private BatteryConsumer mAggregateBatteryConsumer;
-    @Mock
+    @Mock private BatteryInfo mBatteryInfo;
-    private BatteryUsageStats mBatteryUsageStats;
+    @Mock private PackageManager mPackageManager;
-    @Mock
+    @Mock private AppOpsManager mAppOpsManager;
-    private BatteryConsumer mAggregateBatteryConsumer;
+    @Mock private ApplicationInfo mApplicationInfo;
-    @Mock
+
-    private BatteryInfo mBatteryInfo;
-    @Mock
-    private PackageManager mPackageManager;
-    @Mock
-    private AppOpsManager mAppOpsManager;
-    @Mock
-    private ApplicationInfo mApplicationInfo;
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private BatteryStatsManager mBatteryStatsManager;
-    @Mock
+
-    private ApplicationInfo mHighApplicationInfo;
+    @Mock private ApplicationInfo mHighApplicationInfo;
-    @Mock
+    @Mock private ApplicationInfo mLowApplicationInfo;
-    private ApplicationInfo mLowApplicationInfo;
+    @Mock private PowerAllowlistBackend mPowerAllowlistBackend;
-    @Mock
+    @Mock private BatteryDatabaseManager mBatteryDatabaseManager;
-    private PowerAllowlistBackend mPowerAllowlistBackend;
-    @Mock
-    private BatteryDatabaseManager mBatteryDatabaseManager;
     private AnomalyInfo mAnomalyInfo;
     private BatteryUtils mBatteryUtils;
     private FakeFeatureFactory mFeatureFactory;
@@ -145,16 +135,21 @@ public class BatteryUtilsTest {
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mProvider = mFeatureFactory.powerUsageFeatureProvider;
 
-        doReturn(TIME_STATE_TOP).when(mUid).getProcessStateTime(eq(PROCESS_STATE_TOP), anyLong(),
+        doReturn(TIME_STATE_TOP)
-                anyInt());
+                .when(mUid)
-        doReturn(TIME_STATE_FOREGROUND_SERVICE).when(mUid).getProcessStateTime(
+                .getProcessStateTime(eq(PROCESS_STATE_TOP), anyLong(), anyInt());
-                eq(PROCESS_STATE_FOREGROUND_SERVICE), anyLong(), anyInt());
+        doReturn(TIME_STATE_FOREGROUND_SERVICE)
-        doReturn(TIME_STATE_TOP_SLEEPING).when(mUid).getProcessStateTime(
+                .when(mUid)
-                eq(PROCESS_STATE_TOP_SLEEPING), anyLong(), anyInt());
+                .getProcessStateTime(eq(PROCESS_STATE_FOREGROUND_SERVICE), anyLong(), anyInt());
-        doReturn(TIME_STATE_FOREGROUND).when(mUid).getProcessStateTime(eq(PROCESS_STATE_FOREGROUND),
+        doReturn(TIME_STATE_TOP_SLEEPING)
-                anyLong(), anyInt());
+                .when(mUid)
-        doReturn(TIME_STATE_BACKGROUND).when(mUid).getProcessStateTime(eq(PROCESS_STATE_BACKGROUND),
+                .getProcessStateTime(eq(PROCESS_STATE_TOP_SLEEPING), anyLong(), anyInt());
-                anyLong(), anyInt());
+        doReturn(TIME_STATE_FOREGROUND)
+                .when(mUid)
+                .getProcessStateTime(eq(PROCESS_STATE_FOREGROUND), anyLong(), anyInt());
+        doReturn(TIME_STATE_BACKGROUND)
+                .when(mUid)
+                .getProcessStateTime(eq(PROCESS_STATE_BACKGROUND), anyLong(), anyInt());
 
         when(mPackageManager.getApplicationInfo(eq(HIGH_SDK_PACKAGE), anyInt()))
                 .thenReturn(mHighApplicationInfo);
@@ -166,12 +161,14 @@ public class BatteryUtilsTest {
         mContext = spy(RuntimeEnvironment.application);
         doReturn(mPackageManager).when(mContext).getPackageManager();
         doReturn(mAppOpsManager).when(mContext).getSystemService(Context.APP_OPS_SERVICE);
-        doReturn(mBatteryStatsManager).when(mContext)
+        doReturn(mBatteryStatsManager)
+                .when(mContext)
                 .getSystemService(Context.BATTERY_STATS_SERVICE);
         mBatteryUtils = spy(new BatteryUtils(mContext));
         mBatteryUtils.mPowerUsageFeatureProvider = mProvider;
-        doReturn(0L).when(mBatteryUtils)
+        doReturn(0L)
-            .getForegroundServiceTotalTimeUs(any(BatteryStats.Uid.class), anyLong());
+                .when(mBatteryUtils)
+                .getForegroundServiceTotalTimeUs(any(BatteryStats.Uid.class), anyLong());
         mAnomalyInfo = new AnomalyInfo(INFO_WAKELOCK);
 
         BatteryDatabaseManager.setUpForTest(mBatteryDatabaseManager);
@@ -180,54 +177,62 @@ public class BatteryUtilsTest {
 
     @Test
     public void testGetProcessTimeMs_typeForeground_timeCorrect() {
-        doReturn(TIME_STATE_FOREGROUND + 500).when(mBatteryUtils)
+        doReturn(TIME_STATE_FOREGROUND + 500)
-            .getForegroundActivityTotalTimeUs(eq(mUid), anyLong());
+                .when(mBatteryUtils)
+                .getForegroundActivityTotalTimeUs(eq(mUid), anyLong());
 
-        final long time = mBatteryUtils.getProcessTimeMs(BatteryUtils.StatusType.FOREGROUND, mUid,
+        final long time =
-                BatteryStats.STATS_SINCE_CHARGED);
+                mBatteryUtils.getProcessTimeMs(
+                        BatteryUtils.StatusType.FOREGROUND, mUid, BatteryStats.STATS_SINCE_CHARGED);
 
         assertThat(time).isEqualTo(TIME_EXPECTED_FOREGROUND);
     }
 
     @Test
     public void testGetProcessTimeMs_typeBackground_timeCorrect() {
-        final long time = mBatteryUtils.getProcessTimeMs(BatteryUtils.StatusType.BACKGROUND, mUid,
+        final long time =
-                BatteryStats.STATS_SINCE_CHARGED);
+                mBatteryUtils.getProcessTimeMs(
+                        BatteryUtils.StatusType.BACKGROUND, mUid, BatteryStats.STATS_SINCE_CHARGED);
 
         assertThat(time).isEqualTo(TIME_EXPECTED_BACKGROUND);
     }
 
     @Test
     public void testGetProcessTimeMs_typeAll_timeCorrect() {
-        doReturn(TIME_STATE_FOREGROUND + 500).when(mBatteryUtils)
+        doReturn(TIME_STATE_FOREGROUND + 500)
-            .getForegroundActivityTotalTimeUs(eq(mUid), anyLong());
+                .when(mBatteryUtils)
+                .getForegroundActivityTotalTimeUs(eq(mUid), anyLong());
 
-        final long time = mBatteryUtils.getProcessTimeMs(BatteryUtils.StatusType.ALL, mUid,
+        final long time =
-                BatteryStats.STATS_SINCE_CHARGED);
+                mBatteryUtils.getProcessTimeMs(
+                        BatteryUtils.StatusType.ALL, mUid, BatteryStats.STATS_SINCE_CHARGED);
 
         assertThat(time).isEqualTo(TIME_EXPECTED_ALL);
     }
 
     @Test
     public void testGetProcessTimeMs_uidNull_returnZero() {
-        final long time = mBatteryUtils.getProcessTimeMs(BatteryUtils.StatusType.ALL, null,
+        final long time =
-                BatteryStats.STATS_SINCE_CHARGED);
+                mBatteryUtils.getProcessTimeMs(
+                        BatteryUtils.StatusType.ALL, null, BatteryStats.STATS_SINCE_CHARGED);
 
         assertThat(time).isEqualTo(0);
     }
 
     @Test
     public void testCalculateBatteryPercent() {
-        assertThat(mBatteryUtils.calculateBatteryPercent(BATTERY_SYSTEM_USAGE, TOTAL_BATTERY_USAGE,
+        assertThat(
-                DISCHARGE_AMOUNT))
+                        mBatteryUtils.calculateBatteryPercent(
-                .isWithin(PRECISION).of(PERCENT_SYSTEM_USAGE);
+                                BATTERY_SYSTEM_USAGE, TOTAL_BATTERY_USAGE, DISCHARGE_AMOUNT))
+                .isWithin(PRECISION)
+                .of(PERCENT_SYSTEM_USAGE);
     }
 
     @Test
     public void testCalculateLastFullChargeTime() {
         final long currentTimeMs = System.currentTimeMillis();
-        when(mBatteryUsageStats.getStatsStartTimestamp()).thenReturn(
+        when(mBatteryUsageStats.getStatsStartTimestamp())
-                currentTimeMs - TIME_SINCE_LAST_FULL_CHARGE_MS);
+                .thenReturn(currentTimeMs - TIME_SINCE_LAST_FULL_CHARGE_MS);
 
         assertThat(mBatteryUtils.calculateLastFullChargeTime(mBatteryUsageStats, currentTimeMs))
                 .isEqualTo(TIME_SINCE_LAST_FULL_CHARGE_MS);
@@ -237,49 +242,54 @@ public class BatteryUtilsTest {
     public void testGetForegroundActivityTotalTimeMs_returnMilliseconds() {
         final long rawRealtimeUs = SystemClock.elapsedRealtime() * 1000;
         doReturn(mTimer).when(mUid).getForegroundActivityTimer();
-        doReturn(TIME_SINCE_LAST_FULL_CHARGE_US).when(mTimer)
+        doReturn(TIME_SINCE_LAST_FULL_CHARGE_US)
+                .when(mTimer)
                 .getTotalTimeLocked(rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED);
 
-        assertThat(mBatteryUtils.getForegroundActivityTotalTimeUs(mUid, rawRealtimeUs)).isEqualTo(
+        assertThat(mBatteryUtils.getForegroundActivityTotalTimeUs(mUid, rawRealtimeUs))
-                TIME_SINCE_LAST_FULL_CHARGE_US);
+                .isEqualTo(TIME_SINCE_LAST_FULL_CHARGE_US);
     }
 
     @Test
-    public void testGetTargetSdkVersion_packageExist_returnSdk() throws
+    public void testGetTargetSdkVersion_packageExist_returnSdk()
-            PackageManager.NameNotFoundException {
+            throws PackageManager.NameNotFoundException {
-        doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfo(PACKAGE_NAME,
+        doReturn(mApplicationInfo)
-                PackageManager.GET_META_DATA);
+                .when(mPackageManager)
+                .getApplicationInfo(PACKAGE_NAME, PackageManager.GET_META_DATA);
         mApplicationInfo.targetSdkVersion = SDK_VERSION;
 
         assertThat(mBatteryUtils.getTargetSdkVersion(PACKAGE_NAME)).isEqualTo(SDK_VERSION);
     }
 
     @Test
-    public void testGetTargetSdkVersion_packageNotExist_returnSdkNull() throws
+    public void testGetTargetSdkVersion_packageNotExist_returnSdkNull()
-            PackageManager.NameNotFoundException {
+            throws PackageManager.NameNotFoundException {
-        doThrow(new PackageManager.NameNotFoundException()).when(
+        doThrow(new PackageManager.NameNotFoundException())
-                mPackageManager).getApplicationInfo(PACKAGE_NAME, PackageManager.GET_META_DATA);
+                .when(mPackageManager)
+                .getApplicationInfo(PACKAGE_NAME, PackageManager.GET_META_DATA);
 
-        assertThat(mBatteryUtils.getTargetSdkVersion(PACKAGE_NAME)).isEqualTo(
+        assertThat(mBatteryUtils.getTargetSdkVersion(PACKAGE_NAME))
-                BatteryUtils.SDK_NULL);
+                .isEqualTo(BatteryUtils.SDK_NULL);
     }
 
     @Test
     public void testBackgroundRestrictionOn_restrictionOn_returnTrue() {
-        doReturn(AppOpsManager.MODE_IGNORED).when(mAppOpsManager).checkOpNoThrow(
+        doReturn(AppOpsManager.MODE_IGNORED)
-                AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
+                .when(mAppOpsManager)
+                .checkOpNoThrow(AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
 
-        assertThat(mBatteryUtils.isBackgroundRestrictionEnabled(SDK_VERSION, UID,
+        assertThat(mBatteryUtils.isBackgroundRestrictionEnabled(SDK_VERSION, UID, PACKAGE_NAME))
-                PACKAGE_NAME)).isTrue();
+                .isTrue();
     }
 
     @Test
     public void testBackgroundRestrictionOn_restrictionOff_returnFalse() {
-        doReturn(AppOpsManager.MODE_ALLOWED).when(mAppOpsManager).checkOpNoThrow(
+        doReturn(AppOpsManager.MODE_ALLOWED)
-                AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
+                .when(mAppOpsManager)
+                .checkOpNoThrow(AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
 
         assertThat(mBatteryUtils.isBackgroundRestrictionEnabled(SDK_VERSION, UID, PACKAGE_NAME))
-            .isFalse();
+                .isFalse();
     }
 
     @Test
@@ -294,13 +304,13 @@ public class BatteryUtilsTest {
 
     @Test
     public void testIsPreOApp_containPreOApp_ReturnTrue() {
-        assertThat(
+        assertThat(mBatteryUtils.isPreOApp(new String[] {HIGH_SDK_PACKAGE, LOW_SDK_PACKAGE}))
-                mBatteryUtils.isPreOApp(new String[]{HIGH_SDK_PACKAGE, LOW_SDK_PACKAGE})).isTrue();
+                .isTrue();
     }
 
     @Test
     public void testIsPreOApp_emptyList_ReturnFalse() {
-        assertThat(mBatteryUtils.isPreOApp(new String[]{})).isFalse();
+        assertThat(mBatteryUtils.isPreOApp(new String[] {})).isFalse();
     }
 
     @Ignore
@@ -309,10 +319,18 @@ public class BatteryUtilsTest {
         mBatteryUtils.setForceAppStandby(UID, LOW_SDK_PACKAGE, AppOpsManager.MODE_IGNORED);
 
         // Restrict both OP_RUN_IN_BACKGROUND and OP_RUN_ANY_IN_BACKGROUND
-        verify(mAppOpsManager).setMode(AppOpsManager.OP_RUN_IN_BACKGROUND, UID, LOW_SDK_PACKAGE,
+        verify(mAppOpsManager)
-                AppOpsManager.MODE_IGNORED);
+                .setMode(
-        verify(mAppOpsManager).setMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID, LOW_SDK_PACKAGE,
+                        AppOpsManager.OP_RUN_IN_BACKGROUND,
-                AppOpsManager.MODE_IGNORED);
+                        UID,
+                        LOW_SDK_PACKAGE,
+                        AppOpsManager.MODE_IGNORED);
+        verify(mAppOpsManager)
+                .setMode(
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
+                        UID,
+                        LOW_SDK_PACKAGE,
+                        AppOpsManager.MODE_IGNORED);
     }
 
     @Ignore
@@ -321,42 +339,53 @@ public class BatteryUtilsTest {
         mBatteryUtils.setForceAppStandby(UID, HIGH_SDK_PACKAGE, AppOpsManager.MODE_IGNORED);
 
         // Don't restrict OP_RUN_IN_BACKGROUND because it is already been restricted for O app
-        verify(mAppOpsManager, never()).setMode(AppOpsManager.OP_RUN_IN_BACKGROUND, UID,
+        verify(mAppOpsManager, never())
-                HIGH_SDK_PACKAGE, AppOpsManager.MODE_IGNORED);
+                .setMode(
+                        AppOpsManager.OP_RUN_IN_BACKGROUND,
+                        UID,
+                        HIGH_SDK_PACKAGE,
+                        AppOpsManager.MODE_IGNORED);
         // Restrict OP_RUN_ANY_IN_BACKGROUND
-        verify(mAppOpsManager).setMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        verify(mAppOpsManager)
-                HIGH_SDK_PACKAGE, AppOpsManager.MODE_IGNORED);
+                .setMode(
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
+                        UID,
+                        HIGH_SDK_PACKAGE,
+                        AppOpsManager.MODE_IGNORED);
     }
 
     @Test
     public void testSetForceAppStandby_restrictApp_recordTime() {
         mBatteryUtils.setForceAppStandby(UID, HIGH_SDK_PACKAGE, AppOpsManager.MODE_IGNORED);
 
-        verify(mBatteryDatabaseManager).insertAction(
+        verify(mBatteryDatabaseManager)
-                eq(AnomalyDatabaseHelper.ActionType.RESTRICTION), eq(UID),
+                .insertAction(
-                eq(HIGH_SDK_PACKAGE), anyLong());
+                        eq(AnomalyDatabaseHelper.ActionType.RESTRICTION), eq(UID),
+                        eq(HIGH_SDK_PACKAGE), anyLong());
     }
 
     @Test
     public void testSetForceAppStandby_unrestrictApp_deleteTime() {
         mBatteryUtils.setForceAppStandby(UID, HIGH_SDK_PACKAGE, AppOpsManager.MODE_ALLOWED);
 
-        verify(mBatteryDatabaseManager).deleteAction(AnomalyDatabaseHelper.ActionType.RESTRICTION,
+        verify(mBatteryDatabaseManager)
-                UID, HIGH_SDK_PACKAGE);
+                .deleteAction(AnomalyDatabaseHelper.ActionType.RESTRICTION, UID, HIGH_SDK_PACKAGE);
     }
 
     @Test
     public void testIsForceAppStandbyEnabled_enabled_returnTrue() {
-        when(mAppOpsManager.checkOpNoThrow(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        when(mAppOpsManager.checkOpNoThrow(
-                PACKAGE_NAME)).thenReturn(AppOpsManager.MODE_IGNORED);
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID, PACKAGE_NAME))
+                .thenReturn(AppOpsManager.MODE_IGNORED);
 
         assertThat(mBatteryUtils.isForceAppStandbyEnabled(UID, PACKAGE_NAME)).isTrue();
     }
 
     @Test
     public void testIsForceAppStandbyEnabled_disabled_returnFalse() {
-        when(mAppOpsManager.checkOpNoThrow(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        when(mAppOpsManager.checkOpNoThrow(
-                PACKAGE_NAME)).thenReturn(AppOpsManager.MODE_ALLOWED);
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID, PACKAGE_NAME))
+                .thenReturn(AppOpsManager.MODE_ALLOWED);
 
         assertThat(mBatteryUtils.isForceAppStandbyEnabled(UID, PACKAGE_NAME)).isFalse();
     }
@@ -369,77 +398,85 @@ public class BatteryUtilsTest {
         resolveInfo.activityInfo.packageName = HIGH_SDK_PACKAGE;
 
         doReturn(resolveInfos).when(mPackageManager).queryIntentActivities(any(), anyInt());
-        doReturn(new String[]{HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
+        doReturn(new String[] {HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
         mHighApplicationInfo.flags = ApplicationInfo.FLAG_SYSTEM;
 
-        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID,
+        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID, mAnomalyInfo))
-                mAnomalyInfo)).isTrue();
+                .isTrue();
     }
 
     @Test
     public void testShouldHideAnomaly_systemAppWithoutLauncher_returnTrue() {
         doReturn(new ArrayList<>()).when(mPackageManager).queryIntentActivities(any(), anyInt());
-        doReturn(new String[]{HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
+        doReturn(new String[] {HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
         mHighApplicationInfo.flags = ApplicationInfo.FLAG_SYSTEM;
 
-        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID,
+        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID, mAnomalyInfo))
-                mAnomalyInfo)).isTrue();
+                .isTrue();
     }
 
     @Test
     public void testShouldHideAnomaly_systemUid_returnTrue() {
         final int systemUid = Process.ROOT_UID;
-        doReturn(new String[]{HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(systemUid);
+        doReturn(new String[] {HIGH_SDK_PACKAGE})
+                .when(mPackageManager)
+                .getPackagesForUid(systemUid);
 
-        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, systemUid,
+        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, systemUid, mAnomalyInfo))
-                mAnomalyInfo)).isTrue();
+                .isTrue();
     }
 
     @Test
     public void testShouldHideAnomaly_AppInDozeList_returnTrue() {
-        doReturn(new String[]{HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
+        doReturn(new String[] {HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
-        doReturn(true).when(mPowerAllowlistBackend)
+        doReturn(true)
-                .isAllowlisted(new String[]{HIGH_SDK_PACKAGE}, UID);
+                .when(mPowerAllowlistBackend)
+                .isAllowlisted(new String[] {HIGH_SDK_PACKAGE}, UID);
 
-        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID,
+        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID, mAnomalyInfo))
-                mAnomalyInfo)).isTrue();
+                .isTrue();
     }
 
     @Test
     public void testShouldHideAnomaly_normalApp_returnFalse() {
-        doReturn(new String[]{HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
+        doReturn(new String[] {HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
 
-        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID,
+        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID, mAnomalyInfo))
-                mAnomalyInfo)).isFalse();
+                .isFalse();
     }
 
     @Test
     public void testShouldHideAnomaly_excessivePriorOApp_returnFalse() {
-        doReturn(new String[]{LOW_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
+        doReturn(new String[] {LOW_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
         mAnomalyInfo = new AnomalyInfo(INFO_EXCESSIVE);
 
-        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID,
+        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID, mAnomalyInfo))
-                mAnomalyInfo)).isFalse();
+                .isFalse();
     }
 
     @Test
     public void testShouldHideAnomaly_excessiveOApp_returnTrue() {
-        doReturn(new String[]{HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
+        doReturn(new String[] {HIGH_SDK_PACKAGE}).when(mPackageManager).getPackagesForUid(UID);
         mAnomalyInfo = new AnomalyInfo(INFO_EXCESSIVE);
 
-        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID,
+        assertThat(mBatteryUtils.shouldHideAnomaly(mPowerAllowlistBackend, UID, mAnomalyInfo))
-                mAnomalyInfo)).isTrue();
+                .isTrue();
     }
 
     @Test
     public void clearForceAppStandby_appRestricted_clearAndReturnTrue() {
         when(mBatteryUtils.getPackageUid(HIGH_SDK_PACKAGE)).thenReturn(UID);
-        when(mAppOpsManager.checkOpNoThrow(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        when(mAppOpsManager.checkOpNoThrow(
-                HIGH_SDK_PACKAGE)).thenReturn(AppOpsManager.MODE_IGNORED);
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID, HIGH_SDK_PACKAGE))
+                .thenReturn(AppOpsManager.MODE_IGNORED);
 
         assertThat(mBatteryUtils.clearForceAppStandby(HIGH_SDK_PACKAGE)).isTrue();
-        verify(mAppOpsManager).setMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        verify(mAppOpsManager)
-                HIGH_SDK_PACKAGE, AppOpsManager.MODE_ALLOWED);
+                .setMode(
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
+                        UID,
+                        HIGH_SDK_PACKAGE,
+                        AppOpsManager.MODE_ALLOWED);
     }
 
     @Test
@@ -447,29 +484,38 @@ public class BatteryUtilsTest {
         when(mBatteryUtils.getPackageUid(PACKAGE_NAME)).thenReturn(BatteryUtils.UID_NULL);
 
         assertThat(mBatteryUtils.clearForceAppStandby(PACKAGE_NAME)).isFalse();
-        verify(mAppOpsManager, never()).setMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        verify(mAppOpsManager, never())
-                PACKAGE_NAME, AppOpsManager.MODE_ALLOWED);
+                .setMode(
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
+                        UID,
+                        PACKAGE_NAME,
+                        AppOpsManager.MODE_ALLOWED);
     }
 
     @Test
     public void clearForceAppStandby_appUnrestricted_returnFalse() {
         when(mBatteryUtils.getPackageUid(PACKAGE_NAME)).thenReturn(UID);
-        when(mAppOpsManager.checkOpNoThrow(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        when(mAppOpsManager.checkOpNoThrow(
-                PACKAGE_NAME)).thenReturn(AppOpsManager.MODE_ALLOWED);
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID, PACKAGE_NAME))
+                .thenReturn(AppOpsManager.MODE_ALLOWED);
 
         assertThat(mBatteryUtils.clearForceAppStandby(PACKAGE_NAME)).isFalse();
-        verify(mAppOpsManager, never()).setMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UID,
+        verify(mAppOpsManager, never())
-                PACKAGE_NAME, AppOpsManager.MODE_ALLOWED);
+                .setMode(
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
+                        UID,
+                        PACKAGE_NAME,
+                        AppOpsManager.MODE_ALLOWED);
     }
 
     @Test
     public void getBatteryInfo_providerNull_shouldNotCrash() {
         when(mProvider.isEnhancedBatteryPredictionEnabled(mContext)).thenReturn(true);
         when(mProvider.getEnhancedBatteryPrediction(mContext)).thenReturn(null);
-        when(mContext.registerReceiver(nullable(BroadcastReceiver.class),
+        when(mContext.registerReceiver(nullable(BroadcastReceiver.class), any(IntentFilter.class)))
-                any(IntentFilter.class))).thenReturn(new Intent());
+                .thenReturn(new Intent());
 
-        //Should not crash
+        // Should not crash
         assertThat(mBatteryUtils.getBatteryInfo(TAG)).isNotNull();
     }
 

tests/robotests/src/com/android/settings/fuelgauge/HighPowerDetailTest.java

@@ -51,10 +51,8 @@ public class HighPowerDetailTest {
     private HighPowerDetail mFragment;
 
     private Context mContext;
-    @Mock
+    @Mock private PowerAllowlistBackend mPowerAllowlistBackend;
-    private PowerAllowlistBackend mPowerAllowlistBackend;
+    @Mock private BatteryUtils mBatteryUtils;
-    @Mock
-    private BatteryUtils mBatteryUtils;
 
     @Before
     public void setUp() {
@@ -73,13 +71,19 @@ public class HighPowerDetailTest {
     public void logSpecialPermissionChange() {
         // Deny means app is allowlisted to opt out of power save restrictions
         HighPowerDetail.logSpecialPermissionChange(true, "app", RuntimeEnvironment.application);
-        verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+        verify(mFeatureFactory.metricsFeatureProvider)
-                eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_DENY), eq("app"));
+                .action(
+                        any(Context.class),
+                        eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_DENY),
+                        eq("app"));
 
         // Allow means app is NOT allowlisted to opt out of power save restrictions
         HighPowerDetail.logSpecialPermissionChange(false, "app", RuntimeEnvironment.application);
-        verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+        verify(mFeatureFactory.metricsFeatureProvider)
-                eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_ALLOW), eq("app"));
+                .action(
+                        any(Context.class),
+                        eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_ALLOW),
+                        eq("app"));
     }
 
     @Test
@@ -87,15 +91,17 @@ public class HighPowerDetailTest {
         mFragment.mIsEnabled = true;
         when(mPowerAllowlistBackend.isAllowlisted(TEST_PACKAGE, TEST_UID)).thenReturn(false);
         mFragment.onClick(null, DialogInterface.BUTTON_POSITIVE);
-        verify(mBatteryUtils).setForceAppStandby(TEST_UID, TEST_PACKAGE,
+        verify(mBatteryUtils)
-                AppOpsManager.MODE_ALLOWED);
+                .setForceAppStandby(TEST_UID, TEST_PACKAGE, AppOpsManager.MODE_ALLOWED);
     }
 
     @Test
     public void getSummary_defaultActivePackage_returnUnavailable() {
         doReturn(true).when(mPowerAllowlistBackend).isDefaultActiveApp(TEST_PACKAGE, TEST_UID);
 
-        assertThat(HighPowerDetail.getSummary(mContext, mPowerAllowlistBackend, TEST_PACKAGE,
+        assertThat(
-                TEST_UID)).isEqualTo(mContext.getString(R.string.high_power_system));
+                        HighPowerDetail.getSummary(
+                                mContext, mPowerAllowlistBackend, TEST_PACKAGE, TEST_UID))
+                .isEqualTo(mContext.getString(R.string.high_power_system));
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/OptimizedPreferenceControllerTest.java

@@ -76,8 +76,8 @@ public class OptimizedPreferenceControllerTest {
     public void testUpdateState_isSystemOrDefaultAppAndOptimizeStates_prefChecked() {
         when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
         when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_OPTIMIZED);
+                .thenReturn(BatteryOptimizeUtils.MODE_OPTIMIZED);
 
         mController.updateState(mPreference);
 
@@ -98,8 +98,8 @@ public class OptimizedPreferenceControllerTest {
     @Test
     public void testUpdateState_isOptimizedStates_prefChecked() {
         when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_OPTIMIZED);
+                .thenReturn(BatteryOptimizeUtils.MODE_OPTIMIZED);
 
         mController.updateState(mPreference);
 

tests/robotests/src/com/android/settings/fuelgauge/PowerBackgroundUsageDetailTest.java

@@ -72,11 +72,12 @@ import org.robolectric.annotation.Config;
 import org.robolectric.util.ReflectionHelpers;
 
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {
+@Config(
-        ShadowEntityHeaderController.class,
+        shadows = {
-        ShadowActivityManager.class,
+            ShadowEntityHeaderController.class,
-        com.android.settings.testutils.shadow.ShadowFragment.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";
@@ -96,30 +97,19 @@ public class PowerBackgroundUsageDetailTest {
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private FragmentActivity mActivity;
-    @Mock
+
-    private EntityHeaderController mEntityHeaderController;
+    @Mock private EntityHeaderController mEntityHeaderController;
-    @Mock
+    @Mock private BatteryOptimizeUtils mBatteryOptimizeUtils;
-    private BatteryOptimizeUtils mBatteryOptimizeUtils;
+    @Mock private LayoutPreference mHeaderPreference;
-    @Mock
+    @Mock private ApplicationsState mState;
-    private LayoutPreference mHeaderPreference;
+    @Mock private Bundle mBundle;
-    @Mock
+    @Mock private LoaderManager mLoaderManager;
-    private ApplicationsState mState;
+    @Mock private ApplicationsState.AppEntry mAppEntry;
-    @Mock
+    @Mock private BatteryEntry mBatteryEntry;
-    private Bundle mBundle;
+    @Mock private BackupManager mBackupManager;
-    @Mock
+    @Mock private PackageManager mPackageManager;
-    private LoaderManager mLoaderManager;
+    @Mock private AppOpsManager mAppOpsManager;
-    @Mock
+    @Mock private Switch mMockSwitch;
-    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() {
@@ -137,19 +127,26 @@ public class PowerBackgroundUsageDetailTest {
         doReturn(mLoaderManager).when(mFragment).getLoaderManager();
 
         ShadowEntityHeaderController.setUseMock(mEntityHeaderController);
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setButtonActions(anyInt(), anyInt());
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setIcon(nullable(Drawable.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController).setIcon(nullable(
+        doReturn(mEntityHeaderController)
-                ApplicationsState.AppEntry.class));
+                .when(mEntityHeaderController)
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+                .setIcon(nullable(ApplicationsState.AppEntry.class));
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setLabel(nullable(String.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setLabel(nullable(String.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setLabel(nullable(ApplicationsState.AppEntry.class));
-        doReturn(mEntityHeaderController).when(mEntityHeaderController)
+        doReturn(mEntityHeaderController)
+                .when(mEntityHeaderController)
                 .setSummary(nullable(String.class));
 
         when(mBatteryEntry.getUid()).thenReturn(UID);
@@ -169,13 +166,15 @@ public class PowerBackgroundUsageDetailTest {
 
         final ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
 
-        Answer<Void> callable = invocation -> {
+        Answer<Void> callable =
-            mBundle = captor.getValue().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
+                invocation -> {
-            System.out.println("mBundle = " + mBundle);
+                    mBundle = captor.getValue().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
-            return null;
+                    System.out.println("mBundle = " + mBundle);
-        };
+                    return null;
-        doAnswer(callable).when(mActivity).startActivityAsUser(captor.capture(),
+                };
-                nullable(UserHandle.class));
+        doAnswer(callable)
+                .when(mActivity)
+                .startActivityAsUser(captor.capture(), nullable(UserHandle.class));
         doAnswer(callable).when(mActivity).startActivity(captor.capture());
 
         mFooterPreference = spy(new FooterPreference(mContext));
@@ -207,7 +206,9 @@ public class PowerBackgroundUsageDetailTest {
 
     @Test
     public void initHeader_HasAppEntry_BuildByAppEntry() {
-        ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
+        ReflectionHelpers.setStaticField(
+                AppUtils.class,
+                "sInstantAppDataProvider",
                 new InstantAppDataProvider() {
                     @Override
                     public boolean isInstantApp(ApplicationInfo info) {
@@ -224,7 +225,9 @@ public class PowerBackgroundUsageDetailTest {
 
     @Test
     public void initHeader_HasAppEntry_InstantApp() {
-        ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
+        ReflectionHelpers.setStaticField(
+                AppUtils.class,
+                "sInstantAppDataProvider",
                 new InstantAppDataProvider() {
                     @Override
                     public boolean isInstantApp(ApplicationInfo info) {
@@ -256,7 +259,7 @@ public class PowerBackgroundUsageDetailTest {
         final int optimizedMode = BatteryOptimizeUtils.MODE_OPTIMIZED;
         mFragment.mOptimizationMode = optimizedMode;
 
-        mFragment.onSwitchChanged(mMockSwitch, /*isChecked=*/ false);
+        mFragment.onSwitchChanged(mMockSwitch, /* isChecked= */ false);
 
         verify(mOptimizePreference).setEnabled(false);
         verify(mUnrestrictedPreference).setEnabled(false);
@@ -272,7 +275,7 @@ public class PowerBackgroundUsageDetailTest {
         final int optimizedMode = BatteryOptimizeUtils.MODE_OPTIMIZED;
         mFragment.mOptimizationMode = restrictedMode;
 
-        mFragment.onSwitchChanged(mMockSwitch, /*isChecked=*/ true);
+        mFragment.onSwitchChanged(mMockSwitch, /* isChecked= */ true);
 
         verify(mOptimizePreference).setEnabled(true);
         verify(mUnrestrictedPreference).setEnabled(true);

tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java

@@ -46,8 +46,8 @@ public class PowerUsageFeatureProviderImplTest {
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
-    @Mock
+
-    private PackageManager mPackageManager;
+    @Mock private PackageManager mPackageManager;
     private PowerUsageFeatureProviderImpl mPowerFeatureProvider;
 
     @Before
@@ -117,16 +117,18 @@ public class PowerUsageFeatureProviderImplTest {
 
     @Test
     public void testIsSmartBatterySupported_smartBatterySupported_returnTrue() {
-        when(mContext.getResources().getBoolean(
+        when(mContext.getResources()
-                com.android.internal.R.bool.config_smart_battery_available)).thenReturn(true);
+                        .getBoolean(com.android.internal.R.bool.config_smart_battery_available))
+                .thenReturn(true);
 
         assertThat(mPowerFeatureProvider.isSmartBatterySupported()).isTrue();
     }
 
     @Test
     public void testIsSmartBatterySupported_smartBatteryNotSupported_returnFalse() {
-        when(mContext.getResources().getBoolean(
+        when(mContext.getResources()
-                com.android.internal.R.bool.config_smart_battery_available)).thenReturn(false);
+                        .getBoolean(com.android.internal.R.bool.config_smart_battery_available))
+                .thenReturn(false);
 
         assertThat(mPowerFeatureProvider.isSmartBatterySupported()).isFalse();
     }

tests/robotests/src/com/android/settings/fuelgauge/PowerUsageTimeControllerTest.java

@@ -46,12 +46,9 @@ public final class PowerUsageTimeControllerTest {
     private Context mContext;
     private PowerUsageTimeController mPowerUsageTimeController;
 
-    @Mock
+    @Mock private PreferenceCategory mPowerUsageTimeCategory;
-    private PreferenceCategory mPowerUsageTimeCategory;
+    @Mock private PowerUsageTimePreference mScreenTimePreference;
-    @Mock
+    @Mock private PowerUsageTimePreference mBackgroundTimePreference;
-    private PowerUsageTimePreference mScreenTimePreference;
-    @Mock
-    private PowerUsageTimePreference mBackgroundTimePreference;
 
     @Before
     public void setUp() {
@@ -67,18 +64,24 @@ public final class PowerUsageTimeControllerTest {
 
     @Test
     public void handleScreenTimeUpdated_noInfo_prefInvisible() {
-        mPowerUsageTimeController.handleScreenTimeUpdated(/*slotTime=*/ null,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                /*screenOnTimeInMs=*/ 0, /*backgroundTimeInMs=*/ 0,
+                /* slotTime= */ null,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                /* screenOnTimeInMs= */ 0,
+                /* backgroundTimeInMs= */ 0,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyAllPreferencesVisible(false);
     }
 
     @Test
     public void handleScreenTimeUpdated_onlySlotTime_prefInvisible() {
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                /*screenOnTimeInMs=*/ 0, /*backgroundTimeInMs=*/ 0,
+                SLOT_TIME,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                /* screenOnTimeInMs= */ 0,
+                /* backgroundTimeInMs= */ 0,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyAllPreferencesVisible(false);
     }
@@ -88,9 +91,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeAMinute = 60000;
         final long backgroundTimeZero = 0;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeAMinute, backgroundTimeZero,
+                SLOT_TIME,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                screenOnTimeAMinute,
+                backgroundTimeZero,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyOnePreferenceInvisible(mBackgroundTimePreference);
         verify(mScreenTimePreference).setTimeTitle("Screen time");
@@ -103,9 +109,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeZero = 0;
         final long backgroundTimeTwoMinutes = 120000;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeZero, backgroundTimeTwoMinutes,
+                SLOT_TIME,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                screenOnTimeZero,
+                backgroundTimeTwoMinutes,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyOnePreferenceInvisible(mScreenTimePreference);
         verify(mBackgroundTimePreference).setTimeTitle("Background time");
@@ -118,9 +127,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeAMinute = 60000;
         final long backgroundTimeTwoMinutes = 120000;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeAMinute, backgroundTimeTwoMinutes,
+                SLOT_TIME,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                screenOnTimeAMinute,
+                backgroundTimeTwoMinutes,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyAllPreferencesVisible(true);
         verify(mScreenTimePreference).setTimeTitle("Screen time");
@@ -137,9 +149,12 @@ public final class PowerUsageTimeControllerTest {
         final long backgroundTimeTwoMinutes = 120000;
         final long screenOnTimeAMinute = 60000;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(/*slotTime=*/ null,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeAMinute, backgroundTimeTwoMinutes,
+                /* slotTime= */ null,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                screenOnTimeAMinute,
+                backgroundTimeTwoMinutes,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyAllPreferencesVisible(true);
         verify(mPowerUsageTimeCategory).setTitle("App usage since last full charge");
@@ -150,9 +165,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeAMinute = 60000;
         final long backgroundTimeLessThanAMinute = 59999;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeAMinute, backgroundTimeLessThanAMinute,
+                SLOT_TIME,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                screenOnTimeAMinute,
+                backgroundTimeLessThanAMinute,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyAllPreferencesVisible(true);
         verify(mScreenTimePreference).setTimeSummary("1 min");
@@ -164,9 +182,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeLessThanAMinute = 59999;
         final long backgroundTimeTwoMinutes = 120000;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeLessThanAMinute, backgroundTimeTwoMinutes,
+                SLOT_TIME,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                screenOnTimeLessThanAMinute,
+                backgroundTimeTwoMinutes,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyAllPreferencesVisible(true);
         verify(mScreenTimePreference).setTimeSummary("Less than a min");
@@ -178,9 +199,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeLessThanAMinute = 59999;
         final long backgroundTimeLessThanAMinute = 59999;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeLessThanAMinute, backgroundTimeLessThanAMinute,
+                SLOT_TIME,
-                /*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
+                screenOnTimeLessThanAMinute,
+                backgroundTimeLessThanAMinute,
+                /* anomalyHintPrefKey= */ null,
+                /* anomalyHintText= */ null);
 
         verifyAllPreferencesVisible(true);
         verify(mScreenTimePreference).setTimeSummary("Less than a min");
@@ -192,9 +216,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeAMinute = 60000;
         final long backgroundTimeTwoMinutes = 120000;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeAMinute, backgroundTimeTwoMinutes,
+                SLOT_TIME,
-                KEY_SCREEN_ON_TIME_PREF, TEST_ANOMALY_HINT_TEXT);
+                screenOnTimeAMinute,
+                backgroundTimeTwoMinutes,
+                KEY_SCREEN_ON_TIME_PREF,
+                TEST_ANOMALY_HINT_TEXT);
 
         verifyAllPreferencesVisible(true);
         verify(mScreenTimePreference).setAnomalyHint(TEST_ANOMALY_HINT_TEXT);
@@ -206,9 +233,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeAMinute = 60000;
         final long backgroundTimeTwoMinutes = 120000;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeAMinute, backgroundTimeTwoMinutes,
+                SLOT_TIME,
-                KEY_BACKGROUND_TIME_PREF, TEST_ANOMALY_HINT_TEXT);
+                screenOnTimeAMinute,
+                backgroundTimeTwoMinutes,
+                KEY_BACKGROUND_TIME_PREF,
+                TEST_ANOMALY_HINT_TEXT);
 
         verifyAllPreferencesVisible(true);
         verify(mScreenTimePreference, never()).setAnomalyHint(anyString());
@@ -220,9 +250,12 @@ public final class PowerUsageTimeControllerTest {
         final long screenOnTimeZero = 0;
         final long backgroundTimeTwoMinutes = 120000;
 
-        mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
+        mPowerUsageTimeController.handleScreenTimeUpdated(
-                screenOnTimeZero, backgroundTimeTwoMinutes,
+                SLOT_TIME,
-                KEY_SCREEN_ON_TIME_PREF, TEST_ANOMALY_HINT_TEXT);
+                screenOnTimeZero,
+                backgroundTimeTwoMinutes,
+                KEY_SCREEN_ON_TIME_PREF,
+                TEST_ANOMALY_HINT_TEXT);
 
         verifyAllPreferencesVisible(true);
         verify(mScreenTimePreference).setTimeSummary("Less than a min");

tests/robotests/src/com/android/settings/fuelgauge/RestrictAppPreferenceControllerTest.java

@@ -33,7 +33,6 @@ import android.content.Context;
 import android.content.Intent;
 import android.os.UserHandle;
 import android.os.UserManager;
-import android.util.Pair;
 
 import androidx.preference.Preference;
 import androidx.preference.PreferenceManager;
@@ -65,12 +64,9 @@ public class RestrictAppPreferenceControllerTest {
     private static final String RESTRICTED_PACKAGE_NAME = "com.android.restricted.package";
     private static final int OTHER_USER_UID = UserHandle.PER_USER_RANGE + RESTRICTED_UID;
 
-    @Mock
+    @Mock private AppOpsManager mAppOpsManager;
-    private AppOpsManager mAppOpsManager;
+    @Mock private InstrumentedPreferenceFragment mFragment;
-    @Mock
+    @Mock private UserManager mUserManager;
-    private InstrumentedPreferenceFragment mFragment;
-    @Mock
-    private UserManager mUserManager;
 
     private AppOpsManager.PackageOps mRestrictedPackageOps;
     private AppOpsManager.PackageOps mAllowedPackageOps;
@@ -84,19 +80,25 @@ public class RestrictAppPreferenceControllerTest {
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         final List<AppOpsManager.OpEntry> allowOps = new ArrayList<>();
-        allowOps.add(new AppOpsManager.OpEntry(
+        allowOps.add(
-                AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, AppOpsManager.MODE_ALLOWED,
+                new AppOpsManager.OpEntry(
-                Collections.emptyMap()));
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
+                        AppOpsManager.MODE_ALLOWED,
+                        Collections.emptyMap()));
         final List<AppOpsManager.OpEntry> restrictedOps = new ArrayList<>();
-        restrictedOps.add(new AppOpsManager.OpEntry(
+        restrictedOps.add(
-                AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, AppOpsManager.MODE_IGNORED,
+                new AppOpsManager.OpEntry(
-                Collections.emptyMap()));
+                        AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
-        mAllowedPackageOps = new AppOpsManager.PackageOps(
+                        AppOpsManager.MODE_IGNORED,
-                ALLOWED_PACKAGE_NAME, ALLOWED_UID, allowOps);
+                        Collections.emptyMap()));
-        mRestrictedPackageOps = new AppOpsManager.PackageOps(
+        mAllowedPackageOps =
-                RESTRICTED_PACKAGE_NAME, RESTRICTED_UID, restrictedOps);
+                new AppOpsManager.PackageOps(ALLOWED_PACKAGE_NAME, ALLOWED_UID, allowOps);
-        mOtherUserPackageOps = new AppOpsManager.PackageOps(
+        mRestrictedPackageOps =
-                RESTRICTED_PACKAGE_NAME, OTHER_USER_UID, restrictedOps);
+                new AppOpsManager.PackageOps(
+                        RESTRICTED_PACKAGE_NAME, RESTRICTED_UID, restrictedOps);
+        mOtherUserPackageOps =
+                new AppOpsManager.PackageOps(
+                        RESTRICTED_PACKAGE_NAME, OTHER_USER_UID, restrictedOps);
 
         mContext = spy(ApplicationProvider.getApplicationContext());
         doReturn(mAppOpsManager).when(mContext).getSystemService(Context.APP_OPS_SERVICE);
@@ -109,8 +111,8 @@ public class RestrictAppPreferenceControllerTest {
         mPreferenceScreen = spy(new PreferenceScreen(mContext, null));
         when(mPreferenceScreen.getPreferenceManager()).thenReturn(mock(PreferenceManager.class));
         when(mPreferenceScreen.getContext()).thenReturn(mContext);
-        when(mPreferenceScreen.findPreference(
+        when(mPreferenceScreen.findPreference(RestrictAppPreferenceController.KEY_RESTRICT_APP))
-                RestrictAppPreferenceController.KEY_RESTRICT_APP)).thenReturn(mPreference);
+                .thenReturn(mPreference);
 
         final List<UserHandle> userHandles = new ArrayList<>();
         userHandles.add(new UserHandle(0));
@@ -122,8 +124,8 @@ public class RestrictAppPreferenceControllerTest {
         mPackageOpsList.add(mRestrictedPackageOps);
         doReturn(mPackageOpsList).when(mAppOpsManager).getPackagesForOps(any(int[].class));
 
-        final RestrictAppPreferenceController controller = new RestrictAppPreferenceController(
+        final RestrictAppPreferenceController controller =
-                mFragment);
+                new RestrictAppPreferenceController(mFragment);
         controller.displayPreference(mPreferenceScreen);
         controller.updateState(mPreference);
 
@@ -138,8 +140,8 @@ public class RestrictAppPreferenceControllerTest {
         mPackageOpsList.add(mOtherUserPackageOps);
         doReturn(mPackageOpsList).when(mAppOpsManager).getPackagesForOps(any(int[].class));
 
-        final RestrictAppPreferenceController controller = new RestrictAppPreferenceController(
+        final RestrictAppPreferenceController controller =
-                mFragment);
+                new RestrictAppPreferenceController(mFragment);
         controller.displayPreference(mPreferenceScreen);
         controller.updateState(mPreference);
 
@@ -154,17 +156,18 @@ public class RestrictAppPreferenceControllerTest {
         mPackageOpsList.add(mOtherUserPackageOps);
         doReturn(mPackageOpsList).when(mAppOpsManager).getPackagesForOps(any(int[].class));
 
-        final RestrictAppPreferenceController controller = new RestrictAppPreferenceController(
+        final RestrictAppPreferenceController controller =
-                mFragment);
+                new RestrictAppPreferenceController(mFragment);
         controller.displayPreference(mPreferenceScreen);
         controller.updateState(mPreference);
 
         assertThat(mPreference.getSummary()).isEqualTo("Limiting battery usage for 1 app");
-        assertThat(controller.mAppInfos).containsExactly(
+        assertThat(controller.mAppInfos)
-                new AppInfo.Builder()
+                .containsExactly(
-                        .setUid(RESTRICTED_UID)
+                        new AppInfo.Builder()
-                        .setPackageName(RESTRICTED_PACKAGE_NAME)
+                                .setUid(RESTRICTED_UID)
-                        .build());
+                                .setPackageName(RESTRICTED_PACKAGE_NAME)
+                                .build());
     }
 
     @Test
@@ -172,8 +175,8 @@ public class RestrictAppPreferenceControllerTest {
         mPackageOpsList.add(mAllowedPackageOps);
         doReturn(mPackageOpsList).when(mAppOpsManager).getPackagesForOps(any(int[].class));
 
-        final RestrictAppPreferenceController controller = new RestrictAppPreferenceController(
+        final RestrictAppPreferenceController controller =
-                mFragment);
+                new RestrictAppPreferenceController(mFragment);
         controller.displayPreference(mPreferenceScreen);
         controller.updateState(mPreference);
 
@@ -185,8 +188,8 @@ public class RestrictAppPreferenceControllerTest {
     public void handlePreferenceTreeClick_startFragment() {
         final ArgumentCaptor<Intent> intent = ArgumentCaptor.forClass(Intent.class);
 
-        final RestrictAppPreferenceController controller = new RestrictAppPreferenceController(
+        final RestrictAppPreferenceController controller =
-                mFragment);
+                new RestrictAppPreferenceController(mFragment);
         controller.handlePreferenceTreeClick(mPreference);
 
         verify(mContext).startActivity(intent.capture());

tests/robotests/src/com/android/settings/fuelgauge/RestrictedAppDetailsTest.java

@@ -72,17 +72,11 @@ public class RestrictedAppDetailsTest {
     private static final int UID = UserHandle.getUid(USER_ID, 234);
     private static final String APP_NAME = "app";
 
-
+    @Mock private PackageManager mPackageManager;
-    @Mock
+    @Mock private ApplicationInfo mApplicationInfo;
-    private PackageManager mPackageManager;
+    @Mock private IconDrawableFactory mIconDrawableFactory;
-    @Mock
+    @Mock private InstrumentedPreferenceFragment mFragment;
-    private ApplicationInfo mApplicationInfo;
+    @Mock private BatteryDatabaseManager mBatteryDatabaseManager;
-    @Mock
-    private IconDrawableFactory mIconDrawableFactory;
-    @Mock
-    private InstrumentedPreferenceFragment mFragment;
-    @Mock
-    private BatteryDatabaseManager mBatteryDatabaseManager;
     private PreferenceManager mPreferenceManager;
     private RestrictedAppDetails mRestrictedAppDetails;
     private Context mContext;
@@ -96,10 +90,7 @@ public class RestrictedAppDetailsTest {
 
         mContext = spy(RuntimeEnvironment.application);
         mRestrictedAppDetails = spy(new RestrictedAppDetails());
-        mAppInfo = new AppInfo.Builder()
+        mAppInfo = new AppInfo.Builder().setPackageName(PACKAGE_NAME).setUid(UID).build();
-                .setPackageName(PACKAGE_NAME)
-                .setUid(UID)
-                .build();
 
         mPreferenceManager = new PreferenceManager(mContext);
 
@@ -113,8 +104,9 @@ public class RestrictedAppDetailsTest {
         mRestrictedAppDetails.mRestrictedAppListGroup = spy(new PreferenceCategory(mContext));
         mRestrictedAppDetails.mBatteryUtils = spy(new BatteryUtils(mContext));
         mRestrictedAppDetails.mBatteryDatabaseManager = mBatteryDatabaseManager;
-        doReturn(mPreferenceManager).when(
+        doReturn(mPreferenceManager)
-                mRestrictedAppDetails.mRestrictedAppListGroup).getPreferenceManager();
+                .when(mRestrictedAppDetails.mRestrictedAppListGroup)
+                .getPreferenceManager();
 
         mCheckBoxPreference = new CheckBoxPreference(mContext);
         mCheckBoxPreference.setKey(mRestrictedAppDetails.getKeyFromAppInfo(mAppInfo));
@@ -122,14 +114,17 @@ public class RestrictedAppDetailsTest {
 
     @Test
     public void refreshUi_displayPreference() throws Exception {
-        doReturn(mApplicationInfo).when(mPackageManager)
+        doReturn(mApplicationInfo)
+                .when(mPackageManager)
                 .getApplicationInfoAsUser(PACKAGE_NAME, 0, USER_ID);
         doReturn(APP_NAME).when(mPackageManager).getApplicationLabel(mApplicationInfo);
-        doReturn(true).when(mRestrictedAppDetails.mBatteryUtils).isForceAppStandbyEnabled(UID,
+        doReturn(true)
-                PACKAGE_NAME);
+                .when(mRestrictedAppDetails.mBatteryUtils)
+                .isForceAppStandbyEnabled(UID, PACKAGE_NAME);
         final SparseLongArray timestampArray = new SparseLongArray();
         timestampArray.put(UID, System.currentTimeMillis() - TimeUnit.HOURS.toMillis(5));
-        doReturn(timestampArray).when(mBatteryDatabaseManager)
+        doReturn(timestampArray)
+                .when(mBatteryDatabaseManager)
                 .queryActionTime(AnomalyDatabaseHelper.ActionType.RESTRICTION);
 
         mRestrictedAppDetails.refreshUi();
@@ -145,30 +140,32 @@ public class RestrictedAppDetailsTest {
     @Test
     public void startRestrictedAppDetails_startWithCorrectData() {
         final ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
-        doAnswer(invocation -> {
+        doAnswer(
-            // Get the intent in which it has the app info bundle
+                        invocation -> {
-            mIntent = captor.getValue();
+                            // Get the intent in which it has the app info bundle
-            return true;
+                            mIntent = captor.getValue();
-        }).when(mContext).startActivity(captor.capture());
+                            return true;
+                        })
+                .when(mContext)
+                .startActivity(captor.capture());
 
-        RestrictedAppDetails.startRestrictedAppDetails(mFragment,
+        RestrictedAppDetails.startRestrictedAppDetails(mFragment, mRestrictedAppDetails.mAppInfos);
-                mRestrictedAppDetails.mAppInfos);
 
-        final Bundle bundle = mIntent.getBundleExtra(
+        final Bundle bundle =
-                SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS);
+                mIntent.getBundleExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS);
         // Verify the bundle has the correct info
-        final List<AppInfo> appInfos = bundle.getParcelableArrayList(
+        final List<AppInfo> appInfos =
-                RestrictedAppDetails.EXTRA_APP_INFO_LIST);
+                bundle.getParcelableArrayList(RestrictedAppDetails.EXTRA_APP_INFO_LIST);
         assertThat(appInfos).containsExactly(mAppInfo);
     }
 
     @Test
     public void createDialogFragment_toRestrict_createRestrictDialog() {
-        final BatteryTipDialogFragment dialogFragment = mRestrictedAppDetails.createDialogFragment(
+        final BatteryTipDialogFragment dialogFragment =
-                mAppInfo, true);
+                mRestrictedAppDetails.createDialogFragment(mAppInfo, true);
 
-        FragmentController.setupFragment(dialogFragment, FragmentActivity.class,
+        FragmentController.setupFragment(
-                0 /* containerViewId */, null /* bundle */);
+                dialogFragment, FragmentActivity.class, 0 /* containerViewId */, null /* bundle */);
 
         final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
         ShadowAlertDialogCompat shadowDialog = ShadowAlertDialogCompat.shadowOf(dialog);
@@ -177,11 +174,11 @@ public class RestrictedAppDetailsTest {
 
     @Test
     public void createDialogFragment_toUnrestrict_createUnrestrictDialog() {
-        final BatteryTipDialogFragment dialogFragment = mRestrictedAppDetails.createDialogFragment(
+        final BatteryTipDialogFragment dialogFragment =
-                mAppInfo, false);
+                mRestrictedAppDetails.createDialogFragment(mAppInfo, false);
 
-        FragmentController.setupFragment(dialogFragment, FragmentActivity.class,
+        FragmentController.setupFragment(
-                0 /* containerViewId */, null /* bundle */);
+                dialogFragment, FragmentActivity.class, 0 /* containerViewId */, null /* bundle */);
 
         final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
         ShadowAlertDialogCompat shadowDialog = ShadowAlertDialogCompat.shadowOf(dialog);
@@ -190,8 +187,8 @@ public class RestrictedAppDetailsTest {
 
     @Test
     public void onBatteryTipHandled_restrict_setChecked() {
-        final RestrictAppTip restrictAppTip = new RestrictAppTip(BatteryTip.StateType.NEW,
+        final RestrictAppTip restrictAppTip =
-                mAppInfo);
+                new RestrictAppTip(BatteryTip.StateType.NEW, mAppInfo);
         mRestrictedAppDetails.mRestrictedAppListGroup.addPreference(mCheckBoxPreference);
 
         mRestrictedAppDetails.onBatteryTipHandled(restrictAppTip);
@@ -201,8 +198,8 @@ public class RestrictedAppDetailsTest {
 
     @Test
     public void onBatteryTipHandled_unrestrict_setUnchecked() {
-        final UnrestrictAppTip unrestrictAppTip = new UnrestrictAppTip(BatteryTip.StateType.NEW,
+        final UnrestrictAppTip unrestrictAppTip =
-                mAppInfo);
+                new UnrestrictAppTip(BatteryTip.StateType.NEW, mAppInfo);
         mRestrictedAppDetails.mRestrictedAppListGroup.addPreference(mCheckBoxPreference);
 
         mRestrictedAppDetails.onBatteryTipHandled(unrestrictAppTip);

tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java

@@ -54,7 +54,8 @@ public class SmartBatteryPreferenceControllerTest {
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        doReturn(mock(DevicePolicyManager.class)).when(mContext)
+        doReturn(mock(DevicePolicyManager.class))
+                .when(mContext)
                 .getSystemService(Context.DEVICE_POLICY_SERVICE);
 
         mFeatureFactory = FakeFeatureFactory.setupForTest();
@@ -99,26 +100,26 @@ public class SmartBatteryPreferenceControllerTest {
     public void testGetAvailabilityStatus_smartBatterySupported_returnAvailable() {
         doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
 
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+        assertThat(mController.getAvailabilityStatus())
-                BasePreferenceController.AVAILABLE);
+                .isEqualTo(BasePreferenceController.AVAILABLE);
     }
 
     @Test
     public void testGetAvailabilityStatus_smartBatteryUnSupported_returnDisabled() {
         doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
 
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+        assertThat(mController.getAvailabilityStatus())
-                BasePreferenceController.UNSUPPORTED_ON_DEVICE);
+                .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
     }
 
     private void putSmartBatteryValue(int value) {
-        Settings.Global.putInt(mContentResolver,
+        Settings.Global.putInt(
-                Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, value);
+                mContentResolver, Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, value);
     }
 
     private int getSmartBatteryValue() {
-        return Settings.Global.getInt(mContentResolver,
+        return Settings.Global.getInt(
-                Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, ON);
+                mContentResolver, Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, ON);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/TopLevelBatteryPreferenceControllerTest.java

@@ -50,12 +50,9 @@ public class TopLevelBatteryPreferenceControllerTest {
     private TopLevelBatteryPreferenceController mController;
     private BatterySettingsFeatureProvider mBatterySettingsFeatureProvider;
 
-    @Mock
+    @Mock private UsbPort mUsbPort;
-    private UsbPort mUsbPort;
+    @Mock private UsbManager mUsbManager;
-    @Mock
+    @Mock private UsbPortStatus mUsbPortStatus;
-    private UsbManager mUsbManager;
-    @Mock
-    private UsbPortStatus mUsbPortStatus;
 
     @Before
     public void setUp() {
@@ -125,8 +122,7 @@ public class TopLevelBatteryPreferenceControllerTest {
         info.discharging = false;
         info.chargeLabel = "5% - charging";
 
-        assertThat(mController.getDashboardLabel(mContext, info, true))
+        assertThat(mController.getDashboardLabel(mContext, info, true)).isEqualTo(info.chargeLabel);
-                .isEqualTo(info.chargeLabel);
     }
 
     @Test
@@ -136,8 +132,9 @@ public class TopLevelBatteryPreferenceControllerTest {
         BatteryInfo info = new BatteryInfo();
 
         assertThat(mController.getDashboardLabel(mContext, info, true))
-                .isEqualTo(mContext.getString(
+                .isEqualTo(
-                        com.android.settingslib.R.string.battery_info_status_not_charging));
+                        mContext.getString(
+                                com.android.settingslib.R.string.battery_info_status_not_charging));
     }
 
     @Test
@@ -147,8 +144,7 @@ public class TopLevelBatteryPreferenceControllerTest {
         info.batteryStatus = BatteryManager.BATTERY_STATUS_NOT_CHARGING;
         info.statusLabel = "expected returned label";
 
-        assertThat(mController.getDashboardLabel(mContext, info, true))
+        assertThat(mController.getDashboardLabel(mContext, info, true)).isEqualTo(info.statusLabel);
-                .isEqualTo(info.statusLabel);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/UnrestrictedPreferenceControllerTest.java

@@ -88,8 +88,8 @@ public class UnrestrictedPreferenceControllerTest {
     public void testUpdateState_isSystemOrDefaultAppAndUnrestrictedStates_prefChecked() {
         when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
         when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_UNRESTRICTED);
+                .thenReturn(BatteryOptimizeUtils.MODE_UNRESTRICTED);
 
         mController.updateState(mPreference);
 
@@ -100,8 +100,8 @@ public class UnrestrictedPreferenceControllerTest {
     public void testUpdateState_isSystemOrDefaultApp_prefUnchecked() {
         when(mBatteryOptimizeUtils.isDisabledForOptimizeModeOnly()).thenReturn(false);
         when(mBatteryOptimizeUtils.isSystemOrDefaultApp()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_OPTIMIZED);
+                .thenReturn(BatteryOptimizeUtils.MODE_OPTIMIZED);
 
         mController.updateState(mPreference);
 
@@ -112,8 +112,8 @@ public class UnrestrictedPreferenceControllerTest {
     @Test
     public void testUpdateState_isUnrestrictedStates_prefChecked() {
         when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_UNRESTRICTED);
+                .thenReturn(BatteryOptimizeUtils.MODE_UNRESTRICTED);
 
         mController.updateState(mPreference);
 
@@ -124,8 +124,8 @@ public class UnrestrictedPreferenceControllerTest {
     @Test
     public void testUpdateState_prefUnchecked() {
         when(mBatteryOptimizeUtils.isOptimizeModeMutable()).thenReturn(true);
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(
+        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                BatteryOptimizeUtils.MODE_OPTIMIZED);
+                .thenReturn(BatteryOptimizeUtils.MODE_OPTIMIZED);
 
         mController.updateState(mPreference);
 

tests/robotests/src/com/android/settings/fuelgauge/batterysaver/BatterySaverButtonPreferenceControllerTest.java

@@ -47,10 +47,8 @@ public class BatterySaverButtonPreferenceControllerTest {
     private Context mContext;
     private MainSwitchPreference mPreference;
 
-    @Mock
+    @Mock private PowerManager mPowerManager;
-    private PowerManager mPowerManager;
+    @Mock private PreferenceScreen mPreferenceScreen;
-    @Mock
-    private PreferenceScreen mPreferenceScreen;
 
     @Before
     public void setUp() {

tests/robotests/src/com/android/settings/fuelgauge/batterysaver/BatterySaverSchedulePreferenceControllerTest.java

@@ -59,10 +59,12 @@ public class BatterySaverSchedulePreferenceControllerTest {
 
     @Test
     public void testPreference_lowPowerLevelZero_percentageMode_summaryNoSchedule() {
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0);
+                mContext.getContentResolver(), Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0);
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Global.AUTOMATIC_POWER_SAVE_MODE, PowerManager.POWER_SAVE_MODE_TRIGGER_PERCENTAGE);
+                mContext.getContentResolver(),
+                Global.AUTOMATIC_POWER_SAVE_MODE,
+                PowerManager.POWER_SAVE_MODE_TRIGGER_PERCENTAGE);
 
         mController.updateState(mPreference);
 
@@ -71,10 +73,14 @@ public class BatterySaverSchedulePreferenceControllerTest {
 
     @Test
     public void testPreference_lowPowerLevelNonZero_percentageMode_summaryPercentage() {
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, TRIGGER_LEVEL);
+                mContext.getContentResolver(),
-        Settings.Global.putInt(mContext.getContentResolver(),
+                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL,
-                Global.AUTOMATIC_POWER_SAVE_MODE, PowerManager.POWER_SAVE_MODE_TRIGGER_PERCENTAGE);
+                TRIGGER_LEVEL);
+        Settings.Global.putInt(
+                mContext.getContentResolver(),
+                Global.AUTOMATIC_POWER_SAVE_MODE,
+                PowerManager.POWER_SAVE_MODE_TRIGGER_PERCENTAGE);
 
         mController.updateState(mPreference);
 

tests/robotests/src/com/android/settings/fuelgauge/batterysaver/BatterySaverScheduleSeekBarControllerTest.java

@@ -34,8 +34,7 @@ public class BatterySaverScheduleSeekBarControllerTest {
     private Context mContext;
     private ContentResolver mResolver;
     private BatterySaverScheduleSeekBarController mController;
-    @Mock
+    @Mock private PreferenceScreen mScreen;
-    private PreferenceScreen mScreen;
 
     @Before
     public void setUp() {
@@ -83,7 +82,9 @@ public class BatterySaverScheduleSeekBarControllerTest {
 
     @Test
     public void updateSeekBar_routineMode_hasCorrectProperties() {
-        Settings.Global.putInt(mResolver, Global.AUTOMATIC_POWER_SAVE_MODE,
+        Settings.Global.putInt(
+                mResolver,
+                Global.AUTOMATIC_POWER_SAVE_MODE,
                 PowerManager.POWER_SAVE_MODE_TRIGGER_DYNAMIC);
 
         mController.updateSeekBar();
@@ -95,7 +96,9 @@ public class BatterySaverScheduleSeekBarControllerTest {
     @Test
     public void updateSeekBar_percentageMode_hasCorrectProperties() {
         final CharSequence expectedTitle = "10%";
-        Settings.Global.putInt(mResolver, Global.AUTOMATIC_POWER_SAVE_MODE,
+        Settings.Global.putInt(
+                mResolver,
+                Global.AUTOMATIC_POWER_SAVE_MODE,
                 PowerManager.POWER_SAVE_MODE_TRIGGER_PERCENTAGE);
         setTriggerLevel(10);
 
@@ -108,7 +111,9 @@ public class BatterySaverScheduleSeekBarControllerTest {
 
     @Test
     public void updateSeekBar_noneMode_hasCorrectProperties() {
-        Settings.Global.putInt(mResolver, Global.AUTOMATIC_POWER_SAVE_MODE,
+        Settings.Global.putInt(
+                mResolver,
+                Global.AUTOMATIC_POWER_SAVE_MODE,
                 PowerManager.POWER_SAVE_MODE_TRIGGER_PERCENTAGE);
         setTriggerLevel(0);
 
@@ -120,7 +125,9 @@ public class BatterySaverScheduleSeekBarControllerTest {
 
     @Test
     public void addToScreen_addsToEnd() {
-        Settings.Global.putInt(mResolver, Global.AUTOMATIC_POWER_SAVE_MODE,
+        Settings.Global.putInt(
+                mResolver,
+                Global.AUTOMATIC_POWER_SAVE_MODE,
                 PowerManager.POWER_SAVE_MODE_TRIGGER_PERCENTAGE);
         setTriggerLevel(15);
 

tests/robotests/src/com/android/settings/fuelgauge/batterysaver/BatterySaverScheduleSettingsTest.java

@@ -1,6 +1,7 @@
 package com.android.settings.fuelgauge.batterysaver;
 
 import static com.google.common.truth.Truth.assertThat;
+
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -90,18 +91,25 @@ public final class BatterySaverScheduleSettingsTest {
     }
 
     private void setSchedule(int scheduleType, int schedulePercentage) {
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.AUTOMATIC_POWER_SAVE_MODE, scheduleType);
+                mContext.getContentResolver(),
-        Settings.Global.putInt(mContext.getContentResolver(),
+                Settings.Global.AUTOMATIC_POWER_SAVE_MODE,
-                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, schedulePercentage);
+                scheduleType);
+        Settings.Global.putInt(
+                mContext.getContentResolver(),
+                Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL,
+                schedulePercentage);
     }
 
     private void verifySchedule(String scheduleTypeKey, int schedulePercentage) {
         waitAWhile();
-        verify(mMetricsFeatureProvider).action(SettingsEnums.FUELGAUGE_BATTERY_SAVER,
+        verify(mMetricsFeatureProvider)
-                SettingsEnums.FIELD_BATTERY_SAVER_SCHEDULE_TYPE,
+                .action(
-                SettingsEnums.FIELD_BATTERY_SAVER_PERCENTAGE_VALUE,
+                        SettingsEnums.FUELGAUGE_BATTERY_SAVER,
-                scheduleTypeKey, schedulePercentage);
+                        SettingsEnums.FIELD_BATTERY_SAVER_SCHEDULE_TYPE,
+                        SettingsEnums.FIELD_BATTERY_SAVER_PERCENTAGE_VALUE,
+                        scheduleTypeKey,
+                        schedulePercentage);
     }
 
     private void waitAWhile() {

tests/robotests/src/com/android/settings/fuelgauge/batterysaver/BatterySaverSettingsTest.java

@@ -34,13 +34,13 @@ import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {
+@Config(
-        com.android.settings.testutils.shadow.ShadowFragment.class,
+        shadows = {
-})
+            com.android.settings.testutils.shadow.ShadowFragment.class,
+        })
 public class BatterySaverSettingsTest {
     BatterySaverSettings mFragment;
-    @Mock
+    @Mock PreferenceScreen mScreen;
-    PreferenceScreen mScreen;
 
     @Before
     public void setUp() {
@@ -50,7 +50,6 @@ public class BatterySaverSettingsTest {
         doReturn(mScreen).when(mFragment).getPreferenceScreen();
     }
 
-
     @Test
     public void setupFooter_linkAddedWhenAppropriate() {
         doReturn("").when(mFragment).getText(anyInt());

tests/robotests/src/com/android/settings/fuelgauge/batterytip/AnomalyCleanupJobServiceTest.java

@@ -63,16 +63,15 @@ public class AnomalyCleanupJobServiceTest {
 
     private Context mContext;
     private JobScheduler mJobScheduler;
-    @Mock
+    @Mock private JobParameters mParams;
-    private JobParameters mParams;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
         mContext = spy(RuntimeEnvironment.application);
-        mJobScheduler = spy(new JobSchedulerImpl(mContext,
+        mJobScheduler =
-                IJobScheduler.Stub.asInterface(new Binder())));
+                spy(new JobSchedulerImpl(mContext, IJobScheduler.Stub.asInterface(new Binder())));
         when(mContext.getSystemService(JobScheduler.class)).thenReturn(mJobScheduler);
     }
 
@@ -108,25 +107,31 @@ public class AnomalyCleanupJobServiceTest {
     @Ignore
     public void onStartJob_cleanUpDataBefore30days() {
         final BatteryDatabaseManager databaseManager = BatteryDatabaseManager.getInstance(mContext);
-        final AnomalyCleanupJobService service = spy(Robolectric.setupService(
+        final AnomalyCleanupJobService service =
-                AnomalyCleanupJobService.class));
+                spy(Robolectric.setupService(AnomalyCleanupJobService.class));
         doNothing().when(service).jobFinished(any(), anyBoolean());
 
         // Insert two records, one is current and the other one is 31 days before
-        databaseManager.insertAnomaly(UID, PACKAGE_NAME, ANOMALY_TYPE,
+        databaseManager.insertAnomaly(
-                AnomalyDatabaseHelper.State.NEW, TIMESTAMP_NOW);
+                UID, PACKAGE_NAME, ANOMALY_TYPE, AnomalyDatabaseHelper.State.NEW, TIMESTAMP_NOW);
-        databaseManager.insertAnomaly(UID, PACKAGE_NAME_OLD, ANOMALY_TYPE,
+        databaseManager.insertAnomaly(
-                AnomalyDatabaseHelper.State.NEW, TIMESTAMP_31_DAYS_BEFORE);
+                UID,
+                PACKAGE_NAME_OLD,
+                ANOMALY_TYPE,
+                AnomalyDatabaseHelper.State.NEW,
+                TIMESTAMP_31_DAYS_BEFORE);
 
         service.onStartJob(mParams);
 
         // In database, it only contains the current record
-        final List<AppInfo> appInfos = databaseManager.queryAllAnomalies(0,
+        final List<AppInfo> appInfos =
-                AnomalyDatabaseHelper.State.NEW);
+                databaseManager.queryAllAnomalies(0, AnomalyDatabaseHelper.State.NEW);
-        assertThat(appInfos).containsExactly(new AppInfo.Builder()
+        assertThat(appInfos)
-                .setUid(UID)
+                .containsExactly(
-                .setPackageName(PACKAGE_NAME)
+                        new AppInfo.Builder()
-                .addAnomalyType(ANOMALY_TYPE)
+                                .setUid(UID)
-                .build());
+                                .setPackageName(PACKAGE_NAME)
+                                .addAnomalyType(ANOMALY_TYPE)
+                                .build());
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/AnomalyConfigJobServiceTest.java

@@ -57,8 +57,7 @@ public class AnomalyConfigJobServiceTest {
 
     private static final int ANOMALY_CONFIG_VERSION = 1;
     private static final String ANOMALY_CONFIG = "X64s";
-    @Mock
+    @Mock private StatsManager mStatsManager;
-    private StatsManager mStatsManager;
 
     private Context mContext;
     private JobScheduler mJobScheduler;
@@ -69,14 +68,16 @@ public class AnomalyConfigJobServiceTest {
         MockitoAnnotations.initMocks(this);
 
         mContext = spy(RuntimeEnvironment.application);
-        mJobScheduler = spy(new JobSchedulerImpl(mContext,
+        mJobScheduler =
-                IJobScheduler.Stub.asInterface(new Binder())));
+                spy(new JobSchedulerImpl(mContext, IJobScheduler.Stub.asInterface(new Binder())));
         when(mContext.getSystemService(JobScheduler.class)).thenReturn(mJobScheduler);
 
         mJobService = spy(new AnomalyConfigJobService());
-        doReturn(application.getSharedPreferences(AnomalyConfigJobService.PREF_DB,
+        doReturn(
-                Context.MODE_PRIVATE)).when(mJobService).getSharedPreferences(anyString(),
+                        application.getSharedPreferences(
-                anyInt());
+                                AnomalyConfigJobService.PREF_DB, Context.MODE_PRIVATE))
+                .when(mJobService)
+                .getSharedPreferences(anyString(), anyInt());
         doReturn(application.getContentResolver()).when(mJobService).getContentResolver();
     }
 
@@ -105,11 +106,13 @@ public class AnomalyConfigJobServiceTest {
 
     @Test
     public void checkAnomalyConfig_newConfigExist_removeOldConfig()
-            throws StatsManager.StatsUnavailableException{
+            throws StatsManager.StatsUnavailableException {
-        Settings.Global.putInt(application.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.ANOMALY_CONFIG_VERSION, ANOMALY_CONFIG_VERSION);
+                application.getContentResolver(),
-        Settings.Global.putString(application.getContentResolver(), Settings.Global.ANOMALY_CONFIG,
+                Settings.Global.ANOMALY_CONFIG_VERSION,
-                ANOMALY_CONFIG);
+                ANOMALY_CONFIG_VERSION);
+        Settings.Global.putString(
+                application.getContentResolver(), Settings.Global.ANOMALY_CONFIG, ANOMALY_CONFIG);
 
         mJobService.checkAnomalyConfig(mStatsManager);
 
@@ -118,11 +121,13 @@ public class AnomalyConfigJobServiceTest {
 
     @Test
     public void checkAnomalyConfig_newConfigExist_uploadNewConfig()
-            throws StatsManager.StatsUnavailableException{
+            throws StatsManager.StatsUnavailableException {
-        Settings.Global.putInt(application.getContentResolver(),
+        Settings.Global.putInt(
-                Settings.Global.ANOMALY_CONFIG_VERSION, ANOMALY_CONFIG_VERSION);
+                application.getContentResolver(),
-        Settings.Global.putString(application.getContentResolver(), Settings.Global.ANOMALY_CONFIG,
+                Settings.Global.ANOMALY_CONFIG_VERSION,
-                ANOMALY_CONFIG);
+                ANOMALY_CONFIG_VERSION);
+        Settings.Global.putString(
+                application.getContentResolver(), Settings.Global.ANOMALY_CONFIG, ANOMALY_CONFIG);
 
         mJobService.checkAnomalyConfig(mStatsManager);
 

tests/robotests/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobServiceTest.java

@@ -86,20 +86,13 @@ public class AnomalyDetectionJobServiceTest {
             "anomaly_type=6,auto_restriction=false";
     private static final int ANOMALY_TYPE = 6;
     private static final long VERSION_CODE = 15;
-    @Mock
+    @Mock private UserManager mUserManager;
-    private UserManager mUserManager;
+    @Mock private BatteryDatabaseManager mBatteryDatabaseManager;
-    @Mock
+    @Mock private BatteryUtils mBatteryUtils;
-    private BatteryDatabaseManager mBatteryDatabaseManager;
+    @Mock private PowerAllowlistBackend mPowerAllowlistBackend;
-    @Mock
+    @Mock private StatsDimensionsValue mStatsDimensionsValue;
-    private BatteryUtils mBatteryUtils;
+    @Mock private JobParameters mJobParameters;
-    @Mock
+    @Mock private JobWorkItem mJobWorkItem;
-    private PowerAllowlistBackend mPowerAllowlistBackend;
-    @Mock
-    private StatsDimensionsValue mStatsDimensionsValue;
-    @Mock
-    private JobParameters mJobParameters;
-    @Mock
-    private JobWorkItem mJobWorkItem;
 
     private BatteryTipPolicy mPolicy;
     private Bundle mBundle;
@@ -113,8 +106,8 @@ public class AnomalyDetectionJobServiceTest {
         MockitoAnnotations.initMocks(this);
 
         mContext = spy(RuntimeEnvironment.application);
-        mJobScheduler = spy(new JobSchedulerImpl(mContext,
+        mJobScheduler =
-                IJobScheduler.Stub.asInterface(new Binder())));
+                spy(new JobSchedulerImpl(mContext, IJobScheduler.Stub.asInterface(new Binder())));
         when(mContext.getSystemService(JobScheduler.class)).thenReturn(mJobScheduler);
 
         mPolicy = new BatteryTipPolicy(mContext);
@@ -146,17 +139,24 @@ public class AnomalyDetectionJobServiceTest {
     @Test
     public void saveAnomalyToDatabase_systemAllowlisted_doNotSave() {
         doReturn(UID).when(mAnomalyDetectionJobService).extractUidFromStatsDimensionsValue(any());
-        doReturn(true).when(mPowerAllowlistBackend)
+        doReturn(true)
+                .when(mPowerAllowlistBackend)
                 .isAllowlisted(any(String[].class), any(Integer.class));
 
-        mAnomalyDetectionJobService.saveAnomalyToDatabase(mContext,
+        mAnomalyDetectionJobService.saveAnomalyToDatabase(
-                mUserManager, mBatteryDatabaseManager, mBatteryUtils, mPolicy,
+                mContext,
-                mPowerAllowlistBackend, mContext.getContentResolver(),
+                mUserManager,
+                mBatteryDatabaseManager,
+                mBatteryUtils,
+                mPolicy,
+                mPowerAllowlistBackend,
+                mContext.getContentResolver(),
                 mFeatureFactory.powerUsageFeatureProvider,
-                mFeatureFactory.metricsFeatureProvider, mBundle);
+                mFeatureFactory.metricsFeatureProvider,
+                mBundle);
 
-        verify(mBatteryDatabaseManager, never()).insertAnomaly(anyInt(), anyString(), anyInt(),
+        verify(mBatteryDatabaseManager, never())
-                anyInt(), anyLong());
+                .insertAnomaly(anyInt(), anyString(), anyInt(), anyInt(), anyLong());
     }
 
     @Test
@@ -166,53 +166,76 @@ public class AnomalyDetectionJobServiceTest {
         mBundle.putStringArrayList(StatsManager.EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES, cookies);
         doReturn(SYSTEM_PACKAGE).when(mBatteryUtils).getPackageName(anyInt());
         doReturn(false).when(mPowerAllowlistBackend).isSysAllowlisted(SYSTEM_PACKAGE);
-        doReturn(Process.FIRST_APPLICATION_UID).when(
+        doReturn(Process.FIRST_APPLICATION_UID)
-                mAnomalyDetectionJobService).extractUidFromStatsDimensionsValue(any());
+                .when(mAnomalyDetectionJobService)
+                .extractUidFromStatsDimensionsValue(any());
         doReturn(true).when(mBatteryUtils).shouldHideAnomaly(any(), anyInt(), any());
 
-        mAnomalyDetectionJobService.saveAnomalyToDatabase(mContext,
+        mAnomalyDetectionJobService.saveAnomalyToDatabase(
-                mUserManager, mBatteryDatabaseManager, mBatteryUtils, mPolicy,
+                mContext,
-                mPowerAllowlistBackend, mContext.getContentResolver(),
+                mUserManager,
+                mBatteryDatabaseManager,
+                mBatteryUtils,
+                mPolicy,
+                mPowerAllowlistBackend,
+                mContext.getContentResolver(),
                 mFeatureFactory.powerUsageFeatureProvider,
-                mFeatureFactory.metricsFeatureProvider, mBundle);
+                mFeatureFactory.metricsFeatureProvider,
+                mBundle);
 
-        verify(mBatteryDatabaseManager, never()).insertAnomaly(anyInt(), anyString(), anyInt(),
+        verify(mBatteryDatabaseManager, never())
-                anyInt(), anyLong());
+                .insertAnomaly(anyInt(), anyString(), anyInt(), anyInt(), anyLong());
-        verify(mFeatureFactory.metricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+        verify(mFeatureFactory.metricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_ANOMALY_IGNORED,
+                .action(
-                SettingsEnums.PAGE_UNKNOWN,
+                        SettingsEnums.PAGE_UNKNOWN,
-                SYSTEM_PACKAGE + "/" + VERSION_CODE,
+                        MetricsProto.MetricsEvent.ACTION_ANOMALY_IGNORED,
-                 ANOMALY_TYPE);
+                        SettingsEnums.PAGE_UNKNOWN,
+                        SYSTEM_PACKAGE + "/" + VERSION_CODE,
+                        ANOMALY_TYPE);
     }
 
     @Test
     public void saveAnomalyToDatabase_systemUid_doNotSave() {
-        doReturn(Process.SYSTEM_UID).when(
+        doReturn(Process.SYSTEM_UID)
-                mAnomalyDetectionJobService).extractUidFromStatsDimensionsValue(any());
+                .when(mAnomalyDetectionJobService)
+                .extractUidFromStatsDimensionsValue(any());
 
-        mAnomalyDetectionJobService.saveAnomalyToDatabase(mContext,
+        mAnomalyDetectionJobService.saveAnomalyToDatabase(
-                mUserManager, mBatteryDatabaseManager, mBatteryUtils, mPolicy,
+                mContext,
-                mPowerAllowlistBackend, mContext.getContentResolver(),
+                mUserManager,
-                mFeatureFactory.powerUsageFeatureProvider, mFeatureFactory.metricsFeatureProvider,
+                mBatteryDatabaseManager,
+                mBatteryUtils,
+                mPolicy,
+                mPowerAllowlistBackend,
+                mContext.getContentResolver(),
+                mFeatureFactory.powerUsageFeatureProvider,
+                mFeatureFactory.metricsFeatureProvider,
                 mBundle);
 
-        verify(mBatteryDatabaseManager, never()).insertAnomaly(anyInt(), anyString(), anyInt(),
+        verify(mBatteryDatabaseManager, never())
-                anyInt(), anyLong());
+                .insertAnomaly(anyInt(), anyString(), anyInt(), anyInt(), anyLong());
     }
 
     @Test
     public void saveAnomalyToDatabase_uidNull_doNotSave() {
-        doReturn(AnomalyDetectionJobService.UID_NULL).when(
+        doReturn(AnomalyDetectionJobService.UID_NULL)
-                mAnomalyDetectionJobService).extractUidFromStatsDimensionsValue(any());
+                .when(mAnomalyDetectionJobService)
+                .extractUidFromStatsDimensionsValue(any());
 
-        mAnomalyDetectionJobService.saveAnomalyToDatabase(mContext,
+        mAnomalyDetectionJobService.saveAnomalyToDatabase(
-                mUserManager, mBatteryDatabaseManager, mBatteryUtils, mPolicy,
+                mContext,
-                mPowerAllowlistBackend, mContext.getContentResolver(),
+                mUserManager,
-                mFeatureFactory.powerUsageFeatureProvider, mFeatureFactory.metricsFeatureProvider,
+                mBatteryDatabaseManager,
+                mBatteryUtils,
+                mPolicy,
+                mPowerAllowlistBackend,
+                mContext.getContentResolver(),
+                mFeatureFactory.powerUsageFeatureProvider,
+                mFeatureFactory.metricsFeatureProvider,
                 mBundle);
 
-        verify(mBatteryDatabaseManager, never()).insertAnomaly(anyInt(), anyString(), anyInt(),
+        verify(mBatteryDatabaseManager, never())
-                anyInt(), anyLong());
+                .insertAnomaly(anyInt(), anyString(), anyInt(), anyInt(), anyLong());
     }
 
     @Test
@@ -222,22 +245,36 @@ public class AnomalyDetectionJobServiceTest {
         mBundle.putStringArrayList(StatsManager.EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES, cookies);
         doReturn(SYSTEM_PACKAGE).when(mBatteryUtils).getPackageName(anyInt());
         doReturn(false).when(mPowerAllowlistBackend).isSysAllowlisted(SYSTEM_PACKAGE);
-        doReturn(Process.FIRST_APPLICATION_UID).when(
+        doReturn(Process.FIRST_APPLICATION_UID)
-                mAnomalyDetectionJobService).extractUidFromStatsDimensionsValue(any());
+                .when(mAnomalyDetectionJobService)
+                .extractUidFromStatsDimensionsValue(any());
 
-        mAnomalyDetectionJobService.saveAnomalyToDatabase(mContext,
+        mAnomalyDetectionJobService.saveAnomalyToDatabase(
-                mUserManager, mBatteryDatabaseManager, mBatteryUtils, mPolicy,
+                mContext,
-                mPowerAllowlistBackend, mContext.getContentResolver(),
+                mUserManager,
-                mFeatureFactory.powerUsageFeatureProvider, mFeatureFactory.metricsFeatureProvider,
+                mBatteryDatabaseManager,
+                mBatteryUtils,
+                mPolicy,
+                mPowerAllowlistBackend,
+                mContext.getContentResolver(),
+                mFeatureFactory.powerUsageFeatureProvider,
+                mFeatureFactory.metricsFeatureProvider,
                 mBundle);
 
-        verify(mBatteryDatabaseManager).insertAnomaly(anyInt(), anyString(), eq(6),
+        verify(mBatteryDatabaseManager)
-                eq(AnomalyDatabaseHelper.State.AUTO_HANDLED), anyLong());
+                .insertAnomaly(
-        verify(mFeatureFactory.metricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+                        anyInt(),
-                MetricsProto.MetricsEvent.ACTION_ANOMALY_TRIGGERED,
+                        anyString(),
-                SettingsEnums.PAGE_UNKNOWN,
+                        eq(6),
-                SYSTEM_PACKAGE + "/" + VERSION_CODE,
+                        eq(AnomalyDatabaseHelper.State.AUTO_HANDLED),
-                ANOMALY_TYPE);
+                        anyLong());
+        verify(mFeatureFactory.metricsFeatureProvider)
+                .action(
+                        SettingsEnums.PAGE_UNKNOWN,
+                        MetricsProto.MetricsEvent.ACTION_ANOMALY_TRIGGERED,
+                        SettingsEnums.PAGE_UNKNOWN,
+                        SYSTEM_PACKAGE + "/" + VERSION_CODE,
+                        ANOMALY_TYPE);
     }
 
     @Test
@@ -247,22 +284,36 @@ public class AnomalyDetectionJobServiceTest {
         mBundle.putStringArrayList(StatsManager.EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES, cookies);
         doReturn(SYSTEM_PACKAGE).when(mBatteryUtils).getPackageName(anyInt());
         doReturn(false).when(mPowerAllowlistBackend).isSysAllowlisted(SYSTEM_PACKAGE);
-        doReturn(Process.FIRST_APPLICATION_UID).when(
+        doReturn(Process.FIRST_APPLICATION_UID)
-                mAnomalyDetectionJobService).extractUidFromStatsDimensionsValue(any());
+                .when(mAnomalyDetectionJobService)
+                .extractUidFromStatsDimensionsValue(any());
 
-        mAnomalyDetectionJobService.saveAnomalyToDatabase(mContext,
+        mAnomalyDetectionJobService.saveAnomalyToDatabase(
-                mUserManager, mBatteryDatabaseManager, mBatteryUtils, mPolicy,
+                mContext,
-                mPowerAllowlistBackend, mContext.getContentResolver(),
+                mUserManager,
-                mFeatureFactory.powerUsageFeatureProvider, mFeatureFactory.metricsFeatureProvider,
+                mBatteryDatabaseManager,
+                mBatteryUtils,
+                mPolicy,
+                mPowerAllowlistBackend,
+                mContext.getContentResolver(),
+                mFeatureFactory.powerUsageFeatureProvider,
+                mFeatureFactory.metricsFeatureProvider,
                 mBundle);
 
-        verify(mBatteryDatabaseManager).insertAnomaly(anyInt(), anyString(), eq(6),
+        verify(mBatteryDatabaseManager)
-                eq(AnomalyDatabaseHelper.State.NEW), anyLong());
+                .insertAnomaly(
-        verify(mFeatureFactory.metricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+                        anyInt(),
-                MetricsProto.MetricsEvent.ACTION_ANOMALY_TRIGGERED,
+                        anyString(),
-                SettingsEnums.PAGE_UNKNOWN,
+                        eq(6),
-                SYSTEM_PACKAGE + "/" + VERSION_CODE,
+                        eq(AnomalyDatabaseHelper.State.NEW),
-                ANOMALY_TYPE);
+                        anyLong());
+        verify(mFeatureFactory.metricsFeatureProvider)
+                .action(
+                        SettingsEnums.PAGE_UNKNOWN,
+                        MetricsProto.MetricsEvent.ACTION_ANOMALY_TRIGGERED,
+                        SettingsEnums.PAGE_UNKNOWN,
+                        SYSTEM_PACKAGE + "/" + VERSION_CODE,
+                        ANOMALY_TYPE);
     }
 
     @Test
@@ -280,8 +331,8 @@ public class AnomalyDetectionJobServiceTest {
         statsDimensionsValues.add(intValue);
         when(tupleValue.getTupleValueList()).thenReturn(statsDimensionsValues);
 
-        assertThat(mAnomalyDetectionJobService.extractUidFromStatsDimensionsValue(
+        assertThat(mAnomalyDetectionJobService.extractUidFromStatsDimensionsValue(tupleValue))
-                tupleValue)).isEqualTo(UID);
+                .isEqualTo(UID);
     }
 
     @Test
@@ -292,8 +343,8 @@ public class AnomalyDetectionJobServiceTest {
         when(floatValue.getField()).thenReturn(AnomalyDetectionJobService.STATSD_UID_FILED);
         when(floatValue.getFloatValue()).thenReturn(0f);
 
-        assertThat(mAnomalyDetectionJobService.extractUidFromStatsDimensionsValue(
+        assertThat(mAnomalyDetectionJobService.extractUidFromStatsDimensionsValue(floatValue))
-                floatValue)).isEqualTo(AnomalyDetectionJobService.UID_NULL);
+                .isEqualTo(AnomalyDetectionJobService.UID_NULL);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipDialogFragmentTest.java

@@ -18,7 +18,6 @@ package com.android.settings.fuelgauge.batterytip;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
 
 import android.content.Context;
@@ -39,7 +38,6 @@ import com.android.settings.fuelgauge.batterytip.tips.UnrestrictAppTip;
 import com.android.settings.testutils.FakeFeatureFactory;
 import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
 import com.android.settings.testutils.shadow.ShadowUtils;
-import com.android.settingslib.fuelgauge.EstimateKt;
 
 import org.junit.After;
 import org.junit.Before;
@@ -98,20 +96,21 @@ public class BatteryTipDialogFragmentTest {
         mPackageManager.setApplicationIcon(PACKAGE_NAME, new ColorDrawable());
 
         List<AppInfo> highUsageTips = new ArrayList<>();
-        mAppInfo = new AppInfo.Builder()
+        mAppInfo =
-                .setScreenOnTimeMs(SCREEN_TIME_MS)
+                new AppInfo.Builder()
-                .setPackageName(PACKAGE_NAME)
+                        .setScreenOnTimeMs(SCREEN_TIME_MS)
-                .build();
+                        .setPackageName(PACKAGE_NAME)
+                        .build();
         highUsageTips.add(mAppInfo);
         mHighUsageTip = new HighUsageTip(SCREEN_TIME_MS, highUsageTips);
 
         final List<AppInfo> restrictApps = new ArrayList<>();
         restrictApps.add(mAppInfo);
-        mRestrictedOneAppTip = new RestrictAppTip(BatteryTip.StateType.NEW,
+        mRestrictedOneAppTip =
-                new ArrayList<>(restrictApps));
+                new RestrictAppTip(BatteryTip.StateType.NEW, new ArrayList<>(restrictApps));
         restrictApps.add(mAppInfo);
-        mRestrictTwoAppsTip = new RestrictAppTip(BatteryTip.StateType.NEW,
+        mRestrictTwoAppsTip =
-                new ArrayList<>(restrictApps));
+                new RestrictAppTip(BatteryTip.StateType.NEW, new ArrayList<>(restrictApps));
 
         mUnrestrictAppTip = new UnrestrictAppTip(BatteryTip.StateType.NEW, mAppInfo);
         mDefenderTip = new BatteryDefenderTip(BatteryTip.StateType.NEW, false /* isPluggedIn */);
@@ -128,24 +127,30 @@ public class BatteryTipDialogFragmentTest {
 
         mDialogFragment = BatteryTipDialogFragment.newInstance(mHighUsageTip, METRICS_KEY);
 
-        FragmentController.setupFragment(mDialogFragment, FragmentActivity.class,
+        FragmentController.setupFragment(
-                0 /* containerViewId */, null /* bundle */);
+                mDialogFragment,
+                FragmentActivity.class,
+                0 /* containerViewId */,
+                null /* bundle */);
 
         Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable();
 
         final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
         ShadowAlertDialogCompat shadowDialog = ShadowAlertDialogCompat.shadowOf(dialog);
 
-        assertThat(shadowDialog.getMessage()).isEqualTo(
+        assertThat(shadowDialog.getMessage())
-                mContext.getString(R.string.battery_tip_dialog_message, 1));
+                .isEqualTo(mContext.getString(R.string.battery_tip_dialog_message, 1));
     }
 
     @Test
     public void testOnCreateDialog_restrictOneAppTip_fireRestrictOneAppDialog() {
         mDialogFragment = BatteryTipDialogFragment.newInstance(mRestrictedOneAppTip, METRICS_KEY);
 
-        FragmentController.setupFragment(mDialogFragment, FragmentActivity.class,
+        FragmentController.setupFragment(
-                0 /* containerViewId */, null /* bundle */);
+                mDialogFragment,
+                FragmentActivity.class,
+                0 /* containerViewId */,
+                null /* bundle */);
 
         final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
         ShadowAlertDialogCompat shadowDialog = ShadowAlertDialogCompat.shadowOf(dialog);
@@ -163,9 +168,11 @@ public class BatteryTipDialogFragmentTest {
 
         mDialogFragment = BatteryTipDialogFragment.newInstance(mRestrictTwoAppsTip, METRICS_KEY);
 
-
+        FragmentController.setupFragment(
-        FragmentController.setupFragment(mDialogFragment, FragmentActivity.class,
+                mDialogFragment,
-                0 /* containerViewId */, null /* bundle */);
+                FragmentActivity.class,
+                0 /* containerViewId */,
+                null /* bundle */);
 
         Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable();
 
@@ -189,13 +196,16 @@ public class BatteryTipDialogFragmentTest {
         for (int i = 0; i < 6; i++) {
             appInfos.add(mAppInfo);
         }
-        final RestrictAppTip restrictSixAppsTip = new RestrictAppTip(BatteryTip.StateType.NEW,
+        final RestrictAppTip restrictSixAppsTip =
-                appInfos);
+                new RestrictAppTip(BatteryTip.StateType.NEW, appInfos);
 
         mDialogFragment = BatteryTipDialogFragment.newInstance(restrictSixAppsTip, METRICS_KEY);
 
-        FragmentController.setupFragment(mDialogFragment, FragmentActivity.class,
+        FragmentController.setupFragment(
-                0 /* containerViewId */, null /* bundle */);
+                mDialogFragment,
+                FragmentActivity.class,
+                0 /* containerViewId */,
+                null /* bundle */);
 
         Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable();
 
@@ -215,8 +225,11 @@ public class BatteryTipDialogFragmentTest {
         mDialogFragment = BatteryTipDialogFragment.newInstance(mUnrestrictAppTip, METRICS_KEY);
         ShadowUtils.setApplicationLabel(PACKAGE_NAME, DISPLAY_NAME);
 
-        FragmentController.setupFragment(mDialogFragment, FragmentActivity.class,
+        FragmentController.setupFragment(
-                0 /* containerViewId */, null /* bundle */);
+                mDialogFragment,
+                FragmentActivity.class,
+                0 /* containerViewId */,
+                null /* bundle */);
 
         final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
         ShadowAlertDialogCompat shadowDialog = ShadowAlertDialogCompat.shadowOf(dialog);

tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipLoaderTest.java

@@ -50,21 +50,20 @@ import java.util.List;
 public class BatteryTipLoaderTest {
 
     private static final int[] TIP_ORDER = {
-            BatteryTip.TipType.LOW_BATTERY,
+        BatteryTip.TipType.LOW_BATTERY,
-            BatteryTip.TipType.BATTERY_DEFENDER,
+        BatteryTip.TipType.BATTERY_DEFENDER,
-            BatteryTip.TipType.DOCK_DEFENDER,
+        BatteryTip.TipType.DOCK_DEFENDER,
-            BatteryTip.TipType.INCOMPATIBLE_CHARGER,
+        BatteryTip.TipType.INCOMPATIBLE_CHARGER,
-            BatteryTip.TipType.HIGH_DEVICE_USAGE};
+        BatteryTip.TipType.HIGH_DEVICE_USAGE
+    };
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private BatteryUsageStats mBatteryUsageStats;
-    @Mock
+
-    private PowerManager mPowerManager;
+    @Mock private PowerManager mPowerManager;
-    @Mock
+    @Mock private Intent mIntent;
-    private Intent mIntent;
+    @Mock private BatteryUtils mBatteryUtils;
-    @Mock
+    @Mock private BatteryInfo mBatteryInfo;
-    private BatteryUtils mBatteryUtils;
-    @Mock
-    private BatteryInfo mBatteryInfo;
     private Context mContext;
     private BatteryTipLoader mBatteryTipLoader;
 

tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPreferenceControllerTest.java

@@ -15,8 +15,7 @@
  */
 package com.android.settings.fuelgauge.batterytip;
 
-import static com.android.settings.fuelgauge.batterytip.tips.BatteryTip.TipType
+import static com.android.settings.fuelgauge.batterytip.tips.BatteryTip.TipType.SMART_BATTERY_MANAGER;
-        .SMART_BATTERY_MANAGER;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -31,8 +30,6 @@ import android.text.format.DateUtils;
 
 import androidx.preference.PreferenceScreen;
 
-import com.android.internal.logging.nano.MetricsProto;
-import com.android.settings.R;
 import com.android.settings.SettingsActivity;
 import com.android.settings.core.BasePreferenceController;
 import com.android.settings.core.InstrumentedPreferenceFragment;
@@ -58,16 +55,11 @@ public class BatteryTipPreferenceControllerTest {
     private static final String KEY_TIP = "key_battery_tip";
     private static final long AVERAGE_TIME_MS = DateUtils.HOUR_IN_MILLIS;
 
-    @Mock
+    @Mock private BatteryTipPreferenceController.BatteryTipListener mBatteryTipListener;
-    private BatteryTipPreferenceController.BatteryTipListener mBatteryTipListener;
+    @Mock private PreferenceScreen mPreferenceScreen;
-    @Mock
+    @Mock private BatteryTip mBatteryTip;
-    private PreferenceScreen mPreferenceScreen;
+    @Mock private SettingsActivity mSettingsActivity;
-    @Mock
+    @Mock private InstrumentedPreferenceFragment mFragment;
-    private BatteryTip mBatteryTip;
-    @Mock
-    private SettingsActivity mSettingsActivity;
-    @Mock
-    private InstrumentedPreferenceFragment mFragment;
 
     private Context mContext;
     private CardPreference mCardPreference;
@@ -147,13 +139,13 @@ public class BatteryTipPreferenceControllerTest {
 
     @Test
     public void getAvailabilityStatus_returnAvailableUnsearchable() {
-        assertThat(mBatteryTipPreferenceController.getAvailabilityStatus()).isEqualTo(
+        assertThat(mBatteryTipPreferenceController.getAvailabilityStatus())
-                BasePreferenceController.AVAILABLE_UNSEARCHABLE);
+                .isEqualTo(BasePreferenceController.AVAILABLE_UNSEARCHABLE);
     }
 
     private BatteryTipPreferenceController buildBatteryTipPreferenceController() {
-        final BatteryTipPreferenceController controller = new BatteryTipPreferenceController(
+        final BatteryTipPreferenceController controller =
-                mContext, KEY_PREF);
+                new BatteryTipPreferenceController(mContext, KEY_PREF);
         controller.setActivity(mSettingsActivity);
         controller.setFragment(mFragment);
         controller.setBatteryTipListener(mBatteryTipListener);

tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipUtilsTest.java

@@ -45,10 +45,8 @@ import java.util.ArrayList;
 @RunWith(RobolectricTestRunner.class)
 public class BatteryTipUtilsTest {
 
-    @Mock
+    @Mock private SettingsActivity mSettingsActivity;
-    private SettingsActivity mSettingsActivity;
+    @Mock private InstrumentedPreferenceFragment mFragment;
-    @Mock
-    private InstrumentedPreferenceFragment mFragment;
     private RestrictAppTip mRestrictAppTip;
     private LowBatteryTip mLowBatteryTip;
     private BatteryDefenderTip mBatteryDefenderTip;
@@ -61,42 +59,49 @@ public class BatteryTipUtilsTest {
         when(mSettingsActivity.getApplicationContext()).thenReturn(RuntimeEnvironment.application);
         when(mFragment.getContext()).thenReturn(RuntimeEnvironment.application);
         mRestrictAppTip = spy(new RestrictAppTip(BatteryTip.StateType.NEW, new ArrayList<>()));
-        mLowBatteryTip = spy(
+        mLowBatteryTip =
-                new LowBatteryTip(BatteryTip.StateType.NEW, false /* powerSaveModeOn */));
+                spy(new LowBatteryTip(BatteryTip.StateType.NEW, false /* powerSaveModeOn */));
-        mBatteryDefenderTip = spy(new BatteryDefenderTip(BatteryTip.StateType.NEW,
+        mBatteryDefenderTip =
-                false /* isPluggedIn */));
+                spy(new BatteryDefenderTip(BatteryTip.StateType.NEW, false /* isPluggedIn */));
     }
 
     @Test
     public void testGetActionForBatteryTip_typeRestrictStateNew_returnActionRestrict() {
         when(mRestrictAppTip.getState()).thenReturn(BatteryTip.StateType.NEW);
 
-        assertThat(BatteryTipUtils.getActionForBatteryTip(mRestrictAppTip, mSettingsActivity,
+        assertThat(
-                mFragment)).isInstanceOf(RestrictAppAction.class);
+                        BatteryTipUtils.getActionForBatteryTip(
+                                mRestrictAppTip, mSettingsActivity, mFragment))
+                .isInstanceOf(RestrictAppAction.class);
     }
 
     @Test
     public void testGetActionForBatteryTip_typeRestrictStateHandled_returnActionOpen() {
         when(mRestrictAppTip.getState()).thenReturn(BatteryTip.StateType.HANDLED);
 
-        assertThat(BatteryTipUtils.getActionForBatteryTip(mRestrictAppTip, mSettingsActivity,
+        assertThat(
-                mFragment)).isInstanceOf(OpenRestrictAppFragmentAction.class);
+                        BatteryTipUtils.getActionForBatteryTip(
+                                mRestrictAppTip, mSettingsActivity, mFragment))
+                .isInstanceOf(OpenRestrictAppFragmentAction.class);
     }
 
     @Test
     public void testGetActionForBatteryTip_typeLowBatteryStateNew_returnActionOpen() {
         when(mLowBatteryTip.getState()).thenReturn(BatteryTip.StateType.NEW);
 
-        assertThat(BatteryTipUtils.getActionForBatteryTip(mLowBatteryTip, mSettingsActivity,
+        assertThat(
-                mFragment)).isInstanceOf(OpenBatterySaverAction.class);
+                        BatteryTipUtils.getActionForBatteryTip(
+                                mLowBatteryTip, mSettingsActivity, mFragment))
+                .isInstanceOf(OpenBatterySaverAction.class);
     }
 
     @Test
-    public void
+    public void testGetActionForBatteryTip_typeBatteryDefenderStateNew_returnNullAction() {
-            testGetActionForBatteryTip_typeBatteryDefenderStateNew_returnNullAction() {
         when(mBatteryDefenderTip.getState()).thenReturn(BatteryTip.StateType.NEW);
 
-        assertThat(BatteryTipUtils.getActionForBatteryTip(mBatteryDefenderTip, mSettingsActivity,
+        assertThat(
-                mFragment)).isNull();
+                        BatteryTipUtils.getActionForBatteryTip(
+                                mBatteryDefenderTip, mSettingsActivity, mFragment))
+                .isNull();
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/HighUsageDataParserTest.java

@@ -24,9 +24,9 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
 
 import java.time.Duration;
-import org.robolectric.RobolectricTestRunner;
 
 @RunWith(RobolectricTestRunner.class)
 public class HighUsageDataParserTest {

tests/robotests/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentActionTest.java

@@ -39,10 +39,10 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
 
 import java.util.ArrayList;
 import java.util.List;
-import org.robolectric.RobolectricTestRunner;
 
 @RunWith(RobolectricTestRunner.class)
 public class OpenRestrictAppFragmentActionTest {
@@ -53,10 +53,8 @@ public class OpenRestrictAppFragmentActionTest {
     private static final int ANOMALY_BT = 1;
     private static final int METRICS_KEY = 1;
 
-    @Mock
+    @Mock private InstrumentedPreferenceFragment mFragment;
-    private InstrumentedPreferenceFragment mFragment;
+    @Mock private BatteryDatabaseManager mBatteryDatabaseManager;
-    @Mock
-    private BatteryDatabaseManager mBatteryDatabaseManager;
     private OpenRestrictAppFragmentAction mAction;
     private FakeFeatureFactory mFeatureFactory;
     private Context mContext;
@@ -67,19 +65,22 @@ public class OpenRestrictAppFragmentActionTest {
         MockitoAnnotations.initMocks(this);
         mContext = ApplicationProvider.getApplicationContext();
         mAppInfos = new ArrayList<>();
-        mAppInfos.add(new AppInfo.Builder()
+        mAppInfos.add(
-                .setPackageName(PACKAGE_NAME_1)
+                new AppInfo.Builder()
-                .addAnomalyType(ANOMALY_BT)
+                        .setPackageName(PACKAGE_NAME_1)
-                .build());
+                        .addAnomalyType(ANOMALY_BT)
-        mAppInfos.add(new AppInfo.Builder()
+                        .build());
-                .setPackageName(PACKAGE_NAME_2)
+        mAppInfos.add(
-                .addAnomalyType(ANOMALY_WAKEUP)
+                new AppInfo.Builder()
-                .build());
+                        .setPackageName(PACKAGE_NAME_2)
+                        .addAnomalyType(ANOMALY_WAKEUP)
+                        .build());
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         when(mFragment.getContext()).thenReturn(mContext);
 
-        mAction = new OpenRestrictAppFragmentAction(mFragment,
+        mAction =
-                new RestrictAppTip(BatteryTip.StateType.HANDLED, mAppInfos));
+                new OpenRestrictAppFragmentAction(
+                        mFragment, new RestrictAppTip(BatteryTip.StateType.HANDLED, mAppInfos));
         mAction.mBatteryDatabaseManager = mBatteryDatabaseManager;
     }
 
@@ -93,9 +94,12 @@ public class OpenRestrictAppFragmentActionTest {
     public void testHandlePositiveAction() {
         mAction.handlePositiveAction(METRICS_KEY);
 
-        verify(mFeatureFactory.metricsFeatureProvider).action(mContext,
+        verify(mFeatureFactory.metricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_TIP_OPEN_APP_RESTRICTION_PAGE, METRICS_KEY);
+                .action(
-        verify(mBatteryDatabaseManager).updateAnomalies(mAppInfos,
+                        mContext,
-                AnomalyDatabaseHelper.State.HANDLED);
+                        MetricsProto.MetricsEvent.ACTION_TIP_OPEN_APP_RESTRICTION_PAGE,
+                        METRICS_KEY);
+        verify(mBatteryDatabaseManager)
+                .updateAnomalies(mAppInfos, AnomalyDatabaseHelper.State.HANDLED);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/actions/RestrictAppActionTest.java

@@ -52,8 +52,7 @@ public class RestrictAppActionTest {
     private static final int ANOMALY_BT = 1;
     private static final int METRICS_KEY = 1;
 
-    @Mock
+    @Mock private BatteryUtils mBatteryUtils;
-    private BatteryUtils mBatteryUtils;
     private RestrictAppAction mRestrictAppAction;
     private FakeFeatureFactory mFeatureFactory;
 
@@ -62,20 +61,20 @@ public class RestrictAppActionTest {
         MockitoAnnotations.initMocks(this);
 
         final List<AppInfo> mAppInfos = new ArrayList<>();
-        mAppInfos.add(new AppInfo.Builder()
+        mAppInfos.add(new AppInfo.Builder().setUid(UID_1).setPackageName(PACKAGE_NAME_1).build());
-                .setUid(UID_1)
+        mAppInfos.add(
-                .setPackageName(PACKAGE_NAME_1)
+                new AppInfo.Builder()
-                .build());
+                        .setUid(UID_2)
-        mAppInfos.add(new AppInfo.Builder()
+                        .setPackageName(PACKAGE_NAME_2)
-                .setUid(UID_2)
+                        .addAnomalyType(ANOMALY_BT)
-                .setPackageName(PACKAGE_NAME_2)
+                        .addAnomalyType(ANOMALY_WAKEUP)
-                .addAnomalyType(ANOMALY_BT)
+                        .build());
-                .addAnomalyType(ANOMALY_WAKEUP)
-                .build());
         mFeatureFactory = FakeFeatureFactory.setupForTest();
 
-        mRestrictAppAction = new RestrictAppAction(RuntimeEnvironment.application,
+        mRestrictAppAction =
-                new RestrictAppTip(BatteryTip.StateType.NEW, mAppInfos));
+                new RestrictAppAction(
+                        RuntimeEnvironment.application,
+                        new RestrictAppTip(BatteryTip.StateType.NEW, mAppInfos));
         mRestrictAppAction.mBatteryUtils = mBatteryUtils;
     }
 
@@ -89,17 +88,28 @@ public class RestrictAppActionTest {
     public void testHandlePositiveAction() {
         mRestrictAppAction.handlePositiveAction(METRICS_KEY);
 
-        verify(mBatteryUtils)
+        verify(mBatteryUtils).setForceAppStandby(UID_1, PACKAGE_NAME_1, AppOpsManager.MODE_IGNORED);
-                .setForceAppStandby(UID_1, PACKAGE_NAME_1, AppOpsManager.MODE_IGNORED);
+        verify(mBatteryUtils).setForceAppStandby(UID_2, PACKAGE_NAME_2, AppOpsManager.MODE_IGNORED);
-        verify(mBatteryUtils)
+        verify(mFeatureFactory.metricsFeatureProvider)
-                .setForceAppStandby(UID_2, PACKAGE_NAME_2, AppOpsManager.MODE_IGNORED);
+                .action(
-        verify(mFeatureFactory.metricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+                        SettingsEnums.PAGE_UNKNOWN,
-                MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP, METRICS_KEY, PACKAGE_NAME_1, 0);
+                        MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP,
-        verify(mFeatureFactory.metricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+                        METRICS_KEY,
-                MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP, METRICS_KEY, PACKAGE_NAME_2,
+                        PACKAGE_NAME_1,
-                ANOMALY_WAKEUP);
+                        0);
-        verify(mFeatureFactory.metricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+        verify(mFeatureFactory.metricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP, METRICS_KEY, PACKAGE_NAME_2,
+                .action(
-                ANOMALY_BT);
+                        SettingsEnums.PAGE_UNKNOWN,
+                        MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP,
+                        METRICS_KEY,
+                        PACKAGE_NAME_2,
+                        ANOMALY_WAKEUP);
+        verify(mFeatureFactory.metricsFeatureProvider)
+                .action(
+                        SettingsEnums.PAGE_UNKNOWN,
+                        MetricsProto.MetricsEvent.ACTION_TIP_RESTRICT_APP,
+                        METRICS_KEY,
+                        PACKAGE_NAME_2,
+                        ANOMALY_BT);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/actions/UnrestrictAppActionTest.java

@@ -44,8 +44,7 @@ public class UnrestrictAppActionTest {
     private static final String PACKAGE_NAME_1 = "com.android.app1";
     private static final int METRICS_KEY = 1;
 
-    @Mock
+    @Mock private BatteryUtils mBatteryUtils;
-    private BatteryUtils mBatteryUtils;
     private UnrestrictAppAction mUnrestrictAppAction;
     private FakeFeatureFactory mFeatureFactory;
 
@@ -53,14 +52,14 @@ public class UnrestrictAppActionTest {
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
-        final AppInfo appInfo = new AppInfo.Builder()
+        final AppInfo appInfo =
-                .setUid(UID_1)
+                new AppInfo.Builder().setUid(UID_1).setPackageName(PACKAGE_NAME_1).build();
-                .setPackageName(PACKAGE_NAME_1)
-                .build();
         mFeatureFactory = FakeFeatureFactory.setupForTest();
 
-        mUnrestrictAppAction = new UnrestrictAppAction(RuntimeEnvironment.application,
+        mUnrestrictAppAction =
-                new UnrestrictAppTip(BatteryTip.StateType.NEW, appInfo));
+                new UnrestrictAppAction(
+                        RuntimeEnvironment.application,
+                        new UnrestrictAppTip(BatteryTip.StateType.NEW, appInfo));
         mUnrestrictAppAction.mBatteryUtils = mBatteryUtils;
     }
 
@@ -73,13 +72,13 @@ public class UnrestrictAppActionTest {
     public void testHandlePositiveAction() {
         mUnrestrictAppAction.handlePositiveAction(METRICS_KEY);
 
-        verify(mBatteryUtils)
+        verify(mBatteryUtils).setForceAppStandby(UID_1, PACKAGE_NAME_1, AppOpsManager.MODE_ALLOWED);
-                .setForceAppStandby(UID_1, PACKAGE_NAME_1, AppOpsManager.MODE_ALLOWED);
+        verify(mFeatureFactory.metricsFeatureProvider)
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+                .action(
-                SettingsEnums.PAGE_UNKNOWN,
+                        SettingsEnums.PAGE_UNKNOWN,
-                MetricsProto.MetricsEvent.ACTION_TIP_UNRESTRICT_APP,
+                        MetricsProto.MetricsEvent.ACTION_TIP_UNRESTRICT_APP,
-                METRICS_KEY,
+                        METRICS_KEY,
-                PACKAGE_NAME_1,
+                        PACKAGE_NAME_1,
-                0);
+                        0);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/BatteryDefenderDetectorTest.java

@@ -38,8 +38,7 @@ import org.robolectric.RobolectricTestRunner;
 @RunWith(RobolectricTestRunner.class)
 public class BatteryDefenderDetectorTest {
 
-    @Mock
+    @Mock private BatteryInfo mBatteryInfo;
-    private BatteryInfo mBatteryInfo;
     private BatteryDefenderDetector mBatteryDefenderDetector;
     private Context mContext;
 
@@ -53,8 +52,7 @@ public class BatteryDefenderDetectorTest {
 
         mContext = ApplicationProvider.getApplicationContext();
 
-        mBatteryDefenderDetector = new BatteryDefenderDetector(
+        mBatteryDefenderDetector = new BatteryDefenderDetector(mBatteryInfo, mContext);
-            mBatteryInfo, mContext);
 
         mFakeFeatureFactory = FakeFeatureFactory.setupForTest();
     }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/DockDefenderDetectorTest.java

@@ -59,25 +59,35 @@ public class DockDefenderDetectorTest {
         mBatteryInfo = new BatteryInfo();
         mBatteryInfo.pluggedStatus = BatteryManager.BATTERY_PLUGGED_DOCK;
         mDockDefenderDetector = new DockDefenderDetector(mBatteryInfo, mContext);
-        Intent intent = BatteryTestUtils.getCustomBatteryIntent(BatteryManager.BATTERY_PLUGGED_DOCK,
+        Intent intent =
-                50 /* level */, 100 /* scale */, BatteryManager.BATTERY_STATUS_CHARGING);
+                BatteryTestUtils.getCustomBatteryIntent(
-        doReturn(intent).when(mContext).registerReceiver(eq(null),
+                        BatteryManager.BATTERY_PLUGGED_DOCK,
-                refEq(new IntentFilter(Intent.ACTION_BATTERY_CHANGED)));
+                        50 /* level */,
+                        100 /* scale */,
+                        BatteryManager.BATTERY_STATUS_CHARGING);
+        doReturn(intent)
+                .when(mContext)
+                .registerReceiver(eq(null), refEq(new IntentFilter(Intent.ACTION_BATTERY_CHANGED)));
 
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS, 0);
+                mContext.getContentResolver(),
+                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS,
+                0);
         mFakeFeatureFactory = FakeFeatureFactory.setupForTest();
     }
 
     @Test
     public void testDetect_dockDefenderTemporarilyBypassed() {
-        Settings.Global.putInt(mContext.getContentResolver(),
+        Settings.Global.putInt(
-                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS, 1);
+                mContext.getContentResolver(),
+                BatteryUtils.SETTINGS_GLOBAL_DOCK_DEFENDER_BYPASS,
+                1);
 
         BatteryTip batteryTip = mDockDefenderDetector.detect();
 
         assertTrue(batteryTip instanceof DockDefenderTip);
-        assertEquals(((DockDefenderTip) batteryTip).getMode(),
+        assertEquals(
+                ((DockDefenderTip) batteryTip).getMode(),
                 BatteryUtils.DockDefenderMode.TEMPORARILY_BYPASSED);
     }
 
@@ -89,8 +99,8 @@ public class DockDefenderDetectorTest {
         BatteryTip batteryTip = mDockDefenderDetector.detect();
 
         assertTrue(batteryTip instanceof DockDefenderTip);
-        assertEquals(((DockDefenderTip) batteryTip).getMode(),
+        assertEquals(
-                BatteryUtils.DockDefenderMode.ACTIVE);
+                ((DockDefenderTip) batteryTip).getMode(), BatteryUtils.DockDefenderMode.ACTIVE);
     }
 
     @Test
@@ -101,7 +111,8 @@ public class DockDefenderDetectorTest {
         BatteryTip batteryTip = mDockDefenderDetector.detect();
 
         assertTrue(batteryTip instanceof DockDefenderTip);
-        assertEquals(((DockDefenderTip) batteryTip).getMode(),
+        assertEquals(
+                ((DockDefenderTip) batteryTip).getMode(),
                 BatteryUtils.DockDefenderMode.FUTURE_BYPASS);
     }
 
@@ -113,8 +124,8 @@ public class DockDefenderDetectorTest {
         BatteryTip batteryTip = mDockDefenderDetector.detect();
 
         assertTrue(batteryTip instanceof DockDefenderTip);
-        assertEquals(((DockDefenderTip) batteryTip).getMode(),
+        assertEquals(
-                BatteryUtils.DockDefenderMode.DISABLED);
+                ((DockDefenderTip) batteryTip).getMode(), BatteryUtils.DockDefenderMode.DISABLED);
     }
 
     @Test
@@ -124,8 +135,8 @@ public class DockDefenderDetectorTest {
         BatteryTip batteryTip = mDockDefenderDetector.detect();
 
         assertTrue(batteryTip instanceof DockDefenderTip);
-        assertEquals(((DockDefenderTip) batteryTip).getMode(),
+        assertEquals(
-                BatteryUtils.DockDefenderMode.DISABLED);
+                ((DockDefenderTip) batteryTip).getMode(), BatteryUtils.DockDefenderMode.DISABLED);
     }
 
     @Test
@@ -136,7 +147,7 @@ public class DockDefenderDetectorTest {
         BatteryTip batteryTip = mDockDefenderDetector.detect();
 
         assertTrue(batteryTip instanceof DockDefenderTip);
-        assertEquals(((DockDefenderTip) batteryTip).getMode(),
+        assertEquals(
-                BatteryUtils.DockDefenderMode.DISABLED);
+                ((DockDefenderTip) batteryTip).getMode(), BatteryUtils.DockDefenderMode.DISABLED);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/HighUsageDetectorTest.java

@@ -62,18 +62,12 @@ public class HighUsageDetectorTest {
     private static final double POWER_LOW = 10000;
 
     private Context mContext;
-    @Mock
+    @Mock private UidBatteryConsumer mHighBatteryConsumer;
-    private UidBatteryConsumer mHighBatteryConsumer;
+    @Mock private UidBatteryConsumer mLowBatteryConsumer;
-    @Mock
+    @Mock private UidBatteryConsumer mSystemBatteryConsumer;
-    private UidBatteryConsumer mLowBatteryConsumer;
+    @Mock private HighUsageDataParser mDataParser;
-    @Mock
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    private UidBatteryConsumer mSystemBatteryConsumer;
+    @Mock private BatteryStatsManager mBatteryStatsManager;
-    @Mock
-    private HighUsageDataParser mDataParser;
-    @Mock
-    private BatteryUsageStats mBatteryUsageStats;
-    @Mock
-    private BatteryStatsManager mBatteryStatsManager;
 
     private AppInfo mHighAppInfo;
     private AppInfo mLowAppInfo;
@@ -94,11 +88,17 @@ public class HighUsageDetectorTest {
         when(mBatteryStatsManager.getBatteryUsageStats(any(BatteryUsageStatsQuery.class)))
                 .thenReturn(mBatteryUsageStats);
 
-        mContext.sendStickyBroadcast(new Intent(Intent.ACTION_BATTERY_CHANGED)
+        mContext.sendStickyBroadcast(
-                .putExtra(BatteryManager.EXTRA_PLUGGED, 0));
+                new Intent(Intent.ACTION_BATTERY_CHANGED)
+                        .putExtra(BatteryManager.EXTRA_PLUGGED, 0));
 
-        mHighUsageDetector = spy(new HighUsageDetector(mContext, mPolicy, mBatteryUsageStats,
+        mHighUsageDetector =
-                mBatteryUtils.getBatteryInfo(TAG)));
+                spy(
+                        new HighUsageDetector(
+                                mContext,
+                                mPolicy,
+                                mBatteryUsageStats,
+                                mBatteryUtils.getBatteryInfo(TAG)));
         mHighUsageDetector.mBatteryUtils = mBatteryUtils;
         mHighUsageDetector.mDataParser = mDataParser;
         doNothing().when(mHighUsageDetector).parseBatteryData();
@@ -111,12 +111,8 @@ public class HighUsageDetectorTest {
         when(mBatteryUsageStats.getDischargePercentage()).thenReturn(100);
         when(mBatteryUsageStats.getConsumedPower()).thenReturn(POWER_HIGH + POWER_LOW);
 
-        mHighAppInfo = new AppInfo.Builder()
+        mHighAppInfo = new AppInfo.Builder().setUid(UID_HIGH).build();
-                .setUid(UID_HIGH)
+        mLowAppInfo = new AppInfo.Builder().setUid(UID_LOW).build();
-                .build();
-        mLowAppInfo = new AppInfo.Builder()
-                .setUid(UID_LOW)
-                .build();
 
         ArrayList<UidBatteryConsumer> consumers = new ArrayList<>();
         consumers.add(mSystemBatteryConsumer);

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/IncompatibleChargerDetectorTest.java

@@ -81,6 +81,6 @@ public final class IncompatibleChargerDetectorTest {
         when(mUsbPort.getStatus()).thenReturn(mUsbPortStatus);
         when(mUsbPort.supportsComplianceWarnings()).thenReturn(true);
         when(mUsbPortStatus.isConnected()).thenReturn(true);
-        when(mUsbPortStatus.getComplianceWarnings()).thenReturn(new int[]{1});
+        when(mUsbPortStatus.getComplianceWarnings()).thenReturn(new int[] {1});
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/LowBatteryDetectorTest.java

@@ -40,8 +40,7 @@ import java.util.concurrent.TimeUnit;
 @RunWith(RobolectricTestRunner.class)
 public class LowBatteryDetectorTest {
 
-    @Mock
+    @Mock private BatteryInfo mBatteryInfo;
-    private BatteryInfo mBatteryInfo;
     private BatteryTipPolicy mPolicy;
     private LowBatteryDetector mLowBatteryDetector;
     private Context mContext;
@@ -55,15 +54,16 @@ public class LowBatteryDetectorTest {
         ReflectionHelpers.setField(mPolicy, "lowBatteryEnabled", true);
         mBatteryInfo.discharging = true;
 
-        mLowBatteryDetector = new LowBatteryDetector(mContext, mPolicy, mBatteryInfo,
+        mLowBatteryDetector =
-                false /* isPowerSaveMode */);
+                new LowBatteryDetector(
+                        mContext, mPolicy, mBatteryInfo, false /* isPowerSaveMode */);
     }
 
     @Test
     public void testDetect_disabledByPolicy_tipInvisible() {
         ReflectionHelpers.setField(mPolicy, "lowBatteryEnabled", false);
-        mLowBatteryDetector = new LowBatteryDetector(mContext, mPolicy, mBatteryInfo,
+        mLowBatteryDetector =
-                true /* isPowerSaveMode */);
+                new LowBatteryDetector(mContext, mPolicy, mBatteryInfo, true /* isPowerSaveMode */);
 
         assertThat(mLowBatteryDetector.detect().isVisible()).isFalse();
     }
@@ -84,8 +84,8 @@ public class LowBatteryDetectorTest {
 
     @Test
     public void testDetect_batterySaverOn_tipInvisible() {
-        mLowBatteryDetector = new LowBatteryDetector(mContext, mPolicy, mBatteryInfo,
+        mLowBatteryDetector =
-                true /* isPowerSaveMode */);
+                new LowBatteryDetector(mContext, mPolicy, mBatteryInfo, true /* isPowerSaveMode */);
 
         assertThat(mLowBatteryDetector.detect().getState())
                 .isEqualTo(BatteryTip.StateType.INVISIBLE);

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/SmartBatteryDetectorTest.java

@@ -22,7 +22,6 @@ import static org.mockito.Mockito.spy;
 
 import android.content.ContentResolver;
 import android.content.Context;
-import android.os.PowerManager;
 import android.provider.Settings;
 
 import com.android.settings.fuelgauge.BatteryInfo;
@@ -49,8 +48,7 @@ public class SmartBatteryDetectorTest {
     private SmartBatteryDetector mSmartBatteryDetector;
     private BatteryTipPolicy mPolicy;
 
-    @Mock
+    @Mock private BatteryInfo mBatteryInfo;
-    private BatteryInfo mBatteryInfo;
 
     @Before
     public void setUp() {
@@ -59,8 +57,13 @@ public class SmartBatteryDetectorTest {
         mContext = RuntimeEnvironment.application;
         mContentResolver = mContext.getContentResolver();
         mPolicy = spy(new BatteryTipPolicy(mContext));
-        mSmartBatteryDetector = new SmartBatteryDetector(mContext, mPolicy, mBatteryInfo,
+        mSmartBatteryDetector =
-                mContentResolver, false /* isPowerSaveMode */);
+                new SmartBatteryDetector(
+                        mContext,
+                        mPolicy,
+                        mBatteryInfo,
+                        mContentResolver,
+                        false /* isPowerSaveMode */);
     }
 
     @Test
@@ -72,8 +75,8 @@ public class SmartBatteryDetectorTest {
 
     @Test
     public void testDetect_smartBatteryOff_tipVisible() {
-        Settings.Global.putInt(mContentResolver,
+        Settings.Global.putInt(
-                Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 0);
+                mContentResolver, Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 0);
         mBatteryInfo.batteryLevel = EXPECTED_BATTERY_LEVEL;
 
         assertThat(mSmartBatteryDetector.detect().isVisible()).isTrue();
@@ -81,30 +84,40 @@ public class SmartBatteryDetectorTest {
 
     @Test
     public void testDetect_batterySaverOn_tipInvisible() {
-        Settings.Global.putInt(mContentResolver,
+        Settings.Global.putInt(
-                Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 0);
+                mContentResolver, Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 0);
         mBatteryInfo.batteryLevel = EXPECTED_BATTERY_LEVEL;
-        mSmartBatteryDetector = new SmartBatteryDetector(mContext, mPolicy, mBatteryInfo,
+        mSmartBatteryDetector =
-                mContentResolver, true /* isPowerSaveMode */);
+                new SmartBatteryDetector(
+                        mContext,
+                        mPolicy,
+                        mBatteryInfo,
+                        mContentResolver,
+                        true /* isPowerSaveMode */);
 
         assertThat(mSmartBatteryDetector.detect().isVisible()).isFalse();
     }
 
     @Test
     public void testDetect_unexpectedBatteryLevel_tipInvisible() {
-        Settings.Global.putInt(mContentResolver,
+        Settings.Global.putInt(
-                Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 0);
+                mContentResolver, Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 0);
         mBatteryInfo.batteryLevel = UNEXPECTED_BATTERY_LEVEL;
-        mSmartBatteryDetector = new SmartBatteryDetector(mContext, mPolicy, mBatteryInfo,
+        mSmartBatteryDetector =
-                mContentResolver, true /* isPowerSaveMode */);
+                new SmartBatteryDetector(
+                        mContext,
+                        mPolicy,
+                        mBatteryInfo,
+                        mContentResolver,
+                        true /* isPowerSaveMode */);
 
         assertThat(mSmartBatteryDetector.detect().isVisible()).isFalse();
     }
 
     @Test
     public void testDetect_smartBatteryOn_tipInvisible() {
-        Settings.Global.putInt(mContentResolver,
+        Settings.Global.putInt(
-                Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 1);
+                mContentResolver, Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED, 1);
         mBatteryInfo.batteryLevel = EXPECTED_BATTERY_LEVEL;
 
         assertThat(mSmartBatteryDetector.detect().isVisible()).isFalse();

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryDefenderTipTest.java

@@ -17,9 +17,7 @@ package com.android.settings.fuelgauge.batterytip.tips;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -63,8 +61,8 @@ public class BatteryDefenderTipTest {
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mMetricsFeatureProvider = mFeatureFactory.metricsFeatureProvider;
         mContext = RuntimeEnvironment.application;
-        mBatteryDefenderTip = new BatteryDefenderTip(BatteryTip.StateType.NEW,
+        mBatteryDefenderTip =
-                false /* isPluggedIn */);
+                new BatteryDefenderTip(BatteryTip.StateType.NEW, false /* isPluggedIn */);
 
         when(mPreference.getContext()).thenReturn(mContext);
         when(mCardPreference.getContext()).thenReturn(mContext);
@@ -93,8 +91,8 @@ public class BatteryDefenderTipTest {
         mBatteryDefenderTip.updateState(mBatteryTip);
         mBatteryDefenderTip.log(mContext, mMetricsFeatureProvider);
 
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                SettingsEnums.ACTION_BATTERY_DEFENDER_TIP, mBatteryTip.mState);
+                .action(mContext, SettingsEnums.ACTION_BATTERY_DEFENDER_TIP, mBatteryTip.mState);
     }
 
     @Test
@@ -131,8 +129,8 @@ public class BatteryDefenderTipTest {
 
     @Test
     public void updatePreference_whenCharging_setPrimaryButtonVisibleToBeTrue() {
-        mBatteryDefenderTip = new BatteryDefenderTip(BatteryTip.StateType.NEW,
+        mBatteryDefenderTip =
-                true /* isPluggedIn */);
+                new BatteryDefenderTip(BatteryTip.StateType.NEW, true /* isPluggedIn */);
 
         mBatteryDefenderTip.updatePreference(mCardPreference);
 

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryTipTest.java

@@ -45,8 +45,7 @@ public class BatteryTipTest {
 
     private static final String TITLE = "title";
     private static final String SUMMARY = "summary";
-    @DrawableRes
+    @DrawableRes private static final int ICON_ID = R.drawable.ic_fingerprint;
-    private static final int ICON_ID = R.drawable.ic_fingerprint;
 
     private Context mContext;
     private TestBatteryTip mBatteryTip;
@@ -86,8 +85,10 @@ public class BatteryTipTest {
     @Test
     public void updatePreference_resetLayoutState() {
         mContext.setTheme(R.style.Theme_Settings);
-        PreferenceViewHolder holder = PreferenceViewHolder.createInstanceForTests(
+        PreferenceViewHolder holder =
-                View.inflate(mContext, R.layout.card_preference_layout, /* parent= */ null));
+                PreferenceViewHolder.createInstanceForTests(
+                        View.inflate(
+                                mContext, R.layout.card_preference_layout, /* parent= */ null));
         CardPreference cardPreference = new CardPreference(mContext);
         cardPreference.onBindViewHolder(holder);
         cardPreference.setPrimaryButtonVisible(true);
@@ -113,9 +114,7 @@ public class BatteryTipTest {
         assertThat(mBatteryTip.toString()).isEqualTo("type=6 state=0");
     }
 
-    /**
+    /** Used to test the non abstract methods in {@link TestBatteryTip} */
-     * Used to test the non abstract methods in {@link TestBatteryTip}
-     */
     public static class TestBatteryTip extends BatteryTip {
         TestBatteryTip() {
             super(TipType.SUMMARY, StateType.NEW, true);
@@ -150,14 +149,15 @@ public class BatteryTipTest {
             // do nothing
         }
 
-        public final Parcelable.Creator CREATOR = new Parcelable.Creator() {
+        public final Parcelable.Creator CREATOR =
-            public BatteryTip createFromParcel(Parcel in) {
+                new Parcelable.Creator() {
-                return new TestBatteryTip(in);
+                    public BatteryTip createFromParcel(Parcel in) {
-            }
+                        return new TestBatteryTip(in);
+                    }
 
-            public BatteryTip[] newArray(int size) {
+                    public BatteryTip[] newArray(int size) {
-                return new TestBatteryTip[size];
+                        return new TestBatteryTip[size];
-            }
+                    }
-        };
+                };
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/DockDefenderTipTest.java

@@ -54,10 +54,8 @@ public class DockDefenderTipTest {
     private FakeFeatureFactory mFeatureFactory;
     private MetricsFeatureProvider mMetricsFeatureProvider;
 
-    @Mock
+    @Mock private Preference mPreference;
-    private Preference mPreference;
+    @Mock private CardPreference mCardPreference;
-    @Mock
-    private CardPreference mCardPreference;
 
     @Before
     public void setUp() {
@@ -67,14 +65,18 @@ public class DockDefenderTipTest {
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mMetricsFeatureProvider = mFeatureFactory.metricsFeatureProvider;
 
-        mDockDefenderTipFutureBypass = new DockDefenderTip(BatteryTip.StateType.NEW,
+        mDockDefenderTipFutureBypass =
-                BatteryUtils.DockDefenderMode.FUTURE_BYPASS);
+                new DockDefenderTip(
-        mDockDefenderTipActive = new DockDefenderTip(BatteryTip.StateType.NEW,
+                        BatteryTip.StateType.NEW, BatteryUtils.DockDefenderMode.FUTURE_BYPASS);
-                BatteryUtils.DockDefenderMode.ACTIVE);
+        mDockDefenderTipActive =
-        mDockDefenderTipTemporarilyBypassed = new DockDefenderTip(BatteryTip.StateType.NEW,
+                new DockDefenderTip(BatteryTip.StateType.NEW, BatteryUtils.DockDefenderMode.ACTIVE);
-                BatteryUtils.DockDefenderMode.TEMPORARILY_BYPASSED);
+        mDockDefenderTipTemporarilyBypassed =
-        mDockDefenderTipDisabled = new DockDefenderTip(BatteryTip.StateType.INVISIBLE,
+                new DockDefenderTip(
-                BatteryUtils.DockDefenderMode.DISABLED);
+                        BatteryTip.StateType.NEW,
+                        BatteryUtils.DockDefenderMode.TEMPORARILY_BYPASSED);
+        mDockDefenderTipDisabled =
+                new DockDefenderTip(
+                        BatteryTip.StateType.INVISIBLE, BatteryUtils.DockDefenderMode.DISABLED);
 
         doReturn(mContext).when(mPreference).getContext();
         doReturn(mContext).when(mCardPreference).getContext();
@@ -82,69 +84,78 @@ public class DockDefenderTipTest {
 
     @Test
     public void testGetTitle() {
-        assertThat(mDockDefenderTipFutureBypass.getTitle(mContext).toString()).isEqualTo(
+        assertThat(mDockDefenderTipFutureBypass.getTitle(mContext).toString())
-                mContext.getString(R.string.battery_tip_dock_defender_future_bypass_title));
+                .isEqualTo(
-        assertThat(mDockDefenderTipActive.getTitle(mContext).toString()).isEqualTo(
+                        mContext.getString(R.string.battery_tip_dock_defender_future_bypass_title));
-                mContext.getString(R.string.battery_tip_dock_defender_active_title));
+        assertThat(mDockDefenderTipActive.getTitle(mContext).toString())
-        assertThat(mDockDefenderTipTemporarilyBypassed.getTitle(mContext).toString()).isEqualTo(
+                .isEqualTo(mContext.getString(R.string.battery_tip_dock_defender_active_title));
-                mContext.getString(R.string.battery_tip_dock_defender_temporarily_bypassed_title));
+        assertThat(mDockDefenderTipTemporarilyBypassed.getTitle(mContext).toString())
+                .isEqualTo(
+                        mContext.getString(
+                                R.string.battery_tip_dock_defender_temporarily_bypassed_title));
         assertThat(mDockDefenderTipDisabled.getTitle(mContext)).isNull();
     }
 
     @Test
     public void testGetSummary() {
-        assertThat(mDockDefenderTipFutureBypass.getSummary(mContext).toString()).isEqualTo(
+        assertThat(mDockDefenderTipFutureBypass.getSummary(mContext).toString())
-                mContext.getString(R.string.battery_tip_dock_defender_future_bypass_summary));
+                .isEqualTo(
-        assertThat(mDockDefenderTipActive.getSummary(mContext).toString()).isEqualTo(
+                        mContext.getString(
-                mContext.getString(R.string.battery_tip_dock_defender_active_summary));
+                                R.string.battery_tip_dock_defender_future_bypass_summary));
-        assertThat(mDockDefenderTipTemporarilyBypassed.getSummary(mContext).toString()).isEqualTo(
+        assertThat(mDockDefenderTipActive.getSummary(mContext).toString())
-                mContext.getString(
+                .isEqualTo(mContext.getString(R.string.battery_tip_dock_defender_active_summary));
-                        R.string.battery_tip_dock_defender_temporarily_bypassed_summary));
+        assertThat(mDockDefenderTipTemporarilyBypassed.getSummary(mContext).toString())
+                .isEqualTo(
+                        mContext.getString(
+                                R.string.battery_tip_dock_defender_temporarily_bypassed_summary));
         assertThat(mDockDefenderTipDisabled.getSummary(mContext)).isNull();
     }
 
     @Test
     public void testGetIconId_dockDefenderActive_getProtectedIcon() {
-        assertThat(mDockDefenderTipActive.getIconId()).isEqualTo(
+        assertThat(mDockDefenderTipActive.getIconId())
-                R.drawable.ic_battery_status_protected_24dp);
+                .isEqualTo(R.drawable.ic_battery_status_protected_24dp);
     }
 
     @Test
     public void testGetIconId_dockDefenderNotActive_getUntriggeredIcon() {
-        assertThat(mDockDefenderTipFutureBypass.getIconId()).isEqualTo(
+        assertThat(mDockDefenderTipFutureBypass.getIconId())
-                R.drawable.ic_battery_dock_defender_untriggered_24dp);
+                .isEqualTo(R.drawable.ic_battery_dock_defender_untriggered_24dp);
-        assertThat(mDockDefenderTipTemporarilyBypassed.getIconId()).isEqualTo(
+        assertThat(mDockDefenderTipTemporarilyBypassed.getIconId())
-                R.drawable.ic_battery_dock_defender_untriggered_24dp);
+                .isEqualTo(R.drawable.ic_battery_dock_defender_untriggered_24dp);
-        assertThat(mDockDefenderTipDisabled.getIconId()).isEqualTo(
+        assertThat(mDockDefenderTipDisabled.getIconId())
-                R.drawable.ic_battery_dock_defender_untriggered_24dp);
+                .isEqualTo(R.drawable.ic_battery_dock_defender_untriggered_24dp);
     }
 
     @Test
     public void testUpdateState() {
         mDockDefenderTipTemporarilyBypassed.updateState(mDockDefenderTipDisabled);
 
-        assertThat(mDockDefenderTipTemporarilyBypassed.getState()).isEqualTo(
+        assertThat(mDockDefenderTipTemporarilyBypassed.getState())
-                BatteryTip.StateType.INVISIBLE);
+                .isEqualTo(BatteryTip.StateType.INVISIBLE);
-        assertThat(mDockDefenderTipTemporarilyBypassed.getMode()).isEqualTo(
+        assertThat(mDockDefenderTipTemporarilyBypassed.getMode())
-                BatteryUtils.DockDefenderMode.DISABLED);
+                .isEqualTo(BatteryUtils.DockDefenderMode.DISABLED);
     }
 
     @Test
     public void testLog() {
         mDockDefenderTipActive.log(mContext, mMetricsFeatureProvider);
 
-        verify(mMetricsFeatureProvider).action(mContext, SettingsEnums.ACTION_DOCK_DEFENDER_TIP,
+        verify(mMetricsFeatureProvider)
-                mDockDefenderTipActive.getState());
+                .action(
+                        mContext,
+                        SettingsEnums.ACTION_DOCK_DEFENDER_TIP,
+                        mDockDefenderTipActive.getState());
     }
 
-
     @Test
     public void testUpdatePreference_dockDefenderTipFutureBypass() {
         mDockDefenderTipFutureBypass.updatePreference(mCardPreference);
 
         verify(mCardPreference).setPrimaryButtonVisible(true);
-        verify(mCardPreference).setPrimaryButtonText(
+        verify(mCardPreference)
-                mContext.getString(R.string.battery_tip_charge_to_full_button));
+                .setPrimaryButtonText(
+                        mContext.getString(R.string.battery_tip_charge_to_full_button));
         verifySecondaryButton();
     }
 
@@ -153,8 +164,9 @@ public class DockDefenderTipTest {
         mDockDefenderTipActive.updatePreference(mCardPreference);
 
         verify(mCardPreference).setPrimaryButtonVisible(true);
-        verify(mCardPreference).setPrimaryButtonText(
+        verify(mCardPreference)
-                mContext.getString(R.string.battery_tip_charge_to_full_button));
+                .setPrimaryButtonText(
+                        mContext.getString(R.string.battery_tip_charge_to_full_button));
         verifySecondaryButton();
     }
 
@@ -170,8 +182,10 @@ public class DockDefenderTipTest {
     private void verifySecondaryButton() {
         verify(mCardPreference).setSecondaryButtonText(mContext.getString(R.string.learn_more));
         verify(mCardPreference).setSecondaryButtonVisible(true);
-        verify(mCardPreference).setSecondaryButtonContentDescription(mContext.getString(
+        final String expectedContent =
-                R.string.battery_tip_limited_temporarily_sec_button_content_description));
+                mContext.getString(
+                        R.string.battery_tip_limited_temporarily_sec_button_content_description);
+        verify(mCardPreference).setSecondaryButtonContentDescription(expectedContent);
     }
 
     @Test
@@ -182,9 +196,11 @@ public class DockDefenderTipTest {
     }
 
     private String getLastErrorLog() {
-        return ShadowLog.getLogsForTag(DockDefenderTip.class.getSimpleName()).stream().filter(
+        return ShadowLog.getLogsForTag(DockDefenderTip.class.getSimpleName()).stream()
-                log -> log.type == Log.ERROR).reduce((first, second) -> second).orElse(
+                .filter(log -> log.type == Log.ERROR)
-                createErrorLog("No Error Log")).msg;
+                .reduce((first, second) -> second)
+                .orElse(createErrorLog("No Error Log"))
+                .msg;
     }
 
     private ShadowLog.LogItem createErrorLog(String msg) {

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/HighUsageTipTest.java

@@ -45,8 +45,7 @@ public class HighUsageTipTest {
     private static final long SCREEN_TIME = 30 * DateUtils.MINUTE_IN_MILLIS;
     private static final long LAST_FULL_CHARGE_TIME = 20 * DateUtils.MINUTE_IN_MILLIS;
 
-    @Mock
+    @Mock private MetricsFeatureProvider mMetricsFeatureProvider;
-    private MetricsFeatureProvider mMetricsFeatureProvider;
     private Context mContext;
     private HighUsageTip mBatteryTip;
     private List<AppInfo> mUsageAppList;
@@ -57,10 +56,11 @@ public class HighUsageTipTest {
 
         mContext = RuntimeEnvironment.application;
         mUsageAppList = new ArrayList<>();
-        mUsageAppList.add(new AppInfo.Builder()
+        mUsageAppList.add(
-                .setPackageName(PACKAGE_NAME)
+                new AppInfo.Builder()
-                .setScreenOnTimeMs(SCREEN_TIME)
+                        .setPackageName(PACKAGE_NAME)
-                .build());
+                        .setScreenOnTimeMs(SCREEN_TIME)
+                        .build());
         mBatteryTip = new HighUsageTip(LAST_FULL_CHARGE_TIME, mUsageAppList);
     }
 
@@ -86,19 +86,25 @@ public class HighUsageTipTest {
 
     @Test
     public void toString_containsAppData() {
-        assertThat(mBatteryTip.toString()).isEqualTo(
+        assertThat(mBatteryTip.toString())
-                "type=2 state=0 { packageName=com.android.app,anomalyTypes={},screenTime=1800000 "
+                .isEqualTo(
-                        + "}");
+                        "type=2 state=0 {"
+                            + " packageName=com.android.app,anomalyTypes={},screenTime=1800000 }");
     }
 
     @Test
     public void testLog_logAppInfo() {
         mBatteryTip.log(mContext, mMetricsFeatureProvider);
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP, BatteryTip.StateType.NEW);
+                .action(
+                        mContext,
+                        MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP,
+                        BatteryTip.StateType.NEW);
 
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP_LIST,
+                .action(
-                PACKAGE_NAME);
+                        mContext,
+                        MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP_LIST,
+                        PACKAGE_NAME);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/IncompatibleChargerTipTest.java

@@ -17,16 +17,11 @@ package com.android.settings.fuelgauge.batterytip.tips;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.app.settings.SettingsEnums;
 import android.content.Context;
-import android.content.Intent;
 import android.util.Log;
 
 import androidx.preference.Preference;
@@ -72,20 +67,19 @@ public final class IncompatibleChargerTipTest {
 
     @Test
     public void getTitle_showTitle() {
-        assertThat(mIncompatibleChargerTip.getTitle(mContext)).isEqualTo(
+        assertThat(mIncompatibleChargerTip.getTitle(mContext))
-                mContext.getString(R.string.battery_tip_incompatible_charging_title));
+                .isEqualTo(mContext.getString(R.string.battery_tip_incompatible_charging_title));
     }
 
     @Test
     public void getSummary_showSummary() {
-        assertThat(mIncompatibleChargerTip.getSummary(mContext)).isEqualTo(
+        assertThat(mIncompatibleChargerTip.getSummary(mContext))
-                mContext.getString(R.string.battery_tip_incompatible_charging_message));
+                .isEqualTo(mContext.getString(R.string.battery_tip_incompatible_charging_message));
     }
 
     @Test
     public void getIcon_showIcon() {
-        assertThat(mIncompatibleChargerTip.getIconId())
+        assertThat(mIncompatibleChargerTip.getIconId()).isEqualTo(R.drawable.ic_battery_charger);
-                .isEqualTo(R.drawable.ic_battery_charger);
     }
 
     @Test
@@ -93,8 +87,11 @@ public final class IncompatibleChargerTipTest {
         mIncompatibleChargerTip.updateState(mBatteryTip);
         mIncompatibleChargerTip.log(mContext, mMetricsFeatureProvider);
 
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                SettingsEnums.ACTION_INCOMPATIBLE_CHARGING_TIP, mBatteryTip.mState);
+                .action(
+                        mContext,
+                        SettingsEnums.ACTION_INCOMPATIBLE_CHARGING_TIP,
+                        mBatteryTip.mState);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/LowBatteryTipTest.java

@@ -37,8 +37,7 @@ import org.robolectric.RuntimeEnvironment;
 @RunWith(RobolectricTestRunner.class)
 public class LowBatteryTipTest {
 
-    @Mock
+    @Mock private MetricsFeatureProvider mMetricsFeatureProvider;
-    private MetricsFeatureProvider mMetricsFeatureProvider;
     private Context mContext;
     private LowBatteryTip mLowBatteryTip;
 
@@ -58,25 +57,25 @@ public class LowBatteryTipTest {
         final LowBatteryTip parcelTip = new LowBatteryTip(parcel);
 
         assertThat(parcelTip.isPowerSaveModeOn()).isFalse();
-        assertThat(parcelTip.getSummary(mContext)).isEqualTo(
+        assertThat(parcelTip.getSummary(mContext))
-                mContext.getString(R.string.battery_tip_low_battery_summary));
+                .isEqualTo(mContext.getString(R.string.battery_tip_low_battery_summary));
     }
 
     @Test
     public void updateState_stateNew_showExpectedInformation() {
         mLowBatteryTip.mState = BatteryTip.StateType.NEW;
 
-        assertThat(mLowBatteryTip.getTitle(mContext)).isEqualTo(
+        assertThat(mLowBatteryTip.getTitle(mContext))
-                mContext.getString(R.string.battery_tip_low_battery_title));
+                .isEqualTo(mContext.getString(R.string.battery_tip_low_battery_title));
-        assertThat(mLowBatteryTip.getSummary(mContext)).isEqualTo(
+        assertThat(mLowBatteryTip.getSummary(mContext))
-                mContext.getString(R.string.battery_tip_low_battery_summary));
+                .isEqualTo(mContext.getString(R.string.battery_tip_low_battery_summary));
         assertThat(mLowBatteryTip.getIconId()).isEqualTo(R.drawable.ic_battery_saver_accent_24dp);
     }
 
     @Test
     public void updateState_powerSaveModeOn_notShowTipItem() {
-        final LowBatteryTip tip = new LowBatteryTip(
+        final LowBatteryTip tip =
-                BatteryTip.StateType.NEW, true /* powerSaveModeOn */);
+                new LowBatteryTip(BatteryTip.StateType.NEW, true /* powerSaveModeOn */);
 
         tip.updateState(tip);
 
@@ -87,7 +86,10 @@ public class LowBatteryTipTest {
     public void log_lowBatteryActionWithCorrectState() {
         mLowBatteryTip.log(mContext, mMetricsFeatureProvider);
 
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_LOW_BATTERY_TIP, BatteryTip.StateType.NEW);
+                .action(
+                        mContext,
+                        MetricsProto.MetricsEvent.ACTION_LOW_BATTERY_TIP,
+                        BatteryTip.StateType.NEW);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/RestrictAppTipTest.java

@@ -65,12 +65,9 @@ public class RestrictAppTipTest {
     private List<AppInfo> mUsageAppList;
     private AppInfo mAppInfo;
     private AppInfo mUninstallAppInfo;
-    @Mock
+    @Mock private ApplicationInfo mApplicationInfo;
-    private ApplicationInfo mApplicationInfo;
+    @Mock private PackageManager mPackageManager;
-    @Mock
+    @Mock private MetricsFeatureProvider mMetricsFeatureProvider;
-    private PackageManager mPackageManager;
-    @Mock
-    private MetricsFeatureProvider mMetricsFeatureProvider;
 
     @Before
     public void setUp() throws Exception {
@@ -79,28 +76,35 @@ public class RestrictAppTipTest {
         mContext = spy(RuntimeEnvironment.application);
         doReturn(mContext).when(mContext).getApplicationContext();
         doReturn(mPackageManager).when(mContext).getPackageManager();
-        doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfo(PACKAGE_NAME,
+        doReturn(mApplicationInfo)
-                PackageManager.MATCH_DISABLED_COMPONENTS | PackageManager.MATCH_ANY_USER);
+                .when(mPackageManager)
-        doThrow(new PackageManager.NameNotFoundException()).when(mPackageManager)
+                .getApplicationInfo(
-                .getApplicationInfo(UNINSTALL_PACKAGE_NAME,
+                        PACKAGE_NAME,
+                        PackageManager.MATCH_DISABLED_COMPONENTS | PackageManager.MATCH_ANY_USER);
+        doThrow(new PackageManager.NameNotFoundException())
+                .when(mPackageManager)
+                .getApplicationInfo(
+                        UNINSTALL_PACKAGE_NAME,
                         PackageManager.MATCH_DISABLED_COMPONENTS | PackageManager.MATCH_ANY_USER);
         doReturn(DISPLAY_NAME).when(mApplicationInfo).loadLabel(mPackageManager);
 
-        mAppInfo = new AppInfo.Builder()
+        mAppInfo =
-                .setPackageName(PACKAGE_NAME)
+                new AppInfo.Builder()
-                .addAnomalyType(ANOMALY_WAKEUP)
+                        .setPackageName(PACKAGE_NAME)
-                .addAnomalyType(ANOMALY_WAKELOCK)
+                        .addAnomalyType(ANOMALY_WAKEUP)
-                .build();
+                        .addAnomalyType(ANOMALY_WAKELOCK)
-        mUninstallAppInfo = new AppInfo.Builder()
+                        .build();
-                .setPackageName(UNINSTALL_PACKAGE_NAME)
+        mUninstallAppInfo =
-                .addAnomalyType(ANOMALY_WAKEUP)
+                new AppInfo.Builder()
-                .build();
+                        .setPackageName(UNINSTALL_PACKAGE_NAME)
+                        .addAnomalyType(ANOMALY_WAKEUP)
+                        .build();
         mUsageAppList = new ArrayList<>();
         mUsageAppList.add(mAppInfo);
         mNewBatteryTip = new RestrictAppTip(BatteryTip.StateType.NEW, mUsageAppList);
         mHandledBatteryTip = new RestrictAppTip(BatteryTip.StateType.HANDLED, mUsageAppList);
-        mInvisibleBatteryTip = new RestrictAppTip(BatteryTip.StateType.INVISIBLE,
+        mInvisibleBatteryTip =
-                new ArrayList<>());
+                new RestrictAppTip(BatteryTip.StateType.INVISIBLE, new ArrayList<>());
     }
 
     @After
@@ -149,8 +153,9 @@ public class RestrictAppTipTest {
     @Test
     public void getSummary_oneAppHandled_showHandledSummary() {
         assertThat(mHandledBatteryTip.getSummary(mContext).toString())
-                .isEqualTo(StringUtil.getIcuPluralsString(mContext, 1,
+                .isEqualTo(
-                        R.string.battery_tip_restrict_handled_summary));
+                        StringUtil.getIcuPluralsString(
+                                mContext, 1, R.string.battery_tip_restrict_handled_summary));
     }
 
     @Test
@@ -158,8 +163,9 @@ public class RestrictAppTipTest {
         mUsageAppList.add(new AppInfo.Builder().build());
         mHandledBatteryTip = new RestrictAppTip(BatteryTip.StateType.HANDLED, mUsageAppList);
         assertThat(mHandledBatteryTip.getSummary(mContext))
-                .isEqualTo(StringUtil.getIcuPluralsString(mContext, 2,
+                .isEqualTo(
-                        R.string.battery_tip_restrict_handled_summary));
+                        StringUtil.getIcuPluralsString(
+                                mContext, 2, R.string.battery_tip_restrict_handled_summary));
     }
 
     @Test
@@ -217,35 +223,47 @@ public class RestrictAppTipTest {
 
     @Test
     public void toString_containsAppData() {
-        assertThat(mNewBatteryTip.toString()).isEqualTo(
+        assertThat(mNewBatteryTip.toString())
-                "type=1 state=0 { packageName=com.android.app,anomalyTypes={0, 1},screenTime=0 }");
+                .isEqualTo(
+                        "type=1 state=0 { packageName=com.android.app,anomalyTypes={0,"
+                            + " 1},screenTime=0 }");
     }
 
     @Test
     public void testLog_stateNew_logAppInfo() {
         mNewBatteryTip.log(mContext, mMetricsFeatureProvider);
 
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP, BatteryTip.StateType.NEW);
+                .action(
-        verify(mMetricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+                        mContext,
-                MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP_LIST,
+                        MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP,
-                SettingsEnums.PAGE_UNKNOWN,
+                        BatteryTip.StateType.NEW);
-                PACKAGE_NAME,
+        verify(mMetricsFeatureProvider)
-                ANOMALY_WAKEUP);
+                .action(
-        verify(mMetricsFeatureProvider).action(SettingsEnums.PAGE_UNKNOWN,
+                        SettingsEnums.PAGE_UNKNOWN,
-                MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP_LIST,
+                        MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP_LIST,
-                SettingsEnums.PAGE_UNKNOWN,
+                        SettingsEnums.PAGE_UNKNOWN,
-                PACKAGE_NAME,
+                        PACKAGE_NAME,
-                ANOMALY_WAKELOCK);
+                        ANOMALY_WAKEUP);
+        verify(mMetricsFeatureProvider)
+                .action(
+                        SettingsEnums.PAGE_UNKNOWN,
+                        MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP_LIST,
+                        SettingsEnums.PAGE_UNKNOWN,
+                        PACKAGE_NAME,
+                        ANOMALY_WAKELOCK);
     }
 
     @Test
     public void testLog_stateHandled_doNotLogAppInfo() {
         mHandledBatteryTip.log(mContext, mMetricsFeatureProvider);
 
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP, BatteryTip.StateType.HANDLED);
+                .action(
-        verify(mMetricsFeatureProvider, never()).action(
+                        mContext,
-                anyInt(), anyInt(), anyInt(), anyString(), anyInt());
+                        MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP,
+                        BatteryTip.StateType.HANDLED);
+        verify(mMetricsFeatureProvider, never())
+                .action(anyInt(), anyInt(), anyInt(), anyString(), anyInt());
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/SmartBatteryTipTest.java

@@ -33,8 +33,7 @@ import org.robolectric.RuntimeEnvironment;
 @RunWith(RobolectricTestRunner.class)
 public class SmartBatteryTipTest {
 
-    @Mock
+    @Mock private MetricsFeatureProvider mMetricsFeatureProvider;
-    private MetricsFeatureProvider mMetricsFeatureProvider;
     private Context mContext;
     private SmartBatteryTip mSmartBatteryTip;
 
@@ -50,7 +49,10 @@ public class SmartBatteryTipTest {
     public void testLog() {
         mSmartBatteryTip.log(mContext, mMetricsFeatureProvider);
 
-        verify(mMetricsFeatureProvider).action(mContext,
+        verify(mMetricsFeatureProvider)
-                MetricsProto.MetricsEvent.ACTION_SMART_BATTERY_TIP, BatteryTip.StateType.NEW);
+                .action(
+                        mContext,
+                        MetricsProto.MetricsEvent.ACTION_SMART_BATTERY_TIP,
+                        BatteryTip.StateType.NEW);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/AnomalyEventWrapperTest.java

@@ -45,19 +45,18 @@ public class AnomalyEventWrapperTest {
 
     @Test
     public void getDismissRecordKey_returnExpectedResult() {
-        mAnomalyEventWrapper = new AnomalyEventWrapper(mContext,
+        mAnomalyEventWrapper =
-                BatteryTestUtils.createAdaptiveBrightnessAnomalyEvent());
+                new AnomalyEventWrapper(
-        assertThat(mAnomalyEventWrapper.getDismissRecordKey())
+                        mContext, BatteryTestUtils.createAdaptiveBrightnessAnomalyEvent());
-                .isEqualTo("KEY_BRIGHTNESS");
+        assertThat(mAnomalyEventWrapper.getDismissRecordKey()).isEqualTo("KEY_BRIGHTNESS");
 
-        mAnomalyEventWrapper = new AnomalyEventWrapper(mContext,
+        mAnomalyEventWrapper =
-                BatteryTestUtils.createScreenTimeoutAnomalyEvent());
+                new AnomalyEventWrapper(
-        assertThat(mAnomalyEventWrapper.getDismissRecordKey())
+                        mContext, BatteryTestUtils.createScreenTimeoutAnomalyEvent());
-                .isEqualTo("KEY_SCREEN_TIMEOUT");
+        assertThat(mAnomalyEventWrapper.getDismissRecordKey()).isEqualTo("KEY_SCREEN_TIMEOUT");
 
-        mAnomalyEventWrapper = new AnomalyEventWrapper(mContext,
+        mAnomalyEventWrapper =
-                BatteryTestUtils.createAppAnomalyEvent());
+                new AnomalyEventWrapper(mContext, BatteryTestUtils.createAppAnomalyEvent());
-        assertThat(mAnomalyEventWrapper.getDismissRecordKey())
+        assertThat(mAnomalyEventWrapper.getDismissRecordKey()).isEqualTo("KEY_APP_1");
-                .isEqualTo("KEY_APP_1");
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceControllerTest.java

@@ -66,22 +66,14 @@ import java.util.TimeZone;
 
 @RunWith(RobolectricTestRunner.class)
 public final class BatteryChartPreferenceControllerTest {
-    @Mock
+    @Mock private Intent mIntent;
-    private Intent mIntent;
+    @Mock private UserManager mUserManager;
-    @Mock
+    @Mock private SettingsActivity mSettingsActivity;
-    private UserManager mUserManager;
+    @Mock private TextView mChartSummaryTextView;
-    @Mock
+    @Mock private BatteryChartView mDailyChartView;
-    private SettingsActivity mSettingsActivity;
+    @Mock private BatteryChartView mHourlyChartView;
-    @Mock
+    @Mock private ViewPropertyAnimator mViewPropertyAnimator;
-    private TextView mChartSummaryTextView;
+    @Mock private LinearLayout.LayoutParams mLayoutParams;
-    @Mock
-    private BatteryChartView mDailyChartView;
-    @Mock
-    private BatteryChartView mHourlyChartView;
-    @Mock
-    private ViewPropertyAnimator mViewPropertyAnimator;
-    @Mock
-    private LinearLayout.LayoutParams mLayoutParams;
 
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
@@ -97,11 +89,9 @@ public final class BatteryChartPreferenceControllerTest {
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mContext = spy(RuntimeEnvironment.application);
         doReturn(mContext).when(mContext).getApplicationContext();
-        doReturn(mUserManager)
+        doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
-                .when(mContext)
-                .getSystemService(UserManager.class);
         doReturn(true).when(mUserManager).isUserUnlocked(anyInt());
-        doReturn(new int[]{0}).when(mUserManager).getProfileIdsWithDisabled(anyInt());
+        doReturn(new int[] {0}).when(mUserManager).getProfileIdsWithDisabled(anyInt());
         final Resources resources = spy(mContext.getResources());
         resources.getConfiguration().setLocales(new LocaleList(new Locale("en_US")));
         doReturn(resources).when(mContext).getResources();
@@ -122,7 +112,7 @@ public final class BatteryChartPreferenceControllerTest {
         // Adds fake testing data.
         BatteryDiffEntry.sResourceCache.put(
                 "fakeBatteryDiffEntryKey",
-                new BatteryEntry.NameAndIcon("fakeName", /*icon=*/ null, /*iconId=*/ 1));
+                new BatteryEntry.NameAndIcon("fakeName", /* icon= */ null, /* iconId= */ 1));
     }
 
     @Test
@@ -156,15 +146,18 @@ public final class BatteryChartPreferenceControllerTest {
         verify(mDailyChartView, atLeastOnce()).setVisibility(View.GONE);
         // Ignore fast refresh ui from the data processor callback.
         verify(mHourlyChartView, atLeast(0)).setViewModel(null);
-        verify(mHourlyChartView, atLeastOnce()).setViewModel(new BatteryChartViewModel(
+        verify(mHourlyChartView, atLeastOnce())
-                List.of(100, 99, 97, 95, 66),
+                .setViewModel(
-                List.of(1619247660000L /* 7:01 AM */,
+                        new BatteryChartViewModel(
-                        1619251200000L /* 8 AM */,
+                                List.of(100, 99, 97, 95, 66),
-                        1619258400000L /* 10 AM */,
+                                List.of(
-                        1619265600000L /* 12 PM */,
+                                        1619247660000L /* 7:01 AM */,
-                        1619265720000L /* now (12:02 PM) */),
+                                        1619251200000L /* 8 AM */,
-                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                                        1619258400000L /* 10 AM */,
-                mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator));
+                                        1619265600000L /* 12 PM */,
+                                        1619265720000L /* now (12:02 PM) */),
+                                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                                mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator));
     }
 
     @Test
@@ -173,15 +166,17 @@ public final class BatteryChartPreferenceControllerTest {
         reset(mHourlyChartView);
         setupHourlyChartViewAnimationMock();
 
-        BatteryChartViewModel expectedDailyViewModel = new BatteryChartViewModel(
+        BatteryChartViewModel expectedDailyViewModel =
-                List.of(100, 83, 59, 66),
+                new BatteryChartViewModel(
-                // "Sat", "Sun", "Mon", "Mon"
+                        List.of(100, 83, 59, 66),
-                List.of(1619247660000L /* Sat */,
+                        // "Sat", "Sun", "Mon", "Mon"
-                        1619308800000L /* Sun */,
+                        List.of(
-                        1619395200000L /* Mon */,
+                                1619247660000L /* Sat */,
-                        1619460120000L /* Mon */),
+                                1619308800000L /* Sun */,
-                BatteryChartViewModel.AxisLabelPosition.CENTER_OF_TRAPEZOIDS,
+                                1619395200000L /* Mon */,
-                mBatteryChartPreferenceController.mDailyChartLabelTextGenerator);
+                                1619460120000L /* Mon */),
+                        BatteryChartViewModel.AxisLabelPosition.CENTER_OF_TRAPEZOIDS,
+                        mBatteryChartPreferenceController.mDailyChartLabelTextGenerator);
 
         mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(60));
 
@@ -202,20 +197,23 @@ public final class BatteryChartPreferenceControllerTest {
 
         expectedDailyViewModel.setSelectedIndex(0);
         verify(mDailyChartView).setViewModel(expectedDailyViewModel);
-        verify(mHourlyChartView).setViewModel(new BatteryChartViewModel(
+        verify(mHourlyChartView)
-                List.of(100, 99, 97, 95, 93, 91, 89, 87, 85, 83),
+                .setViewModel(
-                List.of(1619247660000L /* 7:01 AM */,
+                        new BatteryChartViewModel(
-                        1619251200000L /* 8 AM */,
+                                List.of(100, 99, 97, 95, 93, 91, 89, 87, 85, 83),
-                        1619258400000L /* 10 AM */,
+                                List.of(
-                        1619265600000L /* 12 PM */,
+                                        1619247660000L /* 7:01 AM */,
-                        1619272800000L /* 2 PM */,
+                                        1619251200000L /* 8 AM */,
-                        1619280000000L /* 4 PM */,
+                                        1619258400000L /* 10 AM */,
-                        1619287200000L /* 6 PM */,
+                                        1619265600000L /* 12 PM */,
-                        1619294400000L /* 8 PM */,
+                                        1619272800000L /* 2 PM */,
-                        1619301600000L /* 10 PM */,
+                                        1619280000000L /* 4 PM */,
-                        1619308800000L /* 12 AM */),
+                                        1619287200000L /* 6 PM */,
-                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                                        1619294400000L /* 8 PM */,
-                mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator));
+                                        1619301600000L /* 10 PM */,
+                                        1619308800000L /* 12 AM */),
+                                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                                mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator));
 
         reset(mDailyChartView);
         reset(mHourlyChartView);
@@ -228,23 +226,25 @@ public final class BatteryChartPreferenceControllerTest {
         verify(mViewPropertyAnimator, atLeastOnce()).alpha(1f);
         expectedDailyViewModel.setSelectedIndex(1);
         verify(mDailyChartView).setViewModel(expectedDailyViewModel);
-        BatteryChartViewModel expectedHourlyViewModel = new BatteryChartViewModel(
+        BatteryChartViewModel expectedHourlyViewModel =
-                List.of(83, 81, 79, 77, 75, 73, 71, 69, 67, 65, 63, 61, 59),
+                new BatteryChartViewModel(
-                List.of(1619308800000L /* 12 AM */,
+                        List.of(83, 81, 79, 77, 75, 73, 71, 69, 67, 65, 63, 61, 59),
-                        1619316000000L /* 2 AM */,
+                        List.of(
-                        1619323200000L /* 4 AM */,
+                                1619308800000L /* 12 AM */,
-                        1619330400000L /* 6 AM */,
+                                1619316000000L /* 2 AM */,
-                        1619337600000L /* 8 AM */,
+                                1619323200000L /* 4 AM */,
-                        1619344800000L /* 10 AM */,
+                                1619330400000L /* 6 AM */,
-                        1619352000000L /* 12 PM */,
+                                1619337600000L /* 8 AM */,
-                        1619359200000L /* 2 PM */,
+                                1619344800000L /* 10 AM */,
-                        1619366400000L /* 4 PM */,
+                                1619352000000L /* 12 PM */,
-                        1619373600000L /* 6 PM */,
+                                1619359200000L /* 2 PM */,
-                        1619380800000L /* 8 PM */,
+                                1619366400000L /* 4 PM */,
-                        1619388000000L /* 10 PM */,
+                                1619373600000L /* 6 PM */,
-                        1619395200000L /* 12 AM */),
+                                1619380800000L /* 8 PM */,
-                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                                1619388000000L /* 10 PM */,
-                mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator);
+                                1619395200000L /* 12 AM */),
+                        BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                        mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator);
         expectedHourlyViewModel.setSelectedIndex(6);
         verify(mHourlyChartView).setViewModel(expectedHourlyViewModel);
 
@@ -259,22 +259,24 @@ public final class BatteryChartPreferenceControllerTest {
         verify(mViewPropertyAnimator, atLeastOnce()).alpha(1f);
         expectedDailyViewModel.setSelectedIndex(2);
         verify(mDailyChartView).setViewModel(expectedDailyViewModel);
-        verify(mHourlyChartView).setViewModel(new BatteryChartViewModel(
+        verify(mHourlyChartView)
-                List.of(59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 66),
+                .setViewModel(
-                List.of(1619395200000L /* 12 AM */,
+                        new BatteryChartViewModel(
-                        1619402400000L /* 2 AM */,
+                                List.of(59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 66),
-                        1619409600000L /* 4 AM */,
+                                List.of(
-                        1619416800000L /* 6 AM */,
+                                        1619395200000L /* 12 AM */,
-                        1619424000000L /* 8 AM */,
+                                        1619402400000L /* 2 AM */,
-                        1619431200000L /* 10 AM */,
+                                        1619409600000L /* 4 AM */,
-                        1619438400000L /* 12 PM */,
+                                        1619416800000L /* 6 AM */,
-                        1619445600000L /* 2 PM */,
+                                        1619424000000L /* 8 AM */,
-                        1619452800000L /* 4 PM */,
+                                        1619431200000L /* 10 AM */,
-                        1619460000000L /* 6 PM */,
+                                        1619438400000L /* 12 PM */,
-                        1619460120000L /* now (6:02 PM) */),
+                                        1619445600000L /* 2 PM */,
-                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                                        1619452800000L /* 4 PM */,
-                mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator));
+                                        1619460000000L /* 6 PM */,
-
+                                        1619460120000L /* now (6:02 PM) */),
+                                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                                mBatteryChartPreferenceController.mHourlyChartLabelTextGenerator));
     }
 
     @Test
@@ -408,8 +410,8 @@ public final class BatteryChartPreferenceControllerTest {
         mBatteryChartPreferenceController.mDailyChartIndex = 0;
         mBatteryChartPreferenceController.mHourlyChartIndex = 2;
 
-        assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo(
+        assertThat(mBatteryChartPreferenceController.getSlotInformation())
-                "10 AM - 12 PM");
+                .isEqualTo("10 AM - 12 PM");
     }
 
     @Test
@@ -418,8 +420,8 @@ public final class BatteryChartPreferenceControllerTest {
         mBatteryChartPreferenceController.mDailyChartIndex = 1;
         mBatteryChartPreferenceController.mHourlyChartIndex = 8;
 
-        assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo(
+        assertThat(mBatteryChartPreferenceController.getSlotInformation())
-                "Sunday 4 PM - 6 PM");
+                .isEqualTo("Sunday 4 PM - 6 PM");
     }
 
     @Test
@@ -428,8 +430,8 @@ public final class BatteryChartPreferenceControllerTest {
         mBatteryChartPreferenceController.mDailyChartIndex = 0;
         mBatteryChartPreferenceController.mHourlyChartIndex = 0;
 
-        assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo(
+        assertThat(mBatteryChartPreferenceController.getSlotInformation())
-                "7:01 AM - 8 AM");
+                .isEqualTo("7:01 AM - 8 AM");
     }
 
     @Test
@@ -438,8 +440,7 @@ public final class BatteryChartPreferenceControllerTest {
         mBatteryChartPreferenceController.mDailyChartIndex = 0;
         mBatteryChartPreferenceController.mHourlyChartIndex = 3;
 
-        assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo(
+        assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo("12 PM - now");
-                "12 PM - now");
     }
 
     @Test
@@ -448,8 +449,8 @@ public final class BatteryChartPreferenceControllerTest {
         mBatteryChartPreferenceController.mDailyChartIndex = 0;
         mBatteryChartPreferenceController.mHourlyChartIndex = 0;
 
-        assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo(
+        assertThat(mBatteryChartPreferenceController.getSlotInformation())
-                "7:01 AM - now");
+                .isEqualTo("7:01 AM - now");
     }
 
     @Test
@@ -508,7 +509,7 @@ public final class BatteryChartPreferenceControllerTest {
     private BatteryChartPreferenceController createController() {
         final BatteryChartPreferenceController controller =
                 new BatteryChartPreferenceController(
-                        mContext, /*lifecycle=*/ null, mSettingsActivity);
+                        mContext, /* lifecycle= */ null, mSettingsActivity);
         controller.mPrefContext = mContext;
         return controller;
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartViewTest.java

@@ -45,8 +45,7 @@ public final class BatteryChartViewTest {
     private FakeFeatureFactory mFeatureFactory;
     private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
 
-    @Mock
+    @Mock private View mMockView;
-    private View mMockView;
 
     @Before
     public void setUp() {
@@ -54,17 +53,19 @@ public final class BatteryChartViewTest {
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mPowerUsageFeatureProvider = mFeatureFactory.powerUsageFeatureProvider;
         mContext = spy(RuntimeEnvironment.application);
-        mContext.getResources().getConfiguration().setLocales(
+        mContext.getResources().getConfiguration().setLocales(new LocaleList(new Locale("en_US")));
-                new LocaleList(new Locale("en_US")));
         mBatteryChartView = new BatteryChartView(mContext);
     }
 
     @Test
     public void onClick_invokesCallback() {
         final int originalSelectedIndex = 2;
-        BatteryChartViewModel batteryChartViewModel = new BatteryChartViewModel(
+        BatteryChartViewModel batteryChartViewModel =
-                List.of(90, 80, 70, 60), List.of(0L, 0L, 0L, 0L),
+                new BatteryChartViewModel(
-                BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS, null);
+                        List.of(90, 80, 70, 60),
+                        List.of(0L, 0L, 0L, 0L),
+                        BatteryChartViewModel.AxisLabelPosition.BETWEEN_TRAPEZOIDS,
+                        null);
         batteryChartViewModel.setSelectedIndex(originalSelectedIndex);
         mBatteryChartView.setViewModel(batteryChartViewModel);
         for (int i = 0; i < mBatteryChartView.mTrapezoidSlots.length; i++) {

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffDataTest.java

@@ -149,16 +149,12 @@ public class BatteryDiffDataTest {
                 createBatteryDiffEntry(mContext, /* consumePower= */ 28.5, /* key= */ "APP_1"));
         batteryDiffEntries.add(
                 createBatteryDiffEntry(
-                        mContext,
+                        mContext, /* consumePower= */ 20, BatteryDiffEntry.UNINSTALLED_APPS_KEY));
-                        /* consumePower= */ 20,
-                        BatteryDiffEntry.UNINSTALLED_APPS_KEY));
         batteryDiffEntries.add(
                 createBatteryDiffEntry(mContext, /* consumePower= */ 3, /* key= */ "APP_2"));
         batteryDiffEntries.add(
                 createBatteryDiffEntry(
-                        mContext,
+                        mContext, /* consumePower= */ 28.5, BatteryDiffEntry.SYSTEM_APPS_KEY));
-                        /* consumePower= */ 28.5,
-                        BatteryDiffEntry.SYSTEM_APPS_KEY));
         batteryDiffEntries.add(
                 createBatteryDiffEntry(mContext, /* consumePower= */ 20, /* key= */ "APP_3"));
 

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java

@@ -64,7 +64,6 @@ public final class BatteryDiffEntryTest {
     private static final String UNINSTALLED_PACKAGE_NAME = "com.android.testing.uninstalled";
     private static final String UID_ZERO_PACKAGE_NAME = "com.android.testing.uid.zero";
 
-
     private Context mContext;
 
     @Mock private ApplicationInfo mMockAppInfo;
@@ -451,7 +450,6 @@ public final class BatteryDiffEntryTest {
         assertThat(entry.isUninstalledEntry()).isFalse();
         assertThat(BatteryDiffEntry.sPackageNameAndUidCache.containsKey(PACKAGE_NAME)).isTrue();
         assertThat(BatteryDiffEntry.sPackageNameAndUidCache.get(PACKAGE_NAME)).isEqualTo(UID);
-
     }
 
     @Test
@@ -602,7 +600,7 @@ public final class BatteryDiffEntryTest {
         final BatteryHistEntry batteryHistEntry = new BatteryHistEntry(values);
         doReturn(drawable).when(mMockPackageManager).getDefaultActivityIcon();
         doReturn(null).when(mMockPackageManager).getApplicationInfo("com.a.b.c", 0);
-        doReturn(new String[]{"com.a.b.c"}).when(mMockPackageManager).getPackagesForUid(1001);
+        doReturn(new String[] {"com.a.b.c"}).when(mMockPackageManager).getPackagesForUid(1001);
         return createBatteryDiffEntry(10, batteryHistEntry);
     }
 

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryEntryTest.java

@@ -61,18 +61,15 @@ public class BatteryEntryTest {
     private static final String HIGH_DRAIN_PACKAGE = "com.android.test.screen";
     private static final String ANDROID_PACKAGE = "android";
 
-    @Rule
+    @Rule public MockitoRule mocks = MockitoJUnit.rule();
-    public MockitoRule mocks = MockitoJUnit.rule();
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mMockContext;
+
     private Context mContext;
-    @Mock
+    @Mock private PackageManager mMockPackageManager;
-    private PackageManager mMockPackageManager;
+    @Mock private UserManager mMockUserManager;
-    @Mock
+    @Mock private UidBatteryConsumer mUidBatteryConsumer;
-    private UserManager mMockUserManager;
-    @Mock
-    private UidBatteryConsumer mUidBatteryConsumer;
 
     @Before
     public void stubContextToReturnMockPackageManager() {
@@ -83,23 +80,27 @@ public class BatteryEntryTest {
     @Before
     public void stubPackageManagerToReturnAppPackageAndName() throws NameNotFoundException {
         when(mMockPackageManager.getApplicationInfo(anyString(), eq(0) /* no flags */))
-                .thenAnswer(invocation -> {
+                .thenAnswer(
-                    ApplicationInfo info = new ApplicationInfo();
+                        invocation -> {
-                    info.packageName = invocation.getArgument(0);
+                            ApplicationInfo info = new ApplicationInfo();
-                    return info;
+                            info.packageName = invocation.getArgument(0);
-                });
+                            return info;
+                        });
         when(mMockPackageManager.getApplicationLabel(any(ApplicationInfo.class)))
-                .thenAnswer(invocation -> LABEL_PREFIX
+                .thenAnswer(
-                        + ((ApplicationInfo) invocation.getArgument(0)).packageName);
+                        invocation ->
+                                LABEL_PREFIX
+                                        + ((ApplicationInfo) invocation.getArgument(0))
+                                                .packageName);
     }
 
-    private BatteryEntry createBatteryEntryForApp(String[] packages, String packageName,
+    private BatteryEntry createBatteryEntryForApp(
-            String highDrainPackage) {
+            String[] packages, String packageName, String highDrainPackage) {
         UidBatteryConsumer consumer = mock(UidBatteryConsumer.class);
         when(consumer.getUid()).thenReturn(APP_UID);
         when(consumer.getPackageWithHighestDrain()).thenReturn(highDrainPackage);
-        return new BatteryEntry(mMockContext, mMockUserManager,
+        return new BatteryEntry(
-                consumer, false, APP_UID, packages, packageName);
+                mMockContext, mMockUserManager, consumer, false, APP_UID, packages, packageName);
     }
 
     private BatteryEntry createAggregateBatteryEntry(int powerComponentId) {
@@ -122,14 +123,13 @@ public class BatteryEntryTest {
     private BatteryEntry createUserBatteryConsumer(int userId) {
         UserBatteryConsumer consumer = mock(UserBatteryConsumer.class);
         when(consumer.getUserId()).thenReturn(userId);
-        return new BatteryEntry(mMockContext, mMockUserManager,
+        return new BatteryEntry(mMockContext, mMockUserManager, consumer, false, 0, null, null);
-                consumer, false, 0, null, null);
     }
 
     @Test
     public void batteryEntryForApp_shouldSetDefaultPackageNameAndLabel() throws Exception {
-        BatteryEntry entry = createBatteryEntryForApp(null, APP_DEFAULT_PACKAGE_NAME,
+        BatteryEntry entry =
-                HIGH_DRAIN_PACKAGE);
+                createBatteryEntryForApp(null, APP_DEFAULT_PACKAGE_NAME, HIGH_DRAIN_PACKAGE);
 
         assertThat(entry.getDefaultPackageName()).isEqualTo(APP_DEFAULT_PACKAGE_NAME);
         assertThat(entry.getLabel()).isEqualTo(LABEL_PREFIX + APP_DEFAULT_PACKAGE_NAME);
@@ -157,20 +157,24 @@ public class BatteryEntryTest {
 
     @Test
     public void batteryEntryForApp_shouldSetHighestDrainPackage_whenMultiplePackagesFoundForUid() {
-        BatteryEntry entry = createBatteryEntryForApp(
+        BatteryEntry entry =
-                new String[]{APP_DEFAULT_PACKAGE_NAME, "package2", "package3"}, null,
+                createBatteryEntryForApp(
-                HIGH_DRAIN_PACKAGE);
+                        new String[] {APP_DEFAULT_PACKAGE_NAME, "package2", "package3"},
+                        null,
+                        HIGH_DRAIN_PACKAGE);
 
         assertThat(entry.getLabel()).isEqualTo(LABEL_PREFIX + HIGH_DRAIN_PACKAGE);
     }
 
     @Test
     public void batteryEntryForAOD_containCorrectInfo() {
-        final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application,
+        final BatteryEntry entry =
-                BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY,
+                new BatteryEntry(
-                /* devicePowerMah= */ 200,
+                        RuntimeEnvironment.application,
-                /* usageDurationMs= */ 1000,
+                        BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY,
-                /* isHidden= */ false);
+                        /* devicePowerMah= */ 200,
+                        /* usageDurationMs= */ 1000,
+                        /* isHidden= */ false);
 
         assertThat(entry.mIconId).isEqualTo(R.drawable.ic_settings_aod);
         assertThat(entry.mName).isEqualTo("Ambient display");
@@ -178,10 +182,12 @@ public class BatteryEntryTest {
 
     @Test
     public void batteryEntryForCustomComponent_containCorrectInfo() {
-        final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application,
+        final BatteryEntry entry =
-                BatteryConsumer.FIRST_CUSTOM_POWER_COMPONENT_ID + 42,
+                new BatteryEntry(
-                /* powerComponentName= */ "ABC",
+                        RuntimeEnvironment.application,
-                /* devicePowerMah= */ 200);
+                        BatteryConsumer.FIRST_CUSTOM_POWER_COMPONENT_ID + 42,
+                        /* powerComponentName= */ "ABC",
+                        /* devicePowerMah= */ 200);
 
         assertThat(entry.mIconId).isEqualTo(R.drawable.ic_power_system);
         assertThat(entry.mName).isEqualTo("ABC");
@@ -192,19 +198,28 @@ public class BatteryEntryTest {
         when(mUidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND))
                 .thenReturn(100L);
 
-        final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application,
+        final BatteryEntry entry =
-                mMockUserManager, mUidBatteryConsumer, false, 0, null, null);
+                new BatteryEntry(
+                        RuntimeEnvironment.application,
+                        mMockUserManager,
+                        mUidBatteryConsumer,
+                        false,
+                        0,
+                        null,
+                        null);
 
         assertThat(entry.getTimeInForegroundMs()).isEqualTo(100L);
     }
 
     @Test
     public void getTimeInForegroundMs_aggregateBatteryConsumer() {
-        final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application,
+        final BatteryEntry entry =
-                BatteryConsumer.POWER_COMPONENT_BLUETOOTH,
+                new BatteryEntry(
-                /* devicePowerMah= */ 10,
+                        RuntimeEnvironment.application,
-                /* usageDurationMs= */ 100,
+                        BatteryConsumer.POWER_COMPONENT_BLUETOOTH,
-                /* isHidden= */ false);
+                        /* devicePowerMah= */ 10,
+                        /* usageDurationMs= */ 100,
+                        /* isHidden= */ false);
 
         assertThat(entry.getTimeInForegroundMs()).isEqualTo(100L);
     }
@@ -214,19 +229,28 @@ public class BatteryEntryTest {
         when(mUidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_BACKGROUND))
                 .thenReturn(100L);
 
-        final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application,
+        final BatteryEntry entry =
-                mMockUserManager, mUidBatteryConsumer, false, 0, null, null);
+                new BatteryEntry(
+                        RuntimeEnvironment.application,
+                        mMockUserManager,
+                        mUidBatteryConsumer,
+                        false,
+                        0,
+                        null,
+                        null);
 
         assertThat(entry.getTimeInBackgroundMs()).isEqualTo(100L);
     }
 
     @Test
     public void getTimeInBackgroundMs_systemConsumer() {
-        final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application,
+        final BatteryEntry entry =
-                BatteryConsumer.POWER_COMPONENT_BLUETOOTH,
+                new BatteryEntry(
-                /* devicePowerMah= */ 100,
+                        RuntimeEnvironment.application,
-                /* usageDurationMs= */ 1000,
+                        BatteryConsumer.POWER_COMPONENT_BLUETOOTH,
-                /* isHidden= */ false);
+                        /* devicePowerMah= */ 100,
+                        /* usageDurationMs= */ 1000,
+                        /* isHidden= */ false);
 
         assertThat(entry.getTimeInBackgroundMs()).isEqualTo(0);
     }
@@ -241,16 +265,17 @@ public class BatteryEntryTest {
 
     @Test
     public void getKey_AggregateBatteryConsumer_returnComponentId() {
-        final BatteryEntry entry = createAggregateBatteryEntry(
+        final BatteryEntry entry =
-                BatteryConsumer.POWER_COMPONENT_BLUETOOTH);
+                createAggregateBatteryEntry(BatteryConsumer.POWER_COMPONENT_BLUETOOTH);
         final String key = entry.getKey();
         assertThat(key).isEqualTo("S|2");
     }
 
     @Test
     public void getKey_CustomAggregateBatteryConsumer_returnComponentId() {
-        final BatteryEntry entry = createCustomAggregateBatteryEntry(
+        final BatteryEntry entry =
-                BatteryConsumer.FIRST_CUSTOM_POWER_COMPONENT_ID + 42);
+                createCustomAggregateBatteryEntry(
+                        BatteryConsumer.FIRST_CUSTOM_POWER_COMPONENT_ID + 42);
         final String key = entry.getKey();
         assertThat(key).isEqualTo("S|1042");
     }
@@ -269,19 +294,18 @@ public class BatteryEntryTest {
         doReturn(mMockUserManager).when(mContext).getSystemService(UserManager.class);
         doReturn(null).when(mMockUserManager).getUserInfo(userId);
 
-        final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUserId(
+        final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUserId(mContext, userId);
-                mContext, userId);
+        assertThat(nameAndIcon.mName)
-        assertThat(nameAndIcon.mName).isEqualTo(getString(
+                .isEqualTo(getString(R.string.running_process_item_removed_user_label));
-                R.string.running_process_item_removed_user_label));
         assertThat(nameAndIcon.mIcon).isNull();
     }
 
     @Test
     public void getNameAndIconFromUid_rerturnExpectedName() {
-        final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUid(
+        final NameAndIcon nameAndIcon =
-                mContext, /* name */ null, /* uid */ 0);
+                BatteryEntry.getNameAndIconFromUid(mContext, /* name */ null, /* uid */ 0);
-        assertThat(nameAndIcon.mName).isEqualTo(
+        assertThat(nameAndIcon.mName)
-                getString(com.android.settingslib.R.string.process_kernel_label));
+                .isEqualTo(getString(com.android.settingslib.R.string.process_kernel_label));
 
         assertNameAndIcon("mediaserver", R.string.process_mediaserver_label);
         assertNameAndIcon("dex2oat32", R.string.process_dex2oat_label);
@@ -291,63 +315,75 @@ public class BatteryEntryTest {
 
     @Test
     public void getNameAndIconFromUid_tetheringUid_rerturnExpectedName() {
-        final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUid(
+        final NameAndIcon nameAndIcon =
-                mContext, /* name */ null, /* uid */ BatteryUtils.UID_TETHERING);
+                BatteryEntry.getNameAndIconFromUid(
+                        mContext, /* name */ null, /* uid */ BatteryUtils.UID_TETHERING);
 
         assertThat(nameAndIcon.mName).isEqualTo(getString(R.string.process_network_tethering));
     }
 
     @Test
     public void getNameAndIconFromUid_removedAppsUid_rerturnExpectedName() {
-        final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUid(
+        final NameAndIcon nameAndIcon =
-                mContext, /* name */ null, /* uid */ BatteryUtils.UID_REMOVED_APPS);
+                BatteryEntry.getNameAndIconFromUid(
+                        mContext, /* name */ null, /* uid */ BatteryUtils.UID_REMOVED_APPS);
 
         assertThat(nameAndIcon.mName).isEqualTo(getString(R.string.process_removed_apps));
     }
 
     @Test
     public void getNameAndIconFromPowerComponent_rerturnExpectedNameAndIcon() {
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_SCREEN,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_SCREEN,
                 R.string.power_screen,
                 R.drawable.ic_settings_display);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_CPU,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_CPU,
                 R.string.power_cpu,
                 R.drawable.ic_settings_cpu);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_BLUETOOTH,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_BLUETOOTH,
                 R.string.power_bluetooth,
                 R.drawable.ic_settings_bluetooth);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_CAMERA,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_CAMERA,
                 R.string.power_camera,
                 R.drawable.ic_settings_camera);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_FLASHLIGHT,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_FLASHLIGHT,
                 R.string.power_flashlight,
                 R.drawable.ic_settings_flashlight);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO,
                 R.string.power_cell,
                 R.drawable.ic_settings_cellular);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_GNSS,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_GNSS,
                 R.string.power_gps,
                 R.drawable.ic_settings_gps);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_WIFI,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_WIFI,
                 R.string.power_wifi,
                 R.drawable.ic_settings_wireless_no_theme);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_PHONE,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_PHONE,
                 R.string.power_phone,
                 R.drawable.ic_settings_voice_calls);
-        assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY,
+        assertNameAndIcon(
+                BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY,
                 R.string.ambient_display_screen_title,
                 R.drawable.ic_settings_aod);
     }
 
     private void assertNameAndIcon(String name, int stringId) {
-        final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUid(
+        final NameAndIcon nameAndIcon =
-                mContext, name, /* uid */ 1000);
+                BatteryEntry.getNameAndIconFromUid(mContext, name, /* uid */ 1000);
         assertThat(nameAndIcon.mName).isEqualTo(getString(stringId));
     }
 
     private void assertNameAndIcon(int powerComponentId, int stringId, int iconId) {
-        final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromPowerComponent(
+        final NameAndIcon nameAndIcon =
-                mContext, powerComponentId);
+                BatteryEntry.getNameAndIconFromPowerComponent(mContext, powerComponentId);
         assertThat(nameAndIcon.mName).isEqualTo(getString(stringId));
         assertThat(nameAndIcon.mIconId).isEqualTo(iconId);
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java

@@ -41,10 +41,8 @@ import java.util.TimeZone;
 @RunWith(RobolectricTestRunner.class)
 public final class BatteryHistEntryTest {
 
-    @Mock
+    @Mock private BatteryEntry mMockBatteryEntry;
-    private BatteryEntry mMockBatteryEntry;
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    @Mock
-    private BatteryUsageStats mBatteryUsageStats;
 
     @Before
     public void setUp() {
@@ -75,17 +73,17 @@ public final class BatteryHistEntryTest {
                 ConvertUtils.convertBatteryEntryToContentValues(
                         mMockBatteryEntry,
                         mBatteryUsageStats,
-                        /*batteryLevel=*/ 12,
+                        /* batteryLevel= */ 12,
-                        /*batteryStatus=*/ BatteryManager.BATTERY_STATUS_FULL,
+                        /* batteryStatus= */ BatteryManager.BATTERY_STATUS_FULL,
-                        /*batteryHealth=*/ BatteryManager.BATTERY_HEALTH_COLD,
+                        /* batteryHealth= */ BatteryManager.BATTERY_HEALTH_COLD,
-                        /*bootTimestamp=*/ 101L,
+                        /* bootTimestamp= */ 101L,
-                        /*timestamp=*/ 10001L,
+                        /* timestamp= */ 10001L,
-                        /*isFullChargeStart=*/ false);
+                        /* isFullChargeStart= */ false);
 
         assertBatteryHistEntry(
                 new BatteryHistEntry(values),
-                /*drainType=*/ expectedType,
+                /* drainType= */ expectedType,
-                /*percentOfTotal=*/ mMockBatteryEntry.mPercent);
+                /* percentOfTotal= */ mMockBatteryEntry.mPercent);
     }
 
     @Test
@@ -98,25 +96,25 @@ public final class BatteryHistEntryTest {
     public void testConstructor_cursor_returnsExpectedResult() {
         assertBatteryHistEntry(
                 createBatteryHistEntry(
-                        /*bootTimestamp=*/ 101L,
+                        /* bootTimestamp= */ 101L,
-                        /*timestamp=*/ 10001L,
+                        /* timestamp= */ 10001L,
-                        /*totalPower=*/ 5.1,
+                        /* totalPower= */ 5.1,
-                        /*consumePower=*/ 1.1,
+                        /* consumePower= */ 1.1,
-                        /*foregroundUsageConsumePower=*/ 1.2,
+                        /* foregroundUsageConsumePower= */ 1.2,
-                        /*foregroundServiceUsageConsumePower=*/ 1.3,
+                        /* foregroundServiceUsageConsumePower= */ 1.3,
-                        /*backgroundUsageConsumePower=*/ 1.4,
+                        /* backgroundUsageConsumePower= */ 1.4,
-                        /*cachedUsageConsumePower=*/ 1.5,
+                        /* cachedUsageConsumePower= */ 1.5,
-                        /*foregroundUsageTimeInMs=*/ 1234L,
+                        /* foregroundUsageTimeInMs= */ 1234L,
-                        /*backgroundUsageTimeInMs=*/ 5689L,
+                        /* backgroundUsageTimeInMs= */ 5689L,
-                        /*batteryLevel=*/ 12),
+                        /* batteryLevel= */ 12),
-                /*drainType=*/ 3,
+                /* drainType= */ 3,
-                /*percentOfTotal=*/ 0.3);
+                /* percentOfTotal= */ 0.3);
     }
 
     @Test
     public void testGetKey_consumerUidType_returnExpectedString() {
-        final ContentValues values = getContentValuesWithType(
+        final ContentValues values =
-                ConvertUtils.CONSUMER_TYPE_UID_BATTERY);
+                getContentValuesWithType(ConvertUtils.CONSUMER_TYPE_UID_BATTERY);
         values.put(BatteryHistEntry.KEY_UID, 3);
         final BatteryHistEntry batteryHistEntry = new BatteryHistEntry(values);
 
@@ -125,8 +123,8 @@ public final class BatteryHistEntryTest {
 
     @Test
     public void testGetKey_consumerUserType_returnExpectedString() {
-        final ContentValues values = getContentValuesWithType(
+        final ContentValues values =
-                ConvertUtils.CONSUMER_TYPE_USER_BATTERY);
+                getContentValuesWithType(ConvertUtils.CONSUMER_TYPE_USER_BATTERY);
         values.put(BatteryHistEntry.KEY_USER_ID, 2);
         final BatteryHistEntry batteryHistEntry = new BatteryHistEntry(values);
 
@@ -135,14 +133,12 @@ public final class BatteryHistEntryTest {
 
     @Test
     public void testGetKey_consumerSystemType_returnExpectedString() {
-        final ContentValues values = getContentValuesWithType(
+        final ContentValues values =
-                ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY);
+                getContentValuesWithType(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY);
         final BatteryInformation batteryInformation =
-                BatteryInformation
+                BatteryInformation.newBuilder().setDrainType(1).build();
-                        .newBuilder()
+        values.put(
-                        .setDrainType(1)
+                BatteryHistEntry.KEY_BATTERY_INFORMATION,
-                        .build();
-        values.put(BatteryHistEntry.KEY_BATTERY_INFORMATION,
                 ConvertUtils.convertBatteryInformationToString(batteryInformation));
         final BatteryHistEntry batteryHistEntry = new BatteryHistEntry(values);
 
@@ -151,32 +147,51 @@ public final class BatteryHistEntryTest {
 
     @Test
     public void testIsAppEntry_returnExpectedResult() {
-        assertThat(isUidConsumer(
+        assertThat(
-                createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).mConsumerType)).isFalse();
+                        isUidConsumer(
-        assertThat(isUidConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY)
-                createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType)).isFalse();
+                                        .mConsumerType))
-        assertThat(isUidConsumer(
+                .isFalse();
-                createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType)).isTrue();
+        assertThat(
+                        isUidConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType))
+                .isFalse();
+        assertThat(isUidConsumer(createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType))
+                .isTrue();
     }
 
     @Test
     public void testIsUserEntry_returnExpectedResult() {
-        assertThat(isUserConsumer(
+        assertThat(
-                createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).mConsumerType)).isFalse();
+                        isUserConsumer(
-        assertThat(isUserConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY)
-                createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType)).isTrue();
+                                        .mConsumerType))
-        assertThat(isUserConsumer(
+                .isFalse();
-                createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType)).isFalse();
+        assertThat(
+                        isUserConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType))
+                .isTrue();
+        assertThat(
+                        isUserConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType))
+                .isFalse();
     }
 
     @Test
     public void testIsSystemEntry_returnExpectedResult() {
-        assertThat(isSystemConsumer(
+        assertThat(
-                createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).mConsumerType)).isTrue();
+                        isSystemConsumer(
-        assertThat(isSystemConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY)
-                createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType)).isFalse();
+                                        .mConsumerType))
-        assertThat(isSystemConsumer(
+                .isTrue();
-                createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType)).isFalse();
+        assertThat(
+                        isSystemConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType))
+                .isFalse();
+        assertThat(
+                        isSystemConsumer(
+                                createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType))
+                .isFalse();
     }
 
     @Test
@@ -185,52 +200,52 @@ public final class BatteryHistEntryTest {
         final long upperTimestamp = 300L;
         final long lowerTimestamp = 100L;
         final double ratio = 0.5;
-        final BatteryHistEntry lowerHistEntry = createBatteryHistEntry(
+        final BatteryHistEntry lowerHistEntry =
-                /*bootTimestamp=*/ 1000L,
+                createBatteryHistEntry(
-                lowerTimestamp,
+                        /* bootTimestamp= */ 1000L,
-                /*totalPower=*/ 50,
+                        lowerTimestamp,
-                /*consumePower=*/ 10,
+                        /* totalPower= */ 50,
-                /*foregroundUsageConsumePower=*/ 1,
+                        /* consumePower= */ 10,
-                /*foregroundServiceUsageConsumePower=*/ 2,
+                        /* foregroundUsageConsumePower= */ 1,
-                /*backgroundUsageConsumePower=*/ 3,
+                        /* foregroundServiceUsageConsumePower= */ 2,
-                /*cachedUsageConsumePower=*/ 4,
+                        /* backgroundUsageConsumePower= */ 3,
-                /*foregroundUsageTimeInMs=*/ 100,
+                        /* cachedUsageConsumePower= */ 4,
-                /*backgroundUsageTimeInMs=*/ 200,
+                        /* foregroundUsageTimeInMs= */ 100,
-                /*batteryLevel=*/ 90);
+                        /* backgroundUsageTimeInMs= */ 200,
-        final BatteryHistEntry upperHistEntry = createBatteryHistEntry(
+                        /* batteryLevel= */ 90);
-                /*bootTimestamp=*/ 1200L,
+        final BatteryHistEntry upperHistEntry =
-                upperTimestamp,
+                createBatteryHistEntry(
-                /*totalPower=*/ 80,
+                        /* bootTimestamp= */ 1200L,
-                /*consumePower=*/ 20,
+                        upperTimestamp,
-                /*foregroundUsageConsumePower=*/ 4,
+                        /* totalPower= */ 80,
-                /*foregroundServiceUsageConsumePower=*/ 5,
+                        /* consumePower= */ 20,
-                /*backgroundUsageConsumePower=*/ 6,
+                        /* foregroundUsageConsumePower= */ 4,
-                /*cachedUsageConsumePower=*/ 5,
+                        /* foregroundServiceUsageConsumePower= */ 5,
-                /*foregroundUsageTimeInMs=*/ 200,
+                        /* backgroundUsageConsumePower= */ 6,
-                /*backgroundUsageTimeInMs=*/ 300,
+                        /* cachedUsageConsumePower= */ 5,
-                /*batteryLevel=*/ 80);
+                        /* foregroundUsageTimeInMs= */ 200,
+                        /* backgroundUsageTimeInMs= */ 300,
+                        /* batteryLevel= */ 80);
 
         final BatteryHistEntry newEntry =
                 BatteryHistEntry.interpolate(
-                        slotTimestamp,
+                        slotTimestamp, upperTimestamp, ratio, lowerHistEntry, upperHistEntry);
-                        upperTimestamp,
-                        ratio,
-                        lowerHistEntry,
-                        upperHistEntry);
 
         assertBatteryHistEntry(
-                newEntry, 3, upperHistEntry.mPercentOfTotal,
+                newEntry,
-                /*bootTimestamp=*/ 1200 - 100,
+                3,
-                /*timestamp=*/ slotTimestamp,
+                upperHistEntry.mPercentOfTotal,
-                /*totalPower=*/ 50 + 0.5 * (80 - 50),
+                /* bootTimestamp= */ 1200 - 100,
-                /*consumePower=*/ 10 + 0.5 * (20 - 10),
+                /* timestamp= */ slotTimestamp,
-                /*foregroundUsageConsumePower=*/ 1 + 0.5 * (4 - 1),
+                /* totalPower= */ 50 + 0.5 * (80 - 50),
-                /*foregroundServiceUsageConsumePower=*/ 2 + 0.5 * (5 - 2),
+                /* consumePower= */ 10 + 0.5 * (20 - 10),
-                /*backgroundUsageConsumePower=*/ 3 + 0.5 * (6 - 3),
+                /* foregroundUsageConsumePower= */ 1 + 0.5 * (4 - 1),
-                /*cachedUsageConsumePower=*/ 4 + 0.5 * (5 - 4),
+                /* foregroundServiceUsageConsumePower= */ 2 + 0.5 * (5 - 2),
-                /*foregroundUsageTimeInMs=*/ Math.round(100 + 0.5 * (200 - 100)),
+                /* backgroundUsageConsumePower= */ 3 + 0.5 * (6 - 3),
-                /*backgroundUsageTimeInMs=*/ Math.round(200 + 0.5 * (300 - 200)),
+                /* cachedUsageConsumePower= */ 4 + 0.5 * (5 - 4),
-                /*batteryLevel=*/ (int) Math.round(90 + 0.5 * (80 - 90)));
+                /* foregroundUsageTimeInMs= */ Math.round(100 + 0.5 * (200 - 100)),
+                /* backgroundUsageTimeInMs= */ Math.round(200 + 0.5 * (300 - 200)),
+                /* batteryLevel= */ (int) Math.round(90 + 0.5 * (80 - 90)));
     }
 
     @Test
@@ -238,40 +253,43 @@ public final class BatteryHistEntryTest {
         final long slotTimestamp = 200L;
         final long upperTimestamp = 300L;
         final double ratio = 0.5;
-        final BatteryHistEntry upperHistEntry = createBatteryHistEntry(
+        final BatteryHistEntry upperHistEntry =
-                /*bootTimestamp=*/ 1200L,
+                createBatteryHistEntry(
-                upperTimestamp,
+                        /* bootTimestamp= */ 1200L,
-                /*totalPower=*/ 80,
+                        upperTimestamp,
-                /*consumePower=*/ 20,
+                        /* totalPower= */ 80,
-                /*foregroundUsageConsumePower=*/ 4,
+                        /* consumePower= */ 20,
-                /*foregroundServiceUsageConsumePower=*/ 5,
+                        /* foregroundUsageConsumePower= */ 4,
-                /*backgroundUsageConsumePower=*/ 6,
+                        /* foregroundServiceUsageConsumePower= */ 5,
-                /*cachedUsageConsumePower=*/ 5,
+                        /* backgroundUsageConsumePower= */ 6,
-                /*foregroundUsageTimeInMs=*/ 200,
+                        /* cachedUsageConsumePower= */ 5,
-                /*backgroundUsageTimeInMs=*/ 300,
+                        /* foregroundUsageTimeInMs= */ 200,
-                /*batteryLevel=*/ 80);
+                        /* backgroundUsageTimeInMs= */ 300,
+                        /* batteryLevel= */ 80);
 
         final BatteryHistEntry newEntry =
                 BatteryHistEntry.interpolate(
                         slotTimestamp,
                         upperTimestamp,
                         ratio,
-                        /*lowerHistEntry=*/ null,
+                        /* lowerHistEntry= */ null,
                         upperHistEntry);
 
         assertBatteryHistEntry(
-                newEntry, 3, upperHistEntry.mPercentOfTotal,
+                newEntry,
-                /*bootTimestamp=*/ 1200 - 100,
+                3,
-                /*timestamp=*/ slotTimestamp,
+                upperHistEntry.mPercentOfTotal,
-                /*totalPower=*/ 0.5 * 80,
+                /* bootTimestamp= */ 1200 - 100,
-                /*consumePower=*/ 0.5 * 20,
+                /* timestamp= */ slotTimestamp,
-                /*foregroundUsageConsumePower=*/ 0.5 * 4,
+                /* totalPower= */ 0.5 * 80,
-                /*foregroundServiceUsageConsumePower=*/ 0.5 * 5,
+                /* consumePower= */ 0.5 * 20,
-                /*backgroundUsageConsumePower=*/ 0.5 * 6,
+                /* foregroundUsageConsumePower= */ 0.5 * 4,
-                /*cachedUsageConsumePower=*/ 0.5 * 5,
+                /* foregroundServiceUsageConsumePower= */ 0.5 * 5,
-                /*foregroundUsageTimeInMs=*/ Math.round(0.5 * 200),
+                /* backgroundUsageConsumePower= */ 0.5 * 6,
-                /*backgroundUsageTimeInMs=*/ Math.round(0.5 * 300),
+                /* cachedUsageConsumePower= */ 0.5 * 5,
-                /*batteryLevel=*/ upperHistEntry.mBatteryLevel);
+                /* foregroundUsageTimeInMs= */ Math.round(0.5 * 200),
+                /* backgroundUsageTimeInMs= */ Math.round(0.5 * 300),
+                /* batteryLevel= */ upperHistEntry.mBatteryLevel);
     }
 
     private static BatteryHistEntry createEntry(int consumerType) {
@@ -280,26 +298,27 @@ public final class BatteryHistEntryTest {
 
     private static ContentValues getContentValuesWithType(int consumerType) {
         final ContentValues values = new ContentValues();
-        values.put(BatteryHistEntry.KEY_CONSUMER_TYPE,
+        values.put(BatteryHistEntry.KEY_CONSUMER_TYPE, Integer.valueOf(consumerType));
-                Integer.valueOf(consumerType));
         return values;
     }
 
     private void assertBatteryHistEntry(
             BatteryHistEntry entry, int drainType, double percentOfTotal) {
         assertBatteryHistEntry(
-                entry, drainType, percentOfTotal,
+                entry,
-                /*bootTimestamp=*/ 101L,
+                drainType,
-                /*timestamp=*/ 10001L,
+                percentOfTotal,
-                /*totalPower=*/ 5.1,
+                /* bootTimestamp= */ 101L,
-                /*consumePower=*/ 1.1,
+                /* timestamp= */ 10001L,
-                /*foregroundUsageConsumePower=*/ 1.2,
+                /* totalPower= */ 5.1,
-                /*foregroundServiceUsageConsumePower=*/ 1.3,
+                /* consumePower= */ 1.1,
-                /*backgroundUsageConsumePower=*/ 1.4,
+                /* foregroundUsageConsumePower= */ 1.2,
-                /*cachedUsageConsumePower=*/ 1.5,
+                /* foregroundServiceUsageConsumePower= */ 1.3,
-                /*foregroundUsageTimeInMs=*/ 1234L,
+                /* backgroundUsageConsumePower= */ 1.4,
-                /*backgroundUsageTimeInMs=*/ 5689L,
+                /* cachedUsageConsumePower= */ 1.5,
-                /*batteryLevel=*/ 12);
+                /* foregroundUsageTimeInMs= */ 1234L,
+                /* backgroundUsageTimeInMs= */ 5689L,
+                /* batteryLevel= */ 12);
     }
 
     private void assertBatteryHistEntry(
@@ -321,8 +340,7 @@ public final class BatteryHistEntryTest {
         assertThat(entry.mUid).isEqualTo(1001);
         assertThat(entry.mUserId).isEqualTo(UserHandle.getUserId(1001));
         assertThat(entry.mAppLabel).isEqualTo("Settings");
-        assertThat(entry.mPackageName)
+        assertThat(entry.mPackageName).isEqualTo("com.google.android.settings.battery");
-                .isEqualTo("com.google.android.settings.battery");
         assertThat(entry.mIsHidden).isTrue();
         assertThat(entry.mBootTimestamp).isEqualTo(bootTimestamp);
         assertThat(entry.mTimestamp).isEqualTo(timestamp);
@@ -338,13 +356,10 @@ public final class BatteryHistEntryTest {
         assertThat(entry.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs);
         assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs);
         assertThat(entry.mDrainType).isEqualTo(drainType);
-        assertThat(entry.mConsumerType)
+        assertThat(entry.mConsumerType).isEqualTo(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY);
-                .isEqualTo(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY);
         assertThat(entry.mBatteryLevel).isEqualTo(batteryLevel);
-        assertThat(entry.mBatteryStatus)
+        assertThat(entry.mBatteryStatus).isEqualTo(BatteryManager.BATTERY_STATUS_FULL);
-                .isEqualTo(BatteryManager.BATTERY_STATUS_FULL);
+        assertThat(entry.mBatteryHealth).isEqualTo(BatteryManager.BATTERY_HEALTH_COLD);
-        assertThat(entry.mBatteryHealth)
-                .isEqualTo(BatteryManager.BATTERY_HEALTH_COLD);
     }
 
     private BatteryHistEntry createBatteryHistEntry(
@@ -359,24 +374,24 @@ public final class BatteryHistEntryTest {
             long foregroundUsageTimeInMs,
             long backgroundUsageTimeInMs,
             int batteryLevel) {
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-            new String[]{
+                new MatrixCursor(
-                BatteryHistEntry.KEY_UID,
+                        new String[] {
-                BatteryHistEntry.KEY_USER_ID,
+                            BatteryHistEntry.KEY_UID,
-                BatteryHistEntry.KEY_PACKAGE_NAME,
+                            BatteryHistEntry.KEY_USER_ID,
-                BatteryHistEntry.KEY_TIMESTAMP,
+                            BatteryHistEntry.KEY_PACKAGE_NAME,
-                BatteryHistEntry.KEY_CONSUMER_TYPE,
+                            BatteryHistEntry.KEY_TIMESTAMP,
-                BatteryHistEntry.KEY_BATTERY_INFORMATION});
+                            BatteryHistEntry.KEY_CONSUMER_TYPE,
+                            BatteryHistEntry.KEY_BATTERY_INFORMATION
+                        });
         DeviceBatteryState deviceBatteryState =
-                DeviceBatteryState
+                DeviceBatteryState.newBuilder()
-                        .newBuilder()
                         .setBatteryLevel(batteryLevel)
                         .setBatteryStatus(BatteryManager.BATTERY_STATUS_FULL)
                         .setBatteryHealth(BatteryManager.BATTERY_HEALTH_COLD)
                         .build();
         BatteryInformation batteryInformation =
-                BatteryInformation
+                BatteryInformation.newBuilder()
-                        .newBuilder()
                         .setDeviceBatteryState(deviceBatteryState)
                         .setIsHidden(true)
                         .setBootTimestamp(bootTimestamp)
@@ -394,13 +409,14 @@ public final class BatteryHistEntryTest {
                         .setBackgroundUsageTimeInMs(backgroundUsageTimeInMs)
                         .build();
         cursor.addRow(
-            new Object[]{
+                new Object[] {
-                Long.valueOf(1001),
+                    Long.valueOf(1001),
-                Long.valueOf(UserHandle.getUserId(1001)),
+                    Long.valueOf(UserHandle.getUserId(1001)),
-                "com.google.android.settings.battery",
+                    "com.google.android.settings.battery",
-                Long.valueOf(timestamp),
+                    Long.valueOf(timestamp),
-                Integer.valueOf(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY),
+                    Integer.valueOf(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY),
-                ConvertUtils.convertBatteryInformationToString(batteryInformation)});
+                    ConvertUtils.convertBatteryInformationToString(batteryInformation)
+                });
         cursor.moveToFirst();
         return new BatteryHistEntry(cursor);
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistoryPreferenceTest.java

@@ -38,14 +38,10 @@ import org.robolectric.RuntimeEnvironment;
 
 @RunWith(RobolectricTestRunner.class)
 public class BatteryHistoryPreferenceTest {
-    @Mock
+    @Mock private PreferenceViewHolder mViewHolder;
-    private PreferenceViewHolder mViewHolder;
+    @Mock private TextView mTextView;
-    @Mock
+    @Mock private BatteryChartView mDailyChartView;
-    private TextView mTextView;
+    @Mock private BatteryChartView mHourlyChartView;
-    @Mock
-    private BatteryChartView mDailyChartView;
-    @Mock
-    private BatteryChartView mHourlyChartView;
     private BatteryHistoryPreference mBatteryHistoryPreference;
 
     @Before

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryLevelDataTest.java

@@ -42,129 +42,143 @@ public class BatteryLevelDataTest {
     @Test
     public void getDailyTimestamps_allDataInOneHour_returnExpectedList() {
         // Timezone GMT+8
-        final List<Long> timestamps = List.of(
+        final List<Long> timestamps =
-                1640970006000L, // 2022-01-01 01:00:06
+                List.of(
-                1640973608000L  // 2022-01-01 01:00:08
+                        1640970006000L, // 2022-01-01 01:00:06
-        );
+                        1640973608000L // 2022-01-01 01:00:08
+                        );
 
-        final List<Long> expectedTimestamps = List.of(
+        final List<Long> expectedTimestamps =
-                1640970006000L, // 2022-01-01 01:00:06
+                List.of(
-                1640973608000L  // 2022-01-01 01:00:08
+                        1640970006000L, // 2022-01-01 01:00:06
-        );
+                        1640973608000L // 2022-01-01 01:00:08
+                        );
         assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
     }
 
     @Test
     public void getDailyTimestamps_OneHourDataPerDay_returnExpectedList() {
         // Timezone GMT+8
-        final List<Long> timestamps = List.of(
+        final List<Long> timestamps =
-                1641049200000L, // 2022-01-01 23:00:00
+                List.of(
-                1641052800000L, // 2022-01-02 00:00:00
+                        1641049200000L, // 2022-01-01 23:00:00
-                1641056400000L  // 2022-01-02 01:00:00
+                        1641052800000L, // 2022-01-02 00:00:00
-        );
+                        1641056400000L // 2022-01-02 01:00:00
+                        );
 
-        final List<Long> expectedTimestamps = List.of(
+        final List<Long> expectedTimestamps =
-                1641049200000L, // 2022-01-01 23:00:00
+                List.of(
-                1641052800000L, // 2022-01-02 00:00:00
+                        1641049200000L, // 2022-01-01 23:00:00
-                1641056400000L  // 2022-01-02 01:00:00
+                        1641052800000L, // 2022-01-02 00:00:00
-        );
+                        1641056400000L // 2022-01-02 01:00:00
+                        );
         assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
     }
 
     @Test
     public void getDailyTimestamps_OneDayData_returnExpectedList() {
         // Timezone GMT+8
-        final List<Long> timestamps = List.of(
+        final List<Long> timestamps =
-                1640966400000L, // 2022-01-01 00:00:00
+                List.of(
-                1640970000000L, // 2022-01-01 01:00:00
+                        1640966400000L, // 2022-01-01 00:00:00
-                1640973600000L, // 2022-01-01 02:00:00
+                        1640970000000L, // 2022-01-01 01:00:00
-                1640977200000L, // 2022-01-01 03:00:00
+                        1640973600000L, // 2022-01-01 02:00:00
-                1640980800000L  // 2022-01-01 04:00:00
+                        1640977200000L, // 2022-01-01 03:00:00
-        );
+                        1640980800000L // 2022-01-01 04:00:00
+                        );
 
-        final List<Long> expectedTimestamps = List.of(
+        final List<Long> expectedTimestamps =
-                1640966400000L, // 2022-01-01 00:00:00
+                List.of(
-                1640980800000L  // 2022-01-01 04:00:00
+                        1640966400000L, // 2022-01-01 00:00:00
-        );
+                        1640980800000L // 2022-01-01 04:00:00
+                        );
         assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
     }
 
     @Test
     public void getDailyTimestamps_MultipleDaysData_returnExpectedList() {
         // Timezone GMT+8
-        final List<Long> timestamps = List.of(
+        final List<Long> timestamps =
-                1641045600000L, // 2022-01-01 22:00:00
+                List.of(
-                1641060000000L, // 2022-01-02 02:00:00
+                        1641045600000L, // 2022-01-01 22:00:00
-                1641160800000L, // 2022-01-03 06:00:00
+                        1641060000000L, // 2022-01-02 02:00:00
-                1641232800000L  // 2022-01-04 02:00:00
+                        1641160800000L, // 2022-01-03 06:00:00
-        );
+                        1641232800000L // 2022-01-04 02:00:00
+                        );
 
-        final List<Long> expectedTimestamps = List.of(
+        final List<Long> expectedTimestamps =
-                1641045600000L, // 2022-01-01 22:00:00
+                List.of(
-                1641052800000L, // 2022-01-02 00:00:00
+                        1641045600000L, // 2022-01-01 22:00:00
-                1641139200000L, // 2022-01-03 00:00:00
+                        1641052800000L, // 2022-01-02 00:00:00
-                1641225600000L, // 2022-01-04 00:00:00
+                        1641139200000L, // 2022-01-03 00:00:00
-                1641232800000L  // 2022-01-04 02:00:00
+                        1641225600000L, // 2022-01-04 00:00:00
-        );
+                        1641232800000L // 2022-01-04 02:00:00
+                        );
         assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
     }
 
     @Test
     public void getDailyTimestamps_FirstDayOneHourData_returnExpectedList() {
         // Timezone GMT+8
-        final List<Long> timestamps = List.of(
+        final List<Long> timestamps =
-                1641049200000L, // 2022-01-01 23:00:00
+                List.of(
-                1641060000000L, // 2022-01-02 02:00:00
+                        1641049200000L, // 2022-01-01 23:00:00
-                1641160800000L, // 2022-01-03 06:00:00
+                        1641060000000L, // 2022-01-02 02:00:00
-                1641254400000L  // 2022-01-04 08:00:00
+                        1641160800000L, // 2022-01-03 06:00:00
-        );
+                        1641254400000L // 2022-01-04 08:00:00
+                        );
 
-        final List<Long> expectedTimestamps = List.of(
+        final List<Long> expectedTimestamps =
-                1641049200000L, // 2022-01-01 23:00:00
+                List.of(
-                1641052800000L, // 2022-01-02 00:00:00
+                        1641049200000L, // 2022-01-01 23:00:00
-                1641139200000L, // 2022-01-03 00:00:00
+                        1641052800000L, // 2022-01-02 00:00:00
-                1641225600000L, // 2022-01-04 00:00:00
+                        1641139200000L, // 2022-01-03 00:00:00
-                1641254400000L  // 2022-01-04 08:00:00
+                        1641225600000L, // 2022-01-04 00:00:00
-        );
+                        1641254400000L // 2022-01-04 08:00:00
+                        );
         assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
     }
 
     @Test
     public void getDailyTimestamps_LastDayNoData_returnExpectedList() {
         // Timezone GMT+8
-        final List<Long> timestamps = List.of(
+        final List<Long> timestamps =
-                1640988000000L, // 2022-01-01 06:00:00
+                List.of(
-                1641060000000L, // 2022-01-02 02:00:00
+                        1640988000000L, // 2022-01-01 06:00:00
-                1641160800000L, // 2022-01-03 06:00:00
+                        1641060000000L, // 2022-01-02 02:00:00
-                1641225600000L  // 2022-01-04 00:00:00
+                        1641160800000L, // 2022-01-03 06:00:00
-        );
+                        1641225600000L // 2022-01-04 00:00:00
+                        );
 
-        final List<Long> expectedTimestamps = List.of(
+        final List<Long> expectedTimestamps =
-                1640988000000L, // 2022-01-01 06:00:00
+                List.of(
-                1641052800000L, // 2022-01-02 00:00:00
+                        1640988000000L, // 2022-01-01 06:00:00
-                1641139200000L, // 2022-01-03 00:00:00
+                        1641052800000L, // 2022-01-02 00:00:00
-                1641225600000L  // 2022-01-04 00:00:00
+                        1641139200000L, // 2022-01-03 00:00:00
-        );
+                        1641225600000L // 2022-01-04 00:00:00
+                        );
         assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
     }
 
     @Test
     public void getDailyTimestamps_LastDayOneHourData_returnExpectedList() {
         // Timezone GMT+8
-        final List<Long> timestamps = List.of(
+        final List<Long> timestamps =
-                1640988000000L, // 2022-01-01 06:00:00
+                List.of(
-                1641060000000L, // 2022-01-02 02:00:00
+                        1640988000000L, // 2022-01-01 06:00:00
-                1641160800000L, // 2022-01-03 06:00:00
+                        1641060000000L, // 2022-01-02 02:00:00
-                1641229200000L  // 2022-01-04 01:00:00
+                        1641160800000L, // 2022-01-03 06:00:00
-        );
+                        1641229200000L // 2022-01-04 01:00:00
+                        );
 
-        final List<Long> expectedTimestamps = List.of(
+        final List<Long> expectedTimestamps =
-                1640988000000L, // 2022-01-01 06:00:00
+                List.of(
-                1641052800000L, // 2022-01-02 00:00:00
+                        1640988000000L, // 2022-01-01 06:00:00
-                1641139200000L, // 2022-01-03 00:00:00
+                        1641052800000L, // 2022-01-02 00:00:00
-                1641225600000L, // 2022-01-04 00:00:00
+                        1641139200000L, // 2022-01-03 00:00:00
-                1641229200000L  // 2022-01-04 01:00:00
+                        1641225600000L, // 2022-01-04 00:00:00
-        );
+                        1641229200000L // 2022-01-04 01:00:00
+                        );
         assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
     }
 
@@ -172,21 +186,26 @@ public class BatteryLevelDataTest {
     public void combine_normalFlow_returnExpectedResult() {
         final BatteryLevelData batteryLevelData =
                 new BatteryLevelData(Map.of(1691596800000L, 90, 1691604000000L, 80));
-        final List<BatteryEvent> batteryLevelRecordEvents = List.of(
+        final List<BatteryEvent> batteryLevelRecordEvents =
-                BatteryEvent.newBuilder().setTimestamp(1691586000166L).setBatteryLevel(100)
+                List.of(
-                        .setType(BatteryEventType.FULL_CHARGED).build(),
+                        BatteryEvent.newBuilder()
-                BatteryEvent.newBuilder().setTimestamp(1691589600000L).setBatteryLevel(98)
+                                .setTimestamp(1691586000166L)
-                        .setType(BatteryEventType.EVEN_HOUR).build());
+                                .setBatteryLevel(100)
+                                .setType(BatteryEventType.FULL_CHARGED)
+                                .build(),
+                        BatteryEvent.newBuilder()
+                                .setTimestamp(1691589600000L)
+                                .setBatteryLevel(98)
+                                .setType(BatteryEventType.EVEN_HOUR)
+                                .build());
 
         BatteryLevelData result =
                 BatteryLevelData.combine(batteryLevelData, batteryLevelRecordEvents);
 
         assertThat(result.getDailyBatteryLevels().getTimestamps())
                 .isEqualTo(List.of(1691586000166L, 1691596800000L, 1691604000000L));
-        assertThat(result.getDailyBatteryLevels().getLevels())
+        assertThat(result.getDailyBatteryLevels().getLevels()).isEqualTo(List.of(100, 90, 80));
-                .isEqualTo(List.of(100, 90, 80));
+        assertThat(result.getHourlyBatteryLevelsPerDay()).hasSize(2);
-        assertThat(result.getHourlyBatteryLevelsPerDay())
-                .hasSize(2);
         assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getTimestamps())
                 .isEqualTo(List.of(1691586000166L, 1691589600000L, 1691596800000L));
         assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getLevels())
@@ -199,17 +218,22 @@ public class BatteryLevelDataTest {
 
     @Test
     public void combine_existingBatteryLevelDataIsNull_returnExpectedResult() {
-        final List<BatteryEvent> batteryLevelRecordEvents = List.of(
+        final List<BatteryEvent> batteryLevelRecordEvents =
-                BatteryEvent.newBuilder().setTimestamp(1691586000166L).setBatteryLevel(100)
+                List.of(
-                        .setType(BatteryEventType.FULL_CHARGED).build(),
+                        BatteryEvent.newBuilder()
-                BatteryEvent.newBuilder().setTimestamp(1691589600000L).setBatteryLevel(98)
+                                .setTimestamp(1691586000166L)
-                        .setType(BatteryEventType.EVEN_HOUR).build());
+                                .setBatteryLevel(100)
+                                .setType(BatteryEventType.FULL_CHARGED)
+                                .build(),
+                        BatteryEvent.newBuilder()
+                                .setTimestamp(1691589600000L)
+                                .setBatteryLevel(98)
+                                .setType(BatteryEventType.EVEN_HOUR)
+                                .build());
 
-        BatteryLevelData result =
+        BatteryLevelData result = BatteryLevelData.combine(null, batteryLevelRecordEvents);
-                BatteryLevelData.combine(null, batteryLevelRecordEvents);
 
-        assertThat(result.getHourlyBatteryLevelsPerDay())
+        assertThat(result.getHourlyBatteryLevelsPerDay()).hasSize(1);
-                .hasSize(1);
         assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getTimestamps())
                 .isEqualTo(List.of(1691586000166L, 1691589600000L));
         assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getLevels())
@@ -219,25 +243,31 @@ public class BatteryLevelDataTest {
     @Test
     public void getIndexByTimestamps_returnExpectedResult() {
         final BatteryLevelData batteryLevelData =
-                new BatteryLevelData(Map.of(
+                new BatteryLevelData(
-                        1694354400000L, 1,      // 2023-09-10 22:00:00
+                        Map.of(
-                        1694361600000L, 2,      // 2023-09-11 00:00:00
+                                1694354400000L, 1, // 2023-09-10 22:00:00
-                        1694368800000L, 3));    // 2023-09-11 02:00:00
+                                1694361600000L, 2, // 2023-09-11 00:00:00
+                                1694368800000L, 3)); // 2023-09-11 02:00:00
         final PowerAnomalyEvent event = BatteryTestUtils.createAppAnomalyEvent();
 
         assertThat(batteryLevelData.getIndexByTimestamps(0L, 0L))
-                .isEqualTo(Pair.create(BatteryChartViewModel.SELECTED_INDEX_INVALID,
+                .isEqualTo(
-                        BatteryChartViewModel.SELECTED_INDEX_INVALID));
+                        Pair.create(
+                                BatteryChartViewModel.SELECTED_INDEX_INVALID,
+                                BatteryChartViewModel.SELECTED_INDEX_INVALID));
         assertThat(batteryLevelData.getIndexByTimestamps(1694361600000L + 1L, 1694368800000L + 1L))
-                .isEqualTo(Pair.create(BatteryChartViewModel.SELECTED_INDEX_INVALID,
+                .isEqualTo(
-                        BatteryChartViewModel.SELECTED_INDEX_INVALID));
+                        Pair.create(
+                                BatteryChartViewModel.SELECTED_INDEX_INVALID,
+                                BatteryChartViewModel.SELECTED_INDEX_INVALID));
         assertThat(batteryLevelData.getIndexByTimestamps(1694361600000L, 1694368800000L))
                 .isEqualTo(Pair.create(1, 0));
         assertThat(batteryLevelData.getIndexByTimestamps(1694361600000L + 1L, 1694368800000L - 1L))
                 .isEqualTo(Pair.create(1, 0));
-        assertThat(batteryLevelData.getIndexByTimestamps(
+        assertThat(
-                event.getWarningItemInfo().getStartTimestamp(),
+                        batteryLevelData.getIndexByTimestamps(
-                event.getWarningItemInfo().getEndTimestamp()))
+                                event.getWarningItemInfo().getStartTimestamp(),
+                                event.getWarningItemInfo().getEndTimestamp()))
                 .isEqualTo(Pair.create(1, 0));
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryTipsCardPreferenceTest.java

@@ -61,19 +61,16 @@ public final class BatteryTipsCardPreferenceTest {
     private BatteryTipsController mBatteryTipsController;
     private BatteryChartPreferenceController mBatteryChartPreferenceController;
 
-    @Mock
+    @Mock private View mFakeView;
-    private View mFakeView;
+    @Mock private BatteryUsageBreakdownController mBatteryUsageBreakdownController;
-    @Mock
+    @Mock private BatteryDiffEntry mFakeEntry;
-    private BatteryUsageBreakdownController mBatteryUsageBreakdownController;
-    @Mock
-    private BatteryDiffEntry mFakeEntry;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = spy(RuntimeEnvironment.application);
         mFeatureFactory = FakeFeatureFactory.setupForTest();
-        mBatteryTipsCardPreference = new BatteryTipsCardPreference(mContext, /*attrs=*/ null);
+        mBatteryTipsCardPreference = new BatteryTipsCardPreference(mContext, /* attrs= */ null);
         mBatteryTipsController = new BatteryTipsController(mContext);
         mBatteryChartPreferenceController =
                 spy(new BatteryChartPreferenceController(mContext, null, null));
@@ -85,17 +82,20 @@ public final class BatteryTipsCardPreferenceTest {
         mPowerUsageAdvanced.mBatteryTipsController = mBatteryTipsController;
         mPowerUsageAdvanced.mBatteryChartPreferenceController = mBatteryChartPreferenceController;
         mPowerUsageAdvanced.mBatteryUsageBreakdownController = mBatteryUsageBreakdownController;
-        mPowerUsageAdvanced.mBatteryLevelData = Optional.of(new BatteryLevelData(Map.of(
+        mPowerUsageAdvanced.mBatteryLevelData =
-                1694354400000L, 1,      // 2023-09-10 22:00:00
+                Optional.of(
-                1694361600000L, 2,      // 2023-09-11 00:00:00
+                        new BatteryLevelData(
-                1694368800000L, 3)));    // 2023-09-11 02:00:00
+                                Map.of(
+                                        1694354400000L, 1, // 2023-09-10 22:00:00
+                                        1694361600000L, 2, // 2023-09-11 00:00:00
+                                        1694368800000L, 3))); // 2023-09-11 02:00:00
         doReturn("TestEntriesKey").when(mFakeEntry).getKey();
     }
 
     @Test
     public void constructor_returnExpectedResult() {
-        assertThat(mBatteryTipsCardPreference.getLayoutResource()).isEqualTo(
+        assertThat(mBatteryTipsCardPreference.getLayoutResource())
-                R.layout.battery_tips_card);
+                .isEqualTo(R.layout.battery_tips_card);
     }
 
     @Test
@@ -118,10 +118,13 @@ public final class BatteryTipsCardPreferenceTest {
                 .isEqualTo(DisplaySettings.class.getName());
         assertThat(intent.getIntExtra(MetricsFeatureProvider.EXTRA_SOURCE_METRICS_CATEGORY, -1))
                 .isEqualTo(SettingsEnums.DISPLAY);
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "BrightnessAnomaly");
+                .action(mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "BrightnessAnomaly");
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_ACCEPT, "BrightnessAnomaly");
+                .action(
+                        mContext,
+                        SettingsEnums.ACTION_BATTERY_TIPS_CARD_ACCEPT,
+                        "BrightnessAnomaly");
     }
 
     @Test
@@ -140,10 +143,16 @@ public final class BatteryTipsCardPreferenceTest {
         assertThat(DatabaseUtils.getDismissedPowerAnomalyKeys(mContext)).hasSize(1);
         assertThat(DatabaseUtils.getDismissedPowerAnomalyKeys(mContext))
                 .contains(PowerAnomalyKey.KEY_SCREEN_TIMEOUT.name());
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "ScreenTimeoutAnomaly");
+                .action(
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+                        mContext,
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_DISMISS, "ScreenTimeoutAnomaly");
+                        SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW,
+                        "ScreenTimeoutAnomaly");
+        verify(mFeatureFactory.metricsFeatureProvider)
+                .action(
+                        mContext,
+                        SettingsEnums.ACTION_BATTERY_TIPS_CARD_DISMISS,
+                        "ScreenTimeoutAnomaly");
     }
 
     @Test
@@ -159,13 +168,12 @@ public final class BatteryTipsCardPreferenceTest {
 
         assertThat(mBatteryTipsCardPreference.isVisible()).isFalse();
         verify(mContext, never()).startActivity(any(Intent.class));
-        verify(mBatteryChartPreferenceController).onHighlightSlotIndexUpdate(
+        verify(mBatteryChartPreferenceController).onHighlightSlotIndexUpdate(eq(1), eq(0));
-                eq(1), eq(0));
         verify(mBatteryChartPreferenceController).selectHighlightSlotIndex();
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "AppAnomaly");
+                .action(mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "AppAnomaly");
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_ACCEPT, "AppAnomaly");
+                .action(mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_ACCEPT, "AppAnomaly");
     }
 
     @Test
@@ -180,12 +188,11 @@ public final class BatteryTipsCardPreferenceTest {
 
         assertThat(mBatteryTipsCardPreference.isVisible()).isFalse();
         verify(mContext, never()).startActivity(any(Intent.class));
-        verify(mBatteryChartPreferenceController).onHighlightSlotIndexUpdate(
+        verify(mBatteryChartPreferenceController).onHighlightSlotIndexUpdate(eq(1), eq(0));
-                eq(1), eq(0));
         verify(mBatteryChartPreferenceController, never()).selectHighlightSlotIndex();
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "AppAnomaly");
+                .action(mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "AppAnomaly");
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_DISMISS, "AppAnomaly");
+                .action(mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_DISMISS, "AppAnomaly");
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryTipsControllerTest.java

@@ -48,8 +48,7 @@ public final class BatteryTipsControllerTest {
     private FakeFeatureFactory mFeatureFactory;
     private BatteryTipsController mBatteryTipsController;
 
-    @Mock
+    @Mock private BatteryTipsCardPreference mBatteryTipsCardPreference;
-    private BatteryTipsCardPreference mBatteryTipsCardPreference;
 
     @Before
     public void setUp() {
@@ -82,17 +81,17 @@ public final class BatteryTipsControllerTest {
                 new AnomalyEventWrapper(mContext, event), false);
 
         // Check pre-defined string
-        verify(mBatteryTipsCardPreference).setTitle(
+        verify(mBatteryTipsCardPreference)
-                "Turn on adaptive brightness to extend battery life");
+                .setTitle("Turn on adaptive brightness to extend battery life");
         verify(mBatteryTipsCardPreference).setIconResourceId(R.drawable.ic_battery_tips_lightbulb);
-        verify(mBatteryTipsCardPreference).setMainButtonStrokeColorResourceId(
+        verify(mBatteryTipsCardPreference)
-                R.color.color_accent_selector);
+                .setMainButtonStrokeColorResourceId(R.color.color_accent_selector);
         verify(mBatteryTipsCardPreference).setMainButtonLabel("View Settings");
         verify(mBatteryTipsCardPreference).setDismissButtonLabel("Got it");
         // Check proto info
         verify(mBatteryTipsCardPreference).setVisible(true);
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "BrightnessAnomaly");
+                .action(mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "BrightnessAnomaly");
     }
 
     @Test
@@ -105,25 +104,29 @@ public final class BatteryTipsControllerTest {
 
         verify(mBatteryTipsCardPreference).setTitle("Reduce screen timeout to extend battery life");
         verify(mBatteryTipsCardPreference).setIconResourceId(R.drawable.ic_battery_tips_lightbulb);
-        verify(mBatteryTipsCardPreference).setMainButtonStrokeColorResourceId(
+        verify(mBatteryTipsCardPreference)
-                R.color.color_accent_selector);
+                .setMainButtonStrokeColorResourceId(R.color.color_accent_selector);
         verify(mBatteryTipsCardPreference).setMainButtonLabel("View Settings");
         verify(mBatteryTipsCardPreference).setDismissButtonLabel("Got it");
         verify(mBatteryTipsCardPreference).setVisible(true);
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "ScreenTimeoutAnomaly");
+                .action(
+                        mContext,
+                        SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW,
+                        "ScreenTimeoutAnomaly");
     }
 
     @Test
     public void handleBatteryTipsCardUpdated_screenTimeoutAnomalyHasTitle_showAnomaly() {
         PowerAnomalyEvent event = BatteryTestUtils.createScreenTimeoutAnomalyEvent();
         String testTitle = "TestTitle";
-        event = event.toBuilder()
+        event =
-                .setWarningBannerInfo(
+                event.toBuilder()
-                        event.getWarningBannerInfo().toBuilder()
+                        .setWarningBannerInfo(
-                                .setTitleString(testTitle)
+                                event.getWarningBannerInfo().toBuilder()
-                                .build())
+                                        .setTitleString(testTitle)
-                .build();
+                                        .build())
+                        .build();
         when(mFeatureFactory.powerUsageFeatureProvider.isBatteryTipsEnabled()).thenReturn(true);
 
         mBatteryTipsController.handleBatteryTipsCardUpdated(
@@ -131,13 +134,16 @@ public final class BatteryTipsControllerTest {
 
         verify(mBatteryTipsCardPreference).setTitle(testTitle);
         verify(mBatteryTipsCardPreference).setIconResourceId(R.drawable.ic_battery_tips_lightbulb);
-        verify(mBatteryTipsCardPreference).setMainButtonStrokeColorResourceId(
+        verify(mBatteryTipsCardPreference)
-                R.color.color_accent_selector);
+                .setMainButtonStrokeColorResourceId(R.color.color_accent_selector);
         verify(mBatteryTipsCardPreference).setMainButtonLabel("View Settings");
         verify(mBatteryTipsCardPreference).setDismissButtonLabel("Got it");
         verify(mBatteryTipsCardPreference).setVisible(true);
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "ScreenTimeoutAnomaly");
+                .action(
+                        mContext,
+                        SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW,
+                        "ScreenTimeoutAnomaly");
     }
 
     @Test
@@ -146,20 +152,18 @@ public final class BatteryTipsControllerTest {
         when(mFeatureFactory.powerUsageFeatureProvider.isBatteryTipsEnabled()).thenReturn(true);
 
         AnomalyEventWrapper eventWrapper = new AnomalyEventWrapper(mContext, event);
-        eventWrapper.setRelatedBatteryDiffEntry(
+        eventWrapper.setRelatedBatteryDiffEntry(new BatteryDiffEntry(mContext, "", "Chrome", 0));
-                new BatteryDiffEntry(mContext, "", "Chrome", 0));
         mBatteryTipsController.handleBatteryTipsCardUpdated(eventWrapper, false);
 
-        verify(mBatteryTipsCardPreference).setTitle(
+        verify(mBatteryTipsCardPreference).setTitle("Chrome used more battery than usual");
-                "Chrome used more battery than usual");
+        verify(mBatteryTipsCardPreference)
-        verify(mBatteryTipsCardPreference).setIconResourceId(
+                .setIconResourceId(R.drawable.ic_battery_tips_warning_icon);
-                R.drawable.ic_battery_tips_warning_icon);
+        verify(mBatteryTipsCardPreference)
-        verify(mBatteryTipsCardPreference).setMainButtonStrokeColorResourceId(
+                .setMainButtonStrokeColorResourceId(R.color.color_battery_anomaly_yellow_selector);
-                R.color.color_battery_anomaly_yellow_selector);
         verify(mBatteryTipsCardPreference).setMainButtonLabel("Check");
         verify(mBatteryTipsCardPreference).setDismissButtonLabel("Got it");
         verify(mBatteryTipsCardPreference).setVisible(true);
-        verify(mFeatureFactory.metricsFeatureProvider).action(
+        verify(mFeatureFactory.metricsFeatureProvider)
-                mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "AppAnomaly");
+                .action(mContext, SettingsEnums.ACTION_BATTERY_TIPS_CARD_SHOW, "AppAnomaly");
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownControllerTest.java

@@ -58,18 +58,12 @@ public final class BatteryUsageBreakdownControllerTest {
     private static final String PREF_KEY2 = "pref_key2";
     private static final String PREF_SUMMARY = "fake preference summary";
 
-    @Mock
+    @Mock private InstrumentedPreferenceFragment mFragment;
-    private InstrumentedPreferenceFragment mFragment;
+    @Mock private SettingsActivity mSettingsActivity;
-    @Mock
+    @Mock private PreferenceGroup mAppListPreferenceGroup;
-    private SettingsActivity mSettingsActivity;
+    @Mock private Drawable mDrawable;
-    @Mock
+    @Mock private BatteryHistEntry mBatteryHistEntry;
-    private PreferenceGroup mAppListPreferenceGroup;
+    @Mock private AnomalyAppItemPreference mAnomalyAppItemPreference;
-    @Mock
-    private Drawable mDrawable;
-    @Mock
-    private BatteryHistEntry mBatteryHistEntry;
-    @Mock
-    private AnomalyAppItemPreference mAnomalyAppItemPreference;
 
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
@@ -94,43 +88,51 @@ public final class BatteryUsageBreakdownControllerTest {
                 .getHideApplicationSet();
         mBatteryUsageBreakdownController = createController();
         mBatteryUsageBreakdownController.mAppListPreferenceGroup = mAppListPreferenceGroup;
-        mBatteryDiffEntry = new BatteryDiffEntry(
+        mBatteryDiffEntry =
-                mContext,
+                new BatteryDiffEntry(
-                /*uid=*/ 0L,
+                        mContext,
-                /*userId=*/ 0L,
+                        /* uid= */ 0L,
-                /*key=*/ "key",
+                        /* userId= */ 0L,
-                /*isHidden=*/ false,
+                        /* key= */ "key",
-                /*componentId=*/ -1,
+                        /* isHidden= */ false,
-                /*legacyPackageName=*/ null,
+                        /* componentId= */ -1,
-                /*legacyLabel=*/ null,
+                        /* legacyPackageName= */ null,
-                /*consumerType=*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
+                        /* legacyLabel= */ null,
-                /*foregroundUsageTimeInMs=*/ 1,
+                        /* consumerType= */ ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
-                /*backgroundUsageTimeInMs=*/ 2,
+                        /* foregroundUsageTimeInMs= */ 1,
-                /*screenOnTimeInMs=*/ 0,
+                        /* backgroundUsageTimeInMs= */ 2,
-                /*consumePower=*/ 3,
+                        /* screenOnTimeInMs= */ 0,
-                /*foregroundUsageConsumePower=*/ 0,
+                        /* consumePower= */ 3,
-                /*foregroundServiceUsageConsumePower=*/ 1,
+                        /* foregroundUsageConsumePower= */ 0,
-                /*backgroundUsageConsumePower=*/ 2,
+                        /* foregroundServiceUsageConsumePower= */ 1,
-                /*cachedUsageConsumePower=*/ 0);
+                        /* backgroundUsageConsumePower= */ 2,
+                        /* cachedUsageConsumePower= */ 0);
         mBatteryDiffEntry = spy(mBatteryDiffEntry);
         mBatteryUsageBreakdownController.mBatteryDiffData =
-                new BatteryDiffData(mContext, /* startTimestamp= */ 0L, /* endTimestamp= */ 0L,
+                new BatteryDiffData(
-                        /* startBatteryLevel= */ 0, /* endBatteryLevel= */ 0,
+                        mContext,
-                        /* screenOnTime= */ 0L, Arrays.asList(mBatteryDiffEntry), Arrays.asList(),
+                        /* startTimestamp= */ 0L,
-                        Set.of(), Set.of(), /* isAccumulated= */ false);
+                        /* endTimestamp= */ 0L,
+                        /* startBatteryLevel= */ 0,
+                        /* endBatteryLevel= */ 0,
+                        /* screenOnTime= */ 0L,
+                        Arrays.asList(mBatteryDiffEntry),
+                        Arrays.asList(),
+                        Set.of(),
+                        Set.of(),
+                        /* isAccumulated= */ false);
         BatteryDiffEntry.clearCache();
         // Adds fake testing data.
         BatteryDiffEntry.sResourceCache.put(
                 "fakeBatteryDiffEntryKey",
-                new BatteryEntry.NameAndIcon("fakeName", /*icon=*/ null, /*iconId=*/ 1));
+                new BatteryEntry.NameAndIcon("fakeName", /* icon= */ null, /* iconId= */ 1));
         doReturn(mAnomalyAppItemPreference).when(mAppListPreferenceGroup).findPreference(PREF_KEY);
     }
 
     @Test
     public void onDestroy_clearPreferenceCacheAndPreferenceGroupRemoveAll() {
         // Ensures the testing environment is correct.
-        mBatteryUsageBreakdownController.mPreferenceCache.put(
+        mBatteryUsageBreakdownController.mPreferenceCache.put(PREF_KEY, mAnomalyAppItemPreference);
-                PREF_KEY, mAnomalyAppItemPreference);
         assertThat(mBatteryUsageBreakdownController.mPreferenceCache).hasSize(1);
 
         mBatteryUsageBreakdownController.onDestroy();
@@ -158,8 +160,8 @@ public final class BatteryUsageBreakdownControllerTest {
 
         // Verifies the preference cache.
         final PowerGaugePreference pref =
-                (PowerGaugePreference) mBatteryUsageBreakdownController.mPreferenceCache
+                (PowerGaugePreference)
-                        .get(PREF_KEY);
+                        mBatteryUsageBreakdownController.mPreferenceCache.get(PREF_KEY);
         assertThat(pref).isNotNull();
         // Verifies the added preference configuration.
         verify(mAppListPreferenceGroup).addPreference(pref);
@@ -218,8 +220,10 @@ public final class BatteryUsageBreakdownControllerTest {
 
     @Test
     public void handlePreferenceTreeClick_notPowerGaugePreference_returnFalse() {
-        assertThat(mBatteryUsageBreakdownController
+        assertThat(
-                .handlePreferenceTreeClick(mAppListPreferenceGroup)).isFalse();
+                        mBatteryUsageBreakdownController.handlePreferenceTreeClick(
+                                mAppListPreferenceGroup))
+                .isFalse();
 
         verify(mMetricsFeatureProvider, never())
                 .action(mContext, SettingsEnums.ACTION_BATTERY_USAGE_APP_ITEM);
@@ -232,8 +236,10 @@ public final class BatteryUsageBreakdownControllerTest {
         mBatteryDiffEntry.mConsumerType = ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY;
         doReturn(mBatteryDiffEntry).when(mAnomalyAppItemPreference).getBatteryDiffEntry();
 
-        assertThat(mBatteryUsageBreakdownController.handlePreferenceTreeClick(
+        assertThat(
-                mAnomalyAppItemPreference)).isTrue();
+                        mBatteryUsageBreakdownController.handlePreferenceTreeClick(
+                                mAnomalyAppItemPreference))
+                .isTrue();
         verify(mMetricsFeatureProvider)
                 .action(
                         SettingsEnums.OPEN_BATTERY_USAGE,
@@ -248,8 +254,10 @@ public final class BatteryUsageBreakdownControllerTest {
         mBatteryDiffEntry.mConsumerType = ConvertUtils.CONSUMER_TYPE_UID_BATTERY;
         doReturn(mBatteryDiffEntry).when(mAnomalyAppItemPreference).getBatteryDiffEntry();
 
-        assertThat(mBatteryUsageBreakdownController.handlePreferenceTreeClick(
+        assertThat(
-                mAnomalyAppItemPreference)).isTrue();
+                        mBatteryUsageBreakdownController.handlePreferenceTreeClick(
+                                mAnomalyAppItemPreference))
+                .isTrue();
         verify(mMetricsFeatureProvider)
                 .action(
                         SettingsEnums.OPEN_BATTERY_USAGE,
@@ -262,11 +270,12 @@ public final class BatteryUsageBreakdownControllerTest {
     @Test
     public void setPreferencePercent_lessThanThreshold_expectedFormat() {
         final PowerGaugePreference pref = new PowerGaugePreference(mContext);
-        final BatteryDiffEntry batteryDiffEntry = createBatteryDiffEntry(
+        final BatteryDiffEntry batteryDiffEntry =
-                /*isSystem=*/ true,
+                createBatteryDiffEntry(
-                /*screenOnTimeInMs=*/ 0,
+                        /* isSystem= */ true,
-                /*foregroundUsageTimeInMs=*/ 0,
+                        /* screenOnTimeInMs= */ 0,
-                /*backgroundUsageTimeInMs=*/ 0);
+                        /* foregroundUsageTimeInMs= */ 0,
+                        /* backgroundUsageTimeInMs= */ 0);
         batteryDiffEntry.mConsumePower = 0.8;
         batteryDiffEntry.setTotalConsumePower(100);
         mBatteryUsageBreakdownController.mPercentLessThanThresholdText = "< 1%";
@@ -279,11 +288,12 @@ public final class BatteryUsageBreakdownControllerTest {
     @Test
     public void setPreferencePercent_greaterThanThreshold_expectedFormat() {
         final PowerGaugePreference pref = new PowerGaugePreference(mContext);
-        final BatteryDiffEntry batteryDiffEntry = createBatteryDiffEntry(
+        final BatteryDiffEntry batteryDiffEntry =
-                /*isSystem=*/ true,
+                createBatteryDiffEntry(
-                /*screenOnTimeInMs=*/ 0,
+                        /* isSystem= */ true,
-                /*foregroundUsageTimeInMs=*/ 0,
+                        /* screenOnTimeInMs= */ 0,
-                /*backgroundUsageTimeInMs=*/ 0);
+                        /* foregroundUsageTimeInMs= */ 0,
+                        /* backgroundUsageTimeInMs= */ 0);
         batteryDiffEntry.mConsumePower = 16;
         batteryDiffEntry.setTotalConsumePower(100);
         mBatteryUsageBreakdownController.mPercentLessThanThresholdText = "< 1%";
@@ -299,11 +309,12 @@ public final class BatteryUsageBreakdownControllerTest {
         pref.setSummary(PREF_SUMMARY);
 
         mBatteryUsageBreakdownController.setPreferenceSummary(
-                pref, createBatteryDiffEntry(
+                pref,
-                        /*isSystem=*/ true,
+                createBatteryDiffEntry(
-                        /*screenOnTimeInMs=*/ 0,
+                        /* isSystem= */ true,
-                        /*foregroundUsageTimeInMs=*/ 0,
+                        /* screenOnTimeInMs= */ 0,
-                        /*backgroundUsageTimeInMs=*/ 0));
+                        /* foregroundUsageTimeInMs= */ 0,
+                        /* backgroundUsageTimeInMs= */ 0));
         assertThat(pref.getSummary().toString().isEmpty()).isTrue();
     }
 
@@ -313,11 +324,12 @@ public final class BatteryUsageBreakdownControllerTest {
         pref.setSummary(PREF_SUMMARY);
 
         mBatteryUsageBreakdownController.setPreferenceSummary(
-                pref, createBatteryDiffEntry(
+                pref,
-                        /*isSystem=*/ true,
+                createBatteryDiffEntry(
-                        /*screenOnTimeInMs=*/ 0,
+                        /* isSystem= */ true,
-                        /*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS - 1,
+                        /* screenOnTimeInMs= */ 0,
-                        /*backgroundUsageTimeInMs=*/ 0));
+                        /* foregroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1,
+                        /* backgroundUsageTimeInMs= */ 0));
         assertThat(pref.getSummary().toString()).isEqualTo("Total: less than a min");
     }
 
@@ -327,11 +339,12 @@ public final class BatteryUsageBreakdownControllerTest {
         pref.setSummary(PREF_SUMMARY);
 
         mBatteryUsageBreakdownController.setPreferenceSummary(
-                pref, createBatteryDiffEntry(
+                pref,
-                        /*isSystem=*/ true,
+                createBatteryDiffEntry(
-                        /*screenOnTimeInMs=*/ 0,
+                        /* isSystem= */ true,
-                        /*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS * 2,
+                        /* screenOnTimeInMs= */ 0,
-                        /*backgroundUsageTimeInMs=*/ 0));
+                        /* foregroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS * 2,
+                        /* backgroundUsageTimeInMs= */ 0));
         assertThat(pref.getSummary().toString()).isEqualTo("Total: 2 min");
     }
 
@@ -341,11 +354,12 @@ public final class BatteryUsageBreakdownControllerTest {
         pref.setSummary(PREF_SUMMARY);
 
         mBatteryUsageBreakdownController.setPreferenceSummary(
-                pref, createBatteryDiffEntry(
+                pref,
-                        /*isSystem=*/ false,
+                createBatteryDiffEntry(
-                        /*screenOnTimeInMs=*/ 0,
+                        /* isSystem= */ false,
-                        /*foregroundUsageTimeInMs=*/ 0,
+                        /* screenOnTimeInMs= */ 0,
-                        /*backgroundUsageTimeInMs=*/ 0));
+                        /* foregroundUsageTimeInMs= */ 0,
+                        /* backgroundUsageTimeInMs= */ 0));
         assertThat(pref.getSummary().toString().isEmpty()).isTrue();
     }
 
@@ -355,11 +369,12 @@ public final class BatteryUsageBreakdownControllerTest {
         pref.setSummary(PREF_SUMMARY);
 
         mBatteryUsageBreakdownController.setPreferenceSummary(
-                pref, createBatteryDiffEntry(
+                pref,
-                        /*isSystem=*/ false,
+                createBatteryDiffEntry(
-                        /*screenOnTimeInMs=*/ 0,
+                        /* isSystem= */ false,
-                        /*foregroundUsageTimeInMs=*/ 0,
+                        /* screenOnTimeInMs= */ 0,
-                        /*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS));
+                        /* foregroundUsageTimeInMs= */ 0,
+                        /* backgroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS));
         assertThat(pref.getSummary().toString()).isEqualTo("Background: 1 min");
     }
 
@@ -369,11 +384,12 @@ public final class BatteryUsageBreakdownControllerTest {
         pref.setSummary(PREF_SUMMARY);
 
         mBatteryUsageBreakdownController.setPreferenceSummary(
-                pref, createBatteryDiffEntry(
+                pref,
-                        /*isSystem=*/ false,
+                createBatteryDiffEntry(
-                        /*screenOnTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS,
+                        /* isSystem= */ false,
-                        /*foregroundUsageTimeInMs=*/ 0,
+                        /* screenOnTimeInMs= */ DateUtils.MINUTE_IN_MILLIS,
-                        /*backgroundUsageTimeInMs=*/ 0));
+                        /* foregroundUsageTimeInMs= */ 0,
+                        /* backgroundUsageTimeInMs= */ 0));
         assertThat(pref.getSummary().toString()).isEqualTo("Screen time: 1 min");
     }
 
@@ -383,21 +399,28 @@ public final class BatteryUsageBreakdownControllerTest {
         pref.setSummary(PREF_SUMMARY);
 
         mBatteryUsageBreakdownController.setPreferenceSummary(
-                pref, createBatteryDiffEntry(
+                pref,
-                        /*isSystem=*/ false,
+                createBatteryDiffEntry(
-                        /*screenOnTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS - 1,
+                        /* isSystem= */ false,
-                        /*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS - 1,
+                        /* screenOnTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1,
-                        /*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS - 1));
+                        /* foregroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1,
-        assertThat(pref.getSummary().toString()).isEqualTo(
+                        /* backgroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1));
-                "Screen time: less than a min\nBackground: less than a min");
+        assertThat(pref.getSummary().toString())
+                .isEqualTo("Screen time: less than a min\nBackground: less than a min");
     }
 
-    private BatteryDiffEntry createBatteryDiffEntry(boolean isSystem, long screenOnTimeInMs,
+    private BatteryDiffEntry createBatteryDiffEntry(
-            long foregroundUsageTimeInMs, long backgroundUsageTimeInMs) {
+            boolean isSystem,
+            long screenOnTimeInMs,
+            long foregroundUsageTimeInMs,
+            long backgroundUsageTimeInMs) {
         final ContentValues contentValues = new ContentValues();
-        contentValues.put(BatteryHistEntry.KEY_CONSUMER_TYPE, Integer.valueOf(
+        contentValues.put(
-                isSystem ? ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY
+                BatteryHistEntry.KEY_CONSUMER_TYPE,
-                        : ConvertUtils.CONSUMER_TYPE_UID_BATTERY));
+                Integer.valueOf(
+                        isSystem
+                                ? ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY
+                                : ConvertUtils.CONSUMER_TYPE_UID_BATTERY));
         contentValues.put(BatteryHistEntry.KEY_USER_ID, Integer.valueOf(1001));
         final BatteryHistEntry batteryHistEntry = new BatteryHistEntry(contentValues);
         return new BatteryDiffEntry(
@@ -413,17 +436,17 @@ public final class BatteryUsageBreakdownControllerTest {
                 foregroundUsageTimeInMs,
                 backgroundUsageTimeInMs,
                 screenOnTimeInMs,
-                /*consumePower=*/ 0,
+                /* consumePower= */ 0,
-                /*foregroundUsageConsumePower=*/ 0,
+                /* foregroundUsageConsumePower= */ 0,
-                /*foregroundServiceUsageConsumePower=*/ 0,
+                /* foregroundServiceUsageConsumePower= */ 0,
-                /*backgroundUsageConsumePower=*/ 0,
+                /* backgroundUsageConsumePower= */ 0,
-                /*cachedUsageConsumePower=*/ 0);
+                /* cachedUsageConsumePower= */ 0);
     }
 
     private BatteryUsageBreakdownController createController() {
         final BatteryUsageBreakdownController controller =
                 new BatteryUsageBreakdownController(
-                        mContext, /*lifecycle=*/ null, mSettingsActivity, mFragment);
+                        mContext, /* lifecycle= */ null, mSettingsActivity, mFragment);
         controller.mPrefContext = mContext;
         return controller;
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBroadcastReceiverTest.java

@@ -48,8 +48,7 @@ public final class BatteryUsageBroadcastReceiverTest {
     private BatteryUsageBroadcastReceiver mBatteryUsageBroadcastReceiver;
     private FakeFeatureFactory mFakeFeatureFactory;
 
-    @Mock
+    @Mock private PackageManager mPackageManager;
-    private PackageManager mPackageManager;
 
     @Before
     public void setUp() {
@@ -72,8 +71,8 @@ public final class BatteryUsageBroadcastReceiverTest {
     public void onReceive_workProfile_doNothing() {
         BatteryTestUtils.setWorkProfile(mContext);
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
+                mContext, new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isFalse();
     }
@@ -84,11 +83,12 @@ public final class BatteryUsageBroadcastReceiverTest {
                 .thenReturn(Intent.ACTION_BATTERY_LEVEL_CHANGED);
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(true);
-        doReturn(getBatteryIntent(/*level=*/ 20, BatteryManager.BATTERY_STATUS_UNKNOWN))
+        doReturn(getBatteryIntent(/* level= */ 20, BatteryManager.BATTERY_STATUS_UNKNOWN))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
+                mContext, new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isFalse();
         assertSharedPreferences(Intent.ACTION_BATTERY_LEVEL_CHANGED);
@@ -101,14 +101,15 @@ public final class BatteryUsageBroadcastReceiverTest {
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(true);
         // Make sure isCharged returns true.
-        doReturn(getBatteryIntent(/*level=*/ 100, BatteryManager.BATTERY_STATUS_FULL))
+        doReturn(getBatteryIntent(/* level= */ 100, BatteryManager.BATTERY_STATUS_FULL))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
         // Make sure broadcast will be sent with delay.
         BatteryUsageBroadcastReceiver.sBroadcastDelayFromBoot =
                 SystemClock.elapsedRealtime() + 5 * DateUtils.MINUTE_IN_MILLIS;
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
+                mContext, new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isFalse();
         assertSharedPreferences(Intent.ACTION_BATTERY_LEVEL_CHANGED);
@@ -121,13 +122,14 @@ public final class BatteryUsageBroadcastReceiverTest {
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(true);
         // Make sure isCharged returns true.
-        doReturn(getBatteryIntent(/*level=*/ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
+        doReturn(getBatteryIntent(/* level= */ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
         BatteryUsageBroadcastReceiver.sBroadcastDelayFromBoot =
                 SystemClock.elapsedRealtime() - 5 * DateUtils.MINUTE_IN_MILLIS;
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
+                mContext, new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isFalse();
         assertSharedPreferences(Intent.ACTION_BATTERY_LEVEL_CHANGED);
@@ -140,13 +142,14 @@ public final class BatteryUsageBroadcastReceiverTest {
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(true);
         // Make sure isCharged returns true.
-        doReturn(getBatteryIntent(/*level=*/ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
+        doReturn(getBatteryIntent(/* level= */ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
         BatteryUsageBroadcastReceiver.sBroadcastDelayFromBoot =
                 SystemClock.elapsedRealtime() - 5 * DateUtils.MINUTE_IN_MILLIS;
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
+                mContext, new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isTrue();
         assertSharedPreferences(Intent.ACTION_BATTERY_LEVEL_CHANGED);
@@ -158,11 +161,12 @@ public final class BatteryUsageBroadcastReceiverTest {
                 .thenReturn(Intent.ACTION_POWER_DISCONNECTED);
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(false);
-        doReturn(getBatteryIntent(/*level=*/ 20, BatteryManager.BATTERY_STATUS_UNKNOWN))
+        doReturn(getBatteryIntent(/* level= */ 20, BatteryManager.BATTERY_STATUS_UNKNOWN))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
+                mContext, new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isFalse();
         assertSharedPreferences(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING);
@@ -175,14 +179,15 @@ public final class BatteryUsageBroadcastReceiverTest {
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(false);
         // Make sure isCharged returns true.
-        doReturn(getBatteryIntent(/*level=*/ 100, BatteryManager.BATTERY_STATUS_FULL))
+        doReturn(getBatteryIntent(/* level= */ 100, BatteryManager.BATTERY_STATUS_FULL))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
         // Make sure broadcast will be sent with delay.
         BatteryUsageBroadcastReceiver.sBroadcastDelayFromBoot =
                 SystemClock.elapsedRealtime() + 5 * DateUtils.MINUTE_IN_MILLIS;
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
+                mContext, new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isTrue();
         assertSharedPreferences(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING);
@@ -195,13 +200,14 @@ public final class BatteryUsageBroadcastReceiverTest {
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(false);
         // Make sure isCharged returns true.
-        doReturn(getBatteryIntent(/*level=*/ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
+        doReturn(getBatteryIntent(/* level= */ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
         BatteryUsageBroadcastReceiver.sBroadcastDelayFromBoot =
                 SystemClock.elapsedRealtime() - 5 * DateUtils.MINUTE_IN_MILLIS;
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
+                mContext, new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isFalse();
         assertSharedPreferences(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING);
@@ -214,13 +220,14 @@ public final class BatteryUsageBroadcastReceiverTest {
         when(mFakeFeatureFactory.powerUsageFeatureProvider.delayHourlyJobWhenBooting())
                 .thenReturn(false);
         // Make sure isCharged returns true.
-        doReturn(getBatteryIntent(/*level=*/ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
+        doReturn(getBatteryIntent(/* level= */ 100, BatteryManager.BATTERY_STATUS_UNKNOWN))
-                .when(mContext).registerReceiver(any(), any());
+                .when(mContext)
+                .registerReceiver(any(), any());
         BatteryUsageBroadcastReceiver.sBroadcastDelayFromBoot =
                 SystemClock.elapsedRealtime() - 5 * DateUtils.MINUTE_IN_MILLIS;
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
-                new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
+                mContext, new Intent(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING));
 
         assertThat(mBatteryUsageBroadcastReceiver.mFetchBatteryUsageData).isTrue();
         assertSharedPreferences(BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING);
@@ -234,12 +241,12 @@ public final class BatteryUsageBroadcastReceiverTest {
                 /*packageName*/ "com.android.testing_package", Boolean.valueOf(true));
         assertThat(BatteryDiffEntry.sValidForRestriction).isNotEmpty();
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
+                mContext,
                 new Intent(BatteryUsageBroadcastReceiver.ACTION_CLEAR_BATTERY_CACHE_DATA));
 
         assertThat(BatteryDiffEntry.sValidForRestriction).isEmpty();
-        assertSharedPreferences(
+        assertSharedPreferences(BatteryUsageBroadcastReceiver.ACTION_CLEAR_BATTERY_CACHE_DATA);
-                BatteryUsageBroadcastReceiver.ACTION_CLEAR_BATTERY_CACHE_DATA);
     }
 
     @Test
@@ -250,12 +257,12 @@ public final class BatteryUsageBroadcastReceiverTest {
                 /*packageName*/ "com.android.testing_package", Boolean.valueOf(true));
         assertThat(BatteryDiffEntry.sValidForRestriction).isNotEmpty();
 
-        mBatteryUsageBroadcastReceiver.onReceive(mContext,
+        mBatteryUsageBroadcastReceiver.onReceive(
+                mContext,
                 new Intent(BatteryUsageBroadcastReceiver.ACTION_CLEAR_BATTERY_CACHE_DATA));
 
         assertThat(BatteryDiffEntry.sValidForRestriction).isNotEmpty();
-        assertSharedPreferences(
+        assertSharedPreferences(BatteryUsageBroadcastReceiver.ACTION_CLEAR_BATTERY_CACHE_DATA);
-                BatteryUsageBroadcastReceiver.ACTION_CLEAR_BATTERY_CACHE_DATA);
     }
 
     private static Intent getBatteryIntent(int level, int status) {
@@ -267,7 +274,6 @@ public final class BatteryUsageBroadcastReceiverTest {
     }
 
     private void assertSharedPreferences(String preferenceKey) {
-        assertThat(DatabaseUtils.getSharedPreferences(mContext).contains(preferenceKey))
+        assertThat(DatabaseUtils.getSharedPreferences(mContext).contains(preferenceKey)).isTrue();
-                .isTrue();
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java

@@ -66,7 +66,7 @@ public final class BatteryUsageContentProviderTest {
     public void setUp() {
         mContext = ApplicationProvider.getApplicationContext();
         mProvider = new BatteryUsageContentProvider();
-        mProvider.attachInfo(mContext, /*info=*/ null);
+        mProvider.attachInfo(mContext, /* info= */ null);
         BatteryTestUtils.setUpBatteryStateDatabase(mContext);
     }
 
@@ -95,11 +95,14 @@ public final class BatteryUsageContentProviderTest {
                 IllegalArgumentException.class,
                 () ->
                         mProvider.query(
-                                uri, /*strings=*/ null, /*s=*/ null, /*strings1=*/ null,
+                                uri,
-                                /*s1=*/ null));
+                                /* strings= */ null,
+                                /* s= */ null,
+                                /* strings1= */ null,
+                                /* s1= */ null));
         assertThrows(
                 IllegalArgumentException.class,
-                () -> mProvider.insert(uri, /*contentValues=*/ null));
+                () -> mProvider.insert(uri, /* contentValues= */ null));
     }
 
     @Test
@@ -116,11 +119,14 @@ public final class BatteryUsageContentProviderTest {
                 IllegalArgumentException.class,
                 () ->
                         mProvider.query(
-                                uri, /*strings=*/ null, /*s=*/ null, /*strings1=*/ null,
+                                uri,
-                                /*s1=*/ null));
+                                /* strings= */ null,
+                                /* s= */ null,
+                                /* strings1= */ null,
+                                /* s1= */ null));
         assertThrows(
                 IllegalArgumentException.class,
-                () -> mProvider.insert(uri, /*contentValues=*/ null));
+                () -> mProvider.insert(uri, /* contentValues= */ null));
     }
 
     @Test
@@ -128,7 +134,8 @@ public final class BatteryUsageContentProviderTest {
         mProvider.onCreate();
         ContentValues values = new ContentValues();
         values.put(BatteryEventEntity.KEY_TIMESTAMP, 10001L);
-        values.put(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE,
+        values.put(
+                BatteryEventEntity.KEY_BATTERY_EVENT_TYPE,
                 BatteryEventType.FULL_CHARGED.getNumber());
         values.put(BatteryEventEntity.KEY_BATTERY_LEVEL, 100);
         mProvider.insert(DatabaseUtils.BATTERY_EVENT_URI, values);
@@ -263,15 +270,13 @@ public final class BatteryUsageContentProviderTest {
     public void insert_batteryState_returnsExpectedResult() {
         mProvider.onCreate();
         final DeviceBatteryState deviceBatteryState =
-                DeviceBatteryState
+                DeviceBatteryState.newBuilder()
-                        .newBuilder()
                         .setBatteryLevel(51)
                         .setBatteryStatus(2)
                         .setBatteryHealth(3)
                         .build();
         final BatteryInformation batteryInformation =
-                BatteryInformation
+                BatteryInformation.newBuilder()
-                        .newBuilder()
                         .setDeviceBatteryState(deviceBatteryState)
                         .setAppLabel("Settings")
                         .setIsHidden(true)
@@ -318,17 +323,13 @@ public final class BatteryUsageContentProviderTest {
     public void insert_partialFieldsContentValues_returnsExpectedResult() {
         mProvider.onCreate();
         final DeviceBatteryState deviceBatteryState =
-                DeviceBatteryState
+                DeviceBatteryState.newBuilder()
-                        .newBuilder()
                         .setBatteryLevel(52)
                         .setBatteryStatus(3)
                         .setBatteryHealth(2)
                         .build();
         final BatteryInformation batteryInformation =
-                BatteryInformation
+                BatteryInformation.newBuilder().setDeviceBatteryState(deviceBatteryState).build();
-                        .newBuilder()
-                        .setDeviceBatteryState(deviceBatteryState)
-                        .build();
         final String expectedBatteryInformationString =
                 ConvertUtils.convertBatteryInformationToString(batteryInformation);
         final ContentValues values = new ContentValues();
@@ -381,7 +382,8 @@ public final class BatteryUsageContentProviderTest {
         mProvider.onCreate();
         ContentValues values = new ContentValues();
         values.put(BatteryEventEntity.KEY_TIMESTAMP, 10001L);
-        values.put(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE,
+        values.put(
+                BatteryEventEntity.KEY_BATTERY_EVENT_TYPE,
                 BatteryEventType.POWER_CONNECTED.getNumber());
         values.put(BatteryEventEntity.KEY_BATTERY_LEVEL, 66);
 
@@ -393,24 +395,26 @@ public final class BatteryUsageContentProviderTest {
                 BatteryStateDatabase.getInstance(mContext).batteryEventDao().getAll();
         assertThat(entities).hasSize(1);
         assertThat(entities.get(0).timestamp).isEqualTo(10001L);
-        assertThat(entities.get(0).batteryEventType).isEqualTo(
+        assertThat(entities.get(0).batteryEventType)
-                BatteryEventType.POWER_CONNECTED.getNumber());
+                .isEqualTo(BatteryEventType.POWER_CONNECTED.getNumber());
         assertThat(entities.get(0).batteryLevel).isEqualTo(66);
 
-        final Cursor cursor1 = getCursorOfBatteryEvents(
+        final Cursor cursor1 =
-                0L, List.of(BatteryEventType.POWER_CONNECTED.getNumber()));
+                getCursorOfBatteryEvents(0L, List.of(BatteryEventType.POWER_CONNECTED.getNumber()));
         assertThat(cursor1.getCount()).isEqualTo(1);
         cursor1.moveToFirst();
         assertThat(cursor1.getLong(cursor1.getColumnIndex(BatteryEventEntity.KEY_TIMESTAMP)))
                 .isEqualTo(10001L);
         assertThat(
-                cursor1.getInt(cursor1.getColumnIndex(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE)))
+                        cursor1.getInt(
+                                cursor1.getColumnIndex(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE)))
                 .isEqualTo(BatteryEventType.POWER_CONNECTED.getNumber());
         assertThat(cursor1.getInt(cursor1.getColumnIndex(BatteryEventEntity.KEY_BATTERY_LEVEL)))
                 .isEqualTo(66);
 
-        final Cursor cursor2 = getCursorOfBatteryEvents(
+        final Cursor cursor2 =
-                0L, List.of(BatteryEventType.POWER_DISCONNECTED.getNumber()));
+                getCursorOfBatteryEvents(
+                        0L, List.of(BatteryEventType.POWER_DISCONNECTED.getNumber()));
         assertThat(cursor2.getCount()).isEqualTo(0);
     }
 
@@ -435,8 +439,11 @@ public final class BatteryUsageContentProviderTest {
         cursor1.moveToFirst();
         assertThat(cursor1.getLong(cursor1.getColumnIndex(BatteryUsageSlotEntity.KEY_TIMESTAMP)))
                 .isEqualTo(10001L);
-        assertThat(cursor1.getString(cursor1.getColumnIndex(
+        assertThat(
-                BatteryUsageSlotEntity.KEY_BATTERY_USAGE_SLOT))).isEqualTo("TEST_STRING");
+                        cursor1.getString(
+                                cursor1.getColumnIndex(
+                                        BatteryUsageSlotEntity.KEY_BATTERY_USAGE_SLOT)))
+                .isEqualTo("TEST_STRING");
 
         final Cursor cursor2 = getCursorOfBatteryUsageSlots(10002L);
         assertThat(cursor2.getCount()).isEqualTo(0);
@@ -446,7 +453,7 @@ public final class BatteryUsageContentProviderTest {
     public void delete_throwsUnsupportedOperationException() {
         assertThrows(
                 UnsupportedOperationException.class,
-                () -> mProvider.delete(/*uri=*/ null, /*s=*/ null, /*strings=*/ null));
+                () -> mProvider.delete(/* uri= */ null, /* s= */ null, /* strings= */ null));
     }
 
     @Test
@@ -455,13 +462,13 @@ public final class BatteryUsageContentProviderTest {
                 UnsupportedOperationException.class,
                 () ->
                         mProvider.update(
-                                /*uri=*/ null, /*contentValues=*/ null, /*s=*/ null,
+                                /* uri= */ null,
-                                /*strings=*/ null));
+                                /* contentValues= */ null,
+                                /* s= */ null,
+                                /* strings= */ null));
     }
 
-    private Cursor insertBatteryState(
+    private Cursor insertBatteryState(Duration currentTime, String queryTimestamp)
-            Duration currentTime,
-            String queryTimestamp)
             throws Exception {
         mProvider.onCreate();
         final FakeClock fakeClock = new FakeClock();
@@ -470,20 +477,17 @@ public final class BatteryUsageContentProviderTest {
         final long currentTimestamp = currentTime.toMillis();
         // Inserts some valid testing data.
         BatteryTestUtils.insertDataToBatteryStateTable(
-                mContext, currentTimestamp - 6, PACKAGE_NAME1,
+                mContext, currentTimestamp - 6, PACKAGE_NAME1, /* isFullChargeStart= */ true);
-                /*isFullChargeStart=*/ true);
         BatteryTestUtils.insertDataToBatteryStateTable(
                 mContext, currentTimestamp - 2, PACKAGE_NAME2);
-        BatteryTestUtils.insertDataToBatteryStateTable(
+        BatteryTestUtils.insertDataToBatteryStateTable(mContext, currentTimestamp, PACKAGE_NAME3);
-                mContext, currentTimestamp, PACKAGE_NAME3);
 
         final Uri batteryStateQueryContentUri =
                 new Uri.Builder()
                         .scheme(ContentResolver.SCHEME_CONTENT)
                         .authority(DatabaseUtils.AUTHORITY)
                         .appendPath(DatabaseUtils.BATTERY_STATE_TABLE)
-                        .appendQueryParameter(
+                        .appendQueryParameter(DatabaseUtils.QUERY_KEY_TIMESTAMP, queryTimestamp)
-                                DatabaseUtils.QUERY_KEY_TIMESTAMP, queryTimestamp)
                         .build();
 
         final Cursor cursor = query(batteryStateQueryContentUri);
@@ -532,17 +536,17 @@ public final class BatteryUsageContentProviderTest {
                         .scheme(ContentResolver.SCHEME_CONTENT)
                         .authority(DatabaseUtils.AUTHORITY)
                         .appendPath(DatabaseUtils.APP_USAGE_LATEST_TIMESTAMP_PATH)
-                        .appendQueryParameter(
+                        .appendQueryParameter(DatabaseUtils.QUERY_KEY_USERID, Long.toString(userId))
-                                DatabaseUtils.QUERY_KEY_USERID, Long.toString(userId))
                         .build();
 
         return query(appUsageLatestTimestampQueryContentUri);
     }
 
     private Cursor getCursorOfAppUsage(final List<Long> userIds, final long queryTimestamp) {
-        final String queryUserIdString = userIds.stream()
+        final String queryUserIdString =
-                .map(userId -> String.valueOf(userId))
+                userIds.stream()
-                .collect(Collectors.joining(","));
+                        .map(userId -> String.valueOf(userId))
+                        .collect(Collectors.joining(","));
         final Uri appUsageEventUri =
                 new Uri.Builder()
                         .scheme(ContentResolver.SCHEME_CONTENT)
@@ -558,9 +562,10 @@ public final class BatteryUsageContentProviderTest {
 
     private Cursor getCursorOfBatteryEvents(
             final long queryTimestamp, final List<Integer> batteryEventTypes) {
-        final String batteryEventTypesString = batteryEventTypes.stream()
+        final String batteryEventTypesString =
-                .map(type -> String.valueOf(type))
+                batteryEventTypes.stream()
-                .collect(Collectors.joining(","));
+                        .map(type -> String.valueOf(type))
+                        .collect(Collectors.joining(","));
         final Uri batteryEventUri =
                 new Uri.Builder()
                         .scheme(ContentResolver.SCHEME_CONTENT)
@@ -590,6 +595,6 @@ public final class BatteryUsageContentProviderTest {
 
     private Cursor query(Uri uri) {
         return mProvider.query(
-                uri, /*strings=*/ null, /*s=*/ null, /*strings1=*/ null, /*s1=*/ null);
+                uri, /* strings= */ null, /* s= */ null, /* strings1= */ null, /* s1= */ null);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageDataLoaderTest.java

@@ -52,28 +52,22 @@ import java.util.List;
 public final class BatteryUsageDataLoaderTest {
 
     private Context mContext;
-    @Mock
+    @Mock private ContentResolver mMockContentResolver;
-    private ContentResolver mMockContentResolver;
+    @Mock private BatteryStatsManager mBatteryStatsManager;
-    @Mock
+    @Mock private PackageManager mPackageManager;
-    private BatteryStatsManager mBatteryStatsManager;
+    @Mock private UserManager mUserManager;
-    @Mock
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    private PackageManager mPackageManager;
+    @Mock private BatteryEntry mMockBatteryEntry;
-    @Mock
+    @Captor private ArgumentCaptor<BatteryUsageStatsQuery> mStatsQueryCaptor;
-    private UserManager mUserManager;
-    @Mock
-    private BatteryUsageStats mBatteryUsageStats;
-    @Mock
-    private BatteryEntry mMockBatteryEntry;
-    @Captor
-    private ArgumentCaptor<BatteryUsageStatsQuery> mStatsQueryCaptor;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = spy(RuntimeEnvironment.application);
         doReturn(mContext).when(mContext).getApplicationContext();
-        doReturn(mBatteryStatsManager).when(mContext).getSystemService(
+        doReturn(mBatteryStatsManager)
-                Context.BATTERY_STATS_SERVICE);
+                .when(mContext)
+                .getSystemService(Context.BATTERY_STATS_SERVICE);
         doReturn(mPackageManager).when(mContext).getPackageManager();
         doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
         doReturn(mMockContentResolver).when(mContext).getContentResolver();
@@ -88,11 +82,10 @@ public final class BatteryUsageDataLoaderTest {
                 .thenReturn(mBatteryUsageStats);
         BatteryUsageDataLoader.sFakeBatteryEntryListSupplier = () -> batteryEntryList;
 
-        BatteryUsageDataLoader.loadBatteryStatsData(mContext, /*isFullChargeStart=*/ false);
+        BatteryUsageDataLoader.loadBatteryStatsData(mContext, /* isFullChargeStart= */ false);
 
         final int queryFlags = mStatsQueryCaptor.getValue().getFlags();
-        assertThat(queryFlags
+        assertThat(queryFlags & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY)
-                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY)
                 .isNotEqualTo(0);
         verify(mMockContentResolver).insert(any(), any());
     }
@@ -103,7 +96,7 @@ public final class BatteryUsageDataLoaderTest {
                 .thenReturn(mBatteryUsageStats);
         BatteryUsageDataLoader.sFakeBatteryEntryListSupplier = () -> null;
 
-        BatteryUsageDataLoader.loadBatteryStatsData(mContext, /*isFullChargeStart=*/ false);
+        BatteryUsageDataLoader.loadBatteryStatsData(mContext, /* isFullChargeStart= */ false);
 
         verify(mMockContentResolver).insert(any(), any());
     }
@@ -114,7 +107,7 @@ public final class BatteryUsageDataLoaderTest {
                 .thenReturn(mBatteryUsageStats);
         BatteryUsageDataLoader.sFakeBatteryEntryListSupplier = () -> new ArrayList<>();
 
-        BatteryUsageDataLoader.loadBatteryStatsData(mContext, /*isFullChargeStart=*/ false);
+        BatteryUsageDataLoader.loadBatteryStatsData(mContext, /* isFullChargeStart= */ false);
 
         verify(mMockContentResolver).insert(any(), any());
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageStatsLoaderTest.java

@@ -39,25 +39,23 @@ import org.robolectric.RuntimeEnvironment;
 @RunWith(RobolectricTestRunner.class)
 public class BatteryUsageStatsLoaderTest {
     private Context mContext;
-    @Mock
+    @Mock private BatteryStatsManager mBatteryStatsManager;
-    private BatteryStatsManager mBatteryStatsManager;
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    @Mock
+    @Captor private ArgumentCaptor<BatteryUsageStatsQuery> mUsageStatsQueryCaptor;
-    private BatteryUsageStats mBatteryUsageStats;
-    @Captor
-    private ArgumentCaptor<BatteryUsageStatsQuery> mUsageStatsQueryCaptor;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = spy(RuntimeEnvironment.application);
-        doReturn(mBatteryStatsManager).when(mContext).getSystemService(
+        doReturn(mBatteryStatsManager)
-                Context.BATTERY_STATS_SERVICE);
+                .when(mContext)
+                .getSystemService(Context.BATTERY_STATS_SERVICE);
     }
 
     @Test
     public void testLoadInBackground_loadWithoutHistory() {
-        BatteryUsageStatsLoader loader = new BatteryUsageStatsLoader(
+        BatteryUsageStatsLoader loader =
-                mContext, /* includeBatteryHistory */ false);
+                new BatteryUsageStatsLoader(mContext, /* includeBatteryHistory */ false);
 
         when(mBatteryStatsManager.getBatteryUsageStats(mUsageStatsQueryCaptor.capture()))
                 .thenReturn(mBatteryUsageStats);
@@ -65,14 +63,14 @@ public class BatteryUsageStatsLoaderTest {
         loader.loadInBackground();
 
         final int queryFlags = mUsageStatsQueryCaptor.getValue().getFlags();
-        assertThat(queryFlags
+        assertThat(queryFlags & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY)
-                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY).isEqualTo(0);
+                .isEqualTo(0);
     }
 
     @Test
     public void testLoadInBackground_loadWithHistory() {
-        BatteryUsageStatsLoader loader = new BatteryUsageStatsLoader(
+        BatteryUsageStatsLoader loader =
-                mContext, /* includeBatteryHistory */ true);
+                new BatteryUsageStatsLoader(mContext, /* includeBatteryHistory */ true);
 
         when(mBatteryStatsManager.getBatteryUsageStats(mUsageStatsQueryCaptor.capture()))
                 .thenReturn(mBatteryUsageStats);
@@ -80,7 +78,7 @@ public class BatteryUsageStatsLoaderTest {
         loader.loadInBackground();
 
         final int queryFlags = mUsageStatsQueryCaptor.getValue().getFlags();
-        assertThat(queryFlags
+        assertThat(queryFlags & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY)
-                & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY).isNotEqualTo(0);
+                .isNotEqualTo(0);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BootBroadcastReceiverTest.java

@@ -88,7 +88,8 @@ public final class BootBroadcastReceiverTest {
         final SharedPreferences sharedPreferences = DatabaseUtils.getSharedPreferences(mContext);
         sharedPreferences
                 .edit()
-                .putInt(DatabaseUtils.KEY_LAST_USAGE_SOURCE,
+                .putInt(
+                        DatabaseUtils.KEY_LAST_USAGE_SOURCE,
                         UsageStatsManager.USAGE_SOURCE_CURRENT_ACTIVITY)
                 .apply();
 
@@ -96,9 +97,8 @@ public final class BootBroadcastReceiverTest {
 
         assertThat(mShadowAlarmManager.peekNextScheduledAlarm()).isNotNull();
         assertThat(
-                DatabaseUtils
+                        DatabaseUtils.getSharedPreferences(mContext)
-                        .getSharedPreferences(mContext)
+                                .contains(DatabaseUtils.KEY_LAST_USAGE_SOURCE))
-                        .contains(DatabaseUtils.KEY_LAST_USAGE_SOURCE))
                 .isFalse();
     }
 
@@ -124,7 +124,7 @@ public final class BootBroadcastReceiverTest {
 
     @Test
     public void onReceive_nullIntent_notRefreshesJob() {
-        mReceiver.onReceive(mContext, /*intent=*/ null);
+        mReceiver.onReceive(mContext, /* intent= */ null);
         assertThat(mShadowAlarmManager.peekNextScheduledAlarm()).isNull();
     }
 
@@ -142,11 +142,10 @@ public final class BootBroadcastReceiverTest {
     public void invokeJobRecheck_broadcastsIntent() {
         BootBroadcastReceiver.invokeJobRecheck(mContext);
 
-        final List<Intent> intents =
+        final List<Intent> intents = Shadows.shadowOf((Application) mContext).getBroadcastIntents();
-                Shadows.shadowOf((Application) mContext).getBroadcastIntents();
         assertThat(intents).hasSize(1);
-        assertThat(intents.get(0).getAction()).isEqualTo(
+        assertThat(intents.get(0).getAction())
-                BootBroadcastReceiver.ACTION_PERIODIC_JOB_RECHECK);
+                .isEqualTo(BootBroadcastReceiver.ACTION_PERIODIC_JOB_RECHECK);
     }
 
     private void clearSharedPreferences() {

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java

@@ -61,14 +61,10 @@ public final class ConvertUtilsTest {
 
     private Context mContext;
 
-    @Mock
+    @Mock private PackageManager mMockPackageManager;
-    private PackageManager mMockPackageManager;
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    @Mock
+    @Mock private BatteryEntry mMockBatteryEntry;
-    private BatteryUsageStats mBatteryUsageStats;
+    @Mock private IUsageStatsManager mUsageStatsManager;
-    @Mock
-    private BatteryEntry mMockBatteryEntry;
-    @Mock
-    private IUsageStatsManager mUsageStatsManager;
 
     @Before
     public void setUp() {
@@ -104,12 +100,12 @@ public final class ConvertUtilsTest {
                 ConvertUtils.convertBatteryEntryToContentValues(
                         mMockBatteryEntry,
                         mBatteryUsageStats,
-                        /*batteryLevel=*/ 12,
+                        /* batteryLevel= */ 12,
-                        /*batteryStatus=*/ BatteryManager.BATTERY_STATUS_FULL,
+                        /* batteryStatus= */ BatteryManager.BATTERY_STATUS_FULL,
-                        /*batteryHealth=*/ BatteryManager.BATTERY_HEALTH_COLD,
+                        /* batteryHealth= */ BatteryManager.BATTERY_HEALTH_COLD,
-                        /*bootTimestamp=*/ 101L,
+                        /* bootTimestamp= */ 101L,
-                        /*timestamp=*/ 10001L,
+                        /* timestamp= */ 10001L,
-                        /*isFullChargeStart=*/ true);
+                        /* isFullChargeStart= */ true);
         final BatteryInformation batteryInformation =
                 ConvertUtils.getBatteryInformation(
                         values, BatteryHistEntry.KEY_BATTERY_INFORMATION);
@@ -150,8 +146,8 @@ public final class ConvertUtilsTest {
         when(mMockBatteryEntry.getUid()).thenReturn(-1);
         when(mMockBatteryEntry.getLabel()).thenReturn("CPU");
         when(mMockBatteryEntry.getDefaultPackageName()).thenReturn(null);
-        when(mMockBatteryEntry.getPowerComponentId()).thenReturn(
+        when(mMockBatteryEntry.getPowerComponentId())
-                BatteryConsumer.POWER_COMPONENT_CPU);
+                .thenReturn(BatteryConsumer.POWER_COMPONENT_CPU);
         when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1);
         when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1);
         when(mMockBatteryEntry.getConsumedPowerInForeground()).thenReturn(1.2);
@@ -168,12 +164,12 @@ public final class ConvertUtilsTest {
                 ConvertUtils.convertBatteryEntryToContentValues(
                         mMockBatteryEntry,
                         mBatteryUsageStats,
-                        /*batteryLevel=*/ 12,
+                        /* batteryLevel= */ 12,
-                        /*batteryStatus=*/ BatteryManager.BATTERY_STATUS_FULL,
+                        /* batteryStatus= */ BatteryManager.BATTERY_STATUS_FULL,
-                        /*batteryHealth=*/ BatteryManager.BATTERY_HEALTH_COLD,
+                        /* batteryHealth= */ BatteryManager.BATTERY_HEALTH_COLD,
-                        /*bootTimestamp=*/ 101L,
+                        /* bootTimestamp= */ 101L,
-                        /*timestamp=*/ 10001L,
+                        /* timestamp= */ 10001L,
-                        /*isFullChargeStart=*/ true);
+                        /* isFullChargeStart= */ true);
         final BatteryInformation batteryInformation =
                 ConvertUtils.getBatteryInformation(
                         values, BatteryHistEntry.KEY_BATTERY_INFORMATION);
@@ -200,8 +196,8 @@ public final class ConvertUtilsTest {
         assertThat(batteryInformation.getPercentOfTotal()).isEqualTo(0.3);
         assertThat(batteryInformation.getForegroundUsageTimeInMs()).isEqualTo(1234L);
         assertThat(batteryInformation.getBackgroundUsageTimeInMs()).isEqualTo(5689L);
-        assertThat(batteryInformation.getDrainType()).isEqualTo(
+        assertThat(batteryInformation.getDrainType())
-                BatteryConsumer.POWER_COMPONENT_CPU);
+                .isEqualTo(BatteryConsumer.POWER_COMPONENT_CPU);
         assertThat(deviceBatteryState.getBatteryLevel()).isEqualTo(12);
         assertThat(deviceBatteryState.getBatteryStatus())
                 .isEqualTo(BatteryManager.BATTERY_STATUS_FULL);
@@ -213,14 +209,14 @@ public final class ConvertUtilsTest {
     public void convertBatteryEntryToContentValues_nullBatteryEntry_returnsExpectedContentValues() {
         final ContentValues values =
                 ConvertUtils.convertBatteryEntryToContentValues(
-                        /*entry=*/ null,
+                        /* entry= */ null,
-                        /*batteryUsageStats=*/ null,
+                        /* batteryUsageStats= */ null,
-                        /*batteryLevel=*/ 12,
+                        /* batteryLevel= */ 12,
-                        /*batteryStatus=*/ BatteryManager.BATTERY_STATUS_FULL,
+                        /* batteryStatus= */ BatteryManager.BATTERY_STATUS_FULL,
-                        /*batteryHealth=*/ BatteryManager.BATTERY_HEALTH_COLD,
+                        /* batteryHealth= */ BatteryManager.BATTERY_HEALTH_COLD,
-                        /*bootTimestamp=*/ 101L,
+                        /* bootTimestamp= */ 101L,
-                        /*timestamp=*/ 10001L,
+                        /* timestamp= */ 10001L,
-                        /*isFullChargeStart=*/ false);
+                        /* isFullChargeStart= */ false);
 
         final BatteryInformation batteryInformation =
                 ConvertUtils.getBatteryInformation(
@@ -234,8 +230,7 @@ public final class ConvertUtilsTest {
                 .isEqualTo(BatteryManager.BATTERY_STATUS_FULL);
         assertThat(deviceBatteryState.getBatteryHealth())
                 .isEqualTo(BatteryManager.BATTERY_HEALTH_COLD);
-        assertThat(values.getAsLong(BatteryHistEntry.KEY_TIMESTAMP))
+        assertThat(values.getAsLong(BatteryHistEntry.KEY_TIMESTAMP)).isEqualTo(10001L);
-                .isEqualTo(10001L);
         assertThat(values.getAsString(BatteryHistEntry.KEY_PACKAGE_NAME))
                 .isEqualTo(ConvertUtils.FAKE_PACKAGE_NAME);
     }
@@ -273,11 +268,10 @@ public final class ConvertUtilsTest {
                         .setType(BatteryEventType.POWER_CONNECTED)
                         .setBatteryLevel(66)
                         .build();
-        final ContentValues values =
+        final ContentValues values = ConvertUtils.convertBatteryEventToContentValues(batteryEvent);
-                ConvertUtils.convertBatteryEventToContentValues(batteryEvent);
         assertThat(values.getAsLong(BatteryEventEntity.KEY_TIMESTAMP)).isEqualTo(10001L);
-        assertThat(values.getAsInteger(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE)).isEqualTo(
+        assertThat(values.getAsInteger(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE))
-                BatteryEventType.POWER_CONNECTED.getNumber());
+                .isEqualTo(BatteryEventType.POWER_CONNECTED.getNumber());
         assertThat(values.getAsInteger(BatteryEventEntity.KEY_BATTERY_LEVEL)).isEqualTo(66);
     }
 
@@ -302,8 +296,7 @@ public final class ConvertUtilsTest {
         final int expectedType = 3;
         when(mMockBatteryEntry.getUid()).thenReturn(1001);
         when(mMockBatteryEntry.getLabel()).thenReturn("Settings");
-        when(mMockBatteryEntry.getDefaultPackageName())
+        when(mMockBatteryEntry.getDefaultPackageName()).thenReturn("com.android.settings.battery");
-                .thenReturn("com.android.settings.battery");
         when(mMockBatteryEntry.isHidden()).thenReturn(true);
         when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1);
         when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1);
@@ -319,23 +312,16 @@ public final class ConvertUtilsTest {
                 .thenReturn(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY);
 
         final BatteryHistEntry batteryHistEntry =
-                ConvertUtils.convertToBatteryHistEntry(
+                ConvertUtils.convertToBatteryHistEntry(mMockBatteryEntry, mBatteryUsageStats);
-                        mMockBatteryEntry,
-                        mBatteryUsageStats);
 
         assertThat(batteryHistEntry.mUid).isEqualTo(1001L);
-        assertThat(batteryHistEntry.mUserId)
+        assertThat(batteryHistEntry.mUserId).isEqualTo(UserHandle.getUserId(1001));
-                .isEqualTo(UserHandle.getUserId(1001));
+        assertThat(batteryHistEntry.mAppLabel).isEqualTo("Settings");
-        assertThat(batteryHistEntry.mAppLabel)
+        assertThat(batteryHistEntry.mPackageName).isEqualTo("com.android.settings.battery");
-                .isEqualTo("Settings");
-        assertThat(batteryHistEntry.mPackageName)
-                .isEqualTo("com.android.settings.battery");
         assertThat(batteryHistEntry.mIsHidden).isTrue();
-        assertThat(batteryHistEntry.mBootTimestamp)
+        assertThat(batteryHistEntry.mBootTimestamp).isEqualTo(0L);
-                .isEqualTo(0L);
         assertThat(batteryHistEntry.mTimestamp).isEqualTo(0L);
-        assertThat(batteryHistEntry.mZoneId)
+        assertThat(batteryHistEntry.mZoneId).isEqualTo(TimeZone.getDefault().getID());
-                .isEqualTo(TimeZone.getDefault().getID());
         assertThat(batteryHistEntry.mTotalPower).isEqualTo(5.1);
         assertThat(batteryHistEntry.mConsumePower).isEqualTo(1.1);
         assertThat(batteryHistEntry.mForegroundUsageConsumePower).isEqualTo(1.2);
@@ -343,10 +329,8 @@ public final class ConvertUtilsTest {
         assertThat(batteryHistEntry.mBackgroundUsageConsumePower).isEqualTo(1.4);
         assertThat(batteryHistEntry.mCachedUsageConsumePower).isEqualTo(1.5);
         assertThat(batteryHistEntry.mPercentOfTotal).isEqualTo(0.3);
-        assertThat(batteryHistEntry.mForegroundUsageTimeInMs)
+        assertThat(batteryHistEntry.mForegroundUsageTimeInMs).isEqualTo(1234L);
-                .isEqualTo(1234L);
+        assertThat(batteryHistEntry.mBackgroundUsageTimeInMs).isEqualTo(5689L);
-        assertThat(batteryHistEntry.mBackgroundUsageTimeInMs)
-                .isEqualTo(5689L);
         assertThat(batteryHistEntry.mDrainType).isEqualTo(expectedType);
         assertThat(batteryHistEntry.mConsumerType)
                 .isEqualTo(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY);
@@ -359,20 +343,15 @@ public final class ConvertUtilsTest {
     public void convertToBatteryHistEntry_nullBatteryEntry_returnsExpectedResult() {
         final BatteryHistEntry batteryHistEntry =
                 ConvertUtils.convertToBatteryHistEntry(
-                        /*entry=*/ null,
+                        /* entry= */ null, /* batteryUsageStats= */ null);
-                        /*batteryUsageStats=*/ null);
 
-        assertThat(batteryHistEntry.mBootTimestamp)
+        assertThat(batteryHistEntry.mBootTimestamp).isEqualTo(0L);
-                .isEqualTo(0L);
+        assertThat(batteryHistEntry.mTimestamp).isEqualTo(0);
-        assertThat(batteryHistEntry.mTimestamp)
+        assertThat(batteryHistEntry.mZoneId).isEqualTo(TimeZone.getDefault().getID());
-                .isEqualTo(0);
-        assertThat(batteryHistEntry.mZoneId)
-                .isEqualTo(TimeZone.getDefault().getID());
         assertThat(batteryHistEntry.mBatteryLevel).isEqualTo(0);
         assertThat(batteryHistEntry.mBatteryStatus).isEqualTo(0);
         assertThat(batteryHistEntry.mBatteryHealth).isEqualTo(0);
-        assertThat(batteryHistEntry.mPackageName)
+        assertThat(batteryHistEntry.mPackageName).isEqualTo(ConvertUtils.FAKE_PACKAGE_NAME);
-                .isEqualTo(ConvertUtils.FAKE_PACKAGE_NAME);
     }
 
     @Test
@@ -387,8 +366,8 @@ public final class ConvertUtilsTest {
         when(mMockPackageManager.getPackageUidAsUser(any(), anyInt())).thenReturn(1001);
 
         final long userId = 2;
-        final AppUsageEvent appUsageEvent = ConvertUtils.convertToAppUsageEvent(
+        final AppUsageEvent appUsageEvent =
-                mContext, mUsageStatsManager, event, userId);
+                ConvertUtils.convertToAppUsageEvent(mContext, mUsageStatsManager, event, userId);
         assertThat(appUsageEvent.getTimestamp()).isEqualTo(101L);
         assertThat(appUsageEvent.getType()).isEqualTo(AppUsageEventType.ACTIVITY_RESUMED);
         assertThat(appUsageEvent.getPackageName()).isEqualTo("com.android.settings1");
@@ -426,14 +405,14 @@ public final class ConvertUtilsTest {
 
         final AppUsageEvent appUsageEvent =
                 ConvertUtils.convertToAppUsageEvent(
-                        mContext, mUsageStatsManager, event, /*userId=*/ 0);
+                        mContext, mUsageStatsManager, event, /* userId= */ 0);
 
         assertThat(appUsageEvent).isNull();
     }
 
     @Test
     public void convertToAppUsageEvent_failToGetUid_returnsNull()
-            throws PackageManager.NameNotFoundException  {
+            throws PackageManager.NameNotFoundException {
         final Event event = new Event();
         event.mEventType = UsageEvents.Event.DEVICE_SHUTDOWN;
         event.mPackage = "com.android.settings1";
@@ -449,24 +428,27 @@ public final class ConvertUtilsTest {
 
     @Test
     public void convertToAppUsageEvent_returnExpectedResult() {
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[]{
+                new MatrixCursor(
-                        AppUsageEventEntity.KEY_UID,
+                        new String[] {
-                        AppUsageEventEntity.KEY_USER_ID,
+                            AppUsageEventEntity.KEY_UID,
-                        AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_USER_ID,
-                        AppUsageEventEntity.KEY_TIMESTAMP,
+                            AppUsageEventEntity.KEY_PACKAGE_NAME,
-                        AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE,
+                            AppUsageEventEntity.KEY_TIMESTAMP,
-                        AppUsageEventEntity.KEY_TASK_ROOT_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE,
-                        AppUsageEventEntity.KEY_INSTANCE_ID});
+                            AppUsageEventEntity.KEY_TASK_ROOT_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_INSTANCE_ID
+                        });
         cursor.addRow(
-                new Object[]{
+                new Object[] {
-                        101L,
+                    101L,
-                        1001L,
+                    1001L,
-                        "com.android.settings1",
+                    "com.android.settings1",
-                        10001L,
+                    10001L,
-                        AppUsageEventType.DEVICE_SHUTDOWN.getNumber(),
+                    AppUsageEventType.DEVICE_SHUTDOWN.getNumber(),
-                        "com.android.settings2",
+                    "com.android.settings2",
-                        100001L});
+                    100001L
+                });
         cursor.moveToFirst();
 
         final AppUsageEvent appUsageEvent = ConvertUtils.convertToAppUsageEvent(cursor);
@@ -482,20 +464,23 @@ public final class ConvertUtilsTest {
 
     @Test
     public void convertToAppUsageEvent_emptyInstanceIdAndRootName_returnExpectedResult() {
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[]{
+                new MatrixCursor(
-                        AppUsageEventEntity.KEY_UID,
+                        new String[] {
-                        AppUsageEventEntity.KEY_USER_ID,
+                            AppUsageEventEntity.KEY_UID,
-                        AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_USER_ID,
-                        AppUsageEventEntity.KEY_TIMESTAMP,
+                            AppUsageEventEntity.KEY_PACKAGE_NAME,
-                        AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE});
+                            AppUsageEventEntity.KEY_TIMESTAMP,
+                            AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE
+                        });
         cursor.addRow(
-                new Object[]{
+                new Object[] {
-                        101L,
+                    101L,
-                        1001L,
+                    1001L,
-                        "com.android.settings1",
+                    "com.android.settings1",
-                        10001L,
+                    10001L,
-                        AppUsageEventType.DEVICE_SHUTDOWN.getNumber()});
+                    AppUsageEventType.DEVICE_SHUTDOWN.getNumber()
+                });
         cursor.moveToFirst();
 
         final AppUsageEvent appUsageEvent = ConvertUtils.convertToAppUsageEvent(cursor);
@@ -511,8 +496,8 @@ public final class ConvertUtilsTest {
 
     @Test
     public void convertToBatteryEvent_normalCase_returnsExpectedResult() {
-        final BatteryEvent batteryEvent = ConvertUtils.convertToBatteryEvent(
+        final BatteryEvent batteryEvent =
-                666L, BatteryEventType.POWER_DISCONNECTED, 88);
+                ConvertUtils.convertToBatteryEvent(666L, BatteryEventType.POWER_DISCONNECTED, 88);
         assertThat(batteryEvent.getTimestamp()).isEqualTo(666L);
         assertThat(batteryEvent.getType()).isEqualTo(BatteryEventType.POWER_DISCONNECTED);
         assertThat(batteryEvent.getBatteryLevel()).isEqualTo(88);
@@ -520,8 +505,9 @@ public final class ConvertUtilsTest {
 
     @Test
     public void convertToBatteryEventList_normalCase_returnsExpectedResult() {
-        final BatteryLevelData batteryLevelData = new BatteryLevelData(Map.of(
+        final BatteryLevelData batteryLevelData =
-                1691589600000L, 98, 1691596800000L, 90, 1691596812345L, 80));
+                new BatteryLevelData(
+                        Map.of(1691589600000L, 98, 1691596800000L, 90, 1691596812345L, 80));
 
         final List<BatteryEvent> batteryEventList =
                 ConvertUtils.convertToBatteryEventList(batteryLevelData);
@@ -537,14 +523,20 @@ public final class ConvertUtilsTest {
 
     @Test
     public void convertToBatteryUsageSlotList_normalCase_returnsExpectedResult() {
-        BatteryDiffData batteryDiffData1 = new BatteryDiffData(
+        BatteryDiffData batteryDiffData1 =
-                mContext, 11L, 12L, 13, 14, 15, List.of(), List.of(), Set.of(), Set.of(), false);
+                new BatteryDiffData(
-        BatteryDiffData batteryDiffData2 = new BatteryDiffData(
+                        mContext, 11L, 12L, 13, 14, 15, List.of(), List.of(), Set.of(), Set.of(),
-                mContext, 21L, 22L, 23, 24, 25, List.of(), List.of(), Set.of(), Set.of(), false);
+                        false);
-        BatteryDiffData batteryDiffData3 = new BatteryDiffData(
+        BatteryDiffData batteryDiffData2 =
-                mContext, 31L, 32L, 33, 34, 35, List.of(), List.of(), Set.of(), Set.of(), false);
+                new BatteryDiffData(
-        final Map<Long, BatteryDiffData> batteryDiffDataMap = Map.of(
+                        mContext, 21L, 22L, 23, 24, 25, List.of(), List.of(), Set.of(), Set.of(),
-                11L, batteryDiffData1, 21L, batteryDiffData2, 31L, batteryDiffData3);
+                        false);
+        BatteryDiffData batteryDiffData3 =
+                new BatteryDiffData(
+                        mContext, 31L, 32L, 33, 34, 35, List.of(), List.of(), Set.of(), Set.of(),
+                        false);
+        final Map<Long, BatteryDiffData> batteryDiffDataMap =
+                Map.of(11L, batteryDiffData1, 21L, batteryDiffData2, 31L, batteryDiffData3);
 
         final List<BatteryUsageSlot> batteryUsageSlotList =
                 ConvertUtils.convertToBatteryUsageSlotList(batteryDiffDataMap);
@@ -556,8 +548,7 @@ public final class ConvertUtilsTest {
 
     @Test
     public void getLocale_nullContext_returnDefaultLocale() {
-        assertThat(ConvertUtils.getLocale(/*context=*/ null))
+        assertThat(ConvertUtils.getLocale(/* context= */ null)).isEqualTo(Locale.getDefault());
-                .isEqualTo(Locale.getDefault());
     }
 
     @Test
@@ -578,8 +569,9 @@ public final class ConvertUtilsTest {
         final String packageName = "com.android.settings1";
         final String taskRootPackageName = "com.android.settings2";
 
-        assertThat(ConvertUtils.getEffectivePackageName(
+        assertThat(
-                mContext, mUsageStatsManager, packageName, taskRootPackageName))
+                        ConvertUtils.getEffectivePackageName(
+                                mContext, mUsageStatsManager, packageName, taskRootPackageName))
                 .isEqualTo(packageName);
     }
 
@@ -588,8 +580,9 @@ public final class ConvertUtilsTest {
         final String packageName = "com.android.settings1";
         final String taskRootPackageName = "com.android.settings2";
 
-        assertThat(ConvertUtils.getEffectivePackageName(
+        assertThat(
-                mContext, mUsageStatsManager, packageName, taskRootPackageName))
+                        ConvertUtils.getEffectivePackageName(
+                                mContext, mUsageStatsManager, packageName, taskRootPackageName))
                 .isEqualTo(packageName);
     }
 
@@ -599,8 +592,9 @@ public final class ConvertUtilsTest {
         final String packageName = "com.android.settings1";
         final String taskRootPackageName = "com.android.settings2";
 
-        assertThat(ConvertUtils.getEffectivePackageName(
+        assertThat(
-                mContext, mUsageStatsManager, packageName, taskRootPackageName))
+                        ConvertUtils.getEffectivePackageName(
+                                mContext, mUsageStatsManager, packageName, taskRootPackageName))
                 .isEqualTo(taskRootPackageName);
     }
 
@@ -609,11 +603,19 @@ public final class ConvertUtilsTest {
         ConvertUtils.sUsageSource = USAGE_SOURCE_TASK_ROOT_ACTIVITY;
         final String packageName = "com.android.settings1";
 
-        assertThat(ConvertUtils.getEffectivePackageName(
+        assertThat(
-                mContext, mUsageStatsManager, packageName, /*taskRootPackageName=*/ null))
+                        ConvertUtils.getEffectivePackageName(
+                                mContext,
+                                mUsageStatsManager,
+                                packageName,
+                                /* taskRootPackageName= */ null))
                 .isEqualTo(packageName);
-        assertThat(ConvertUtils.getEffectivePackageName(
+        assertThat(
-                mContext, mUsageStatsManager, packageName, /*taskRootPackageName=*/ ""))
+                        ConvertUtils.getEffectivePackageName(
+                                mContext,
+                                mUsageStatsManager,
+                                packageName,
+                                /* taskRootPackageName= */ ""))
                 .isEqualTo(packageName);
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessManagerTest.java

@@ -70,18 +70,12 @@ public final class DataProcessManagerTest {
     private Context mContext;
     private DataProcessManager mDataProcessManager;
 
-    @Mock
+    @Mock private IUsageStatsManager mUsageStatsManager;
-    private IUsageStatsManager mUsageStatsManager;
+    @Mock private UserManager mUserManager;
-    @Mock
+    @Mock private BatteryStatsManager mBatteryStatsManager;
-    private UserManager mUserManager;
+    @Mock private BatteryUsageStats mBatteryUsageStats;
-    @Mock
+    @Mock private Intent mIntent;
-    private BatteryStatsManager mBatteryStatsManager;
+    @Captor private ArgumentCaptor<BatteryUsageStatsQuery> mBatteryUsageStatsQueryCaptor;
-    @Mock
-    private BatteryUsageStats mBatteryUsageStats;
-    @Mock
-    private Intent mIntent;
-    @Captor
-    private ArgumentCaptor<BatteryUsageStatsQuery> mBatteryUsageStatsQueryCaptor;
 
     @Before
     public void setUp() {
@@ -91,22 +85,26 @@ public final class DataProcessManagerTest {
         DataProcessor.sTestSystemAppsPackageNames = Set.of();
         DataProcessor.sUsageStatsManager = mUsageStatsManager;
         doReturn(mContext).when(mContext).getApplicationContext();
-        doReturn(mUserManager)
+        doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
+        doReturn(mBatteryStatsManager)
                 .when(mContext)
-                .getSystemService(UserManager.class);
+                .getSystemService(Context.BATTERY_STATS_SERVICE);
-        doReturn(mBatteryStatsManager).when(mContext).getSystemService(
+        doReturn(mBatteryUsageStats)
-                Context.BATTERY_STATS_SERVICE);
+                .when(mBatteryStatsManager)
-        doReturn(mBatteryUsageStats).when(
+                .getBatteryUsageStats(mBatteryUsageStatsQueryCaptor.capture());
-                mBatteryStatsManager).getBatteryUsageStats(mBatteryUsageStatsQueryCaptor.capture());
         doReturn(mIntent).when(mContext).registerReceiver(any(), any());
         doReturn(100).when(mIntent).getIntExtra(eq(BatteryManager.EXTRA_SCALE), anyInt());
         doReturn(66).when(mIntent).getIntExtra(eq(BatteryManager.EXTRA_LEVEL), anyInt());
 
-        mDataProcessManager = new DataProcessManager(
+        mDataProcessManager =
-                mContext, /*handler=*/ null,  /*rawStartTimestamp=*/ 0L,
+                new DataProcessManager(
-                /*lastFullChargeTimestamp=*/ 0L, /*callbackFunction=*/ null,
+                        mContext,
-                /*hourlyBatteryLevelsPerDay=*/ new ArrayList<>(),
+                        /* handler= */ null,
-                /*batteryHistoryMap=*/ new HashMap<>());
+                        /* rawStartTimestamp= */ 0L,
+                        /* lastFullChargeTimestamp= */ 0L,
+                        /* callbackFunction= */ null,
+                        /* hourlyBatteryLevelsPerDay= */ new ArrayList<>(),
+                        /* batteryHistoryMap= */ new HashMap<>());
     }
 
     @After
@@ -119,18 +117,20 @@ public final class DataProcessManagerTest {
     @LooperMode(LooperMode.Mode.LEGACY)
     public void constructor_noLevelData() {
         final DataProcessManager dataProcessManager =
-                new DataProcessManager(mContext, /*handler=*/ null, /*callbackFunction=*/ null);
+                new DataProcessManager(mContext, /* handler= */ null, /* callbackFunction= */ null);
         assertThat(dataProcessManager.getShowScreenOnTime()).isFalse();
     }
 
     @Test
     @LooperMode(LooperMode.Mode.LEGACY)
     public void start_loadEmptyDatabaseAppUsageData() {
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[]{
+                new MatrixCursor(
-                        AppUsageEventEntity.KEY_UID,
+                        new String[] {
-                        AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_UID,
-                        AppUsageEventEntity.KEY_TIMESTAMP});
+                            AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_TIMESTAMP
+                        });
         DatabaseUtils.sFakeSupplier = () -> cursor;
         doReturn(true).when(mUserManager).isUserUnlocked(anyInt());
 
@@ -166,9 +166,9 @@ public final class DataProcessManagerTest {
                 new BatteryLevelData.PeriodBatteryLevelData(batteryLevelMap2, timestamps2));
         // Fake current usage data.
         final UsageEvents.Event event1 =
-                getUsageEvent(UsageEvents.Event.ACTIVITY_RESUMED, /*timestamp=*/ 1, packageName);
+                getUsageEvent(UsageEvents.Event.ACTIVITY_RESUMED, /* timestamp= */ 1, packageName);
         final UsageEvents.Event event2 =
-                getUsageEvent(UsageEvents.Event.ACTIVITY_STOPPED, /*timestamp=*/ 2, packageName);
+                getUsageEvent(UsageEvents.Event.ACTIVITY_STOPPED, /* timestamp= */ 2, packageName);
         final List<UsageEvents.Event> events = new ArrayList<>();
         events.add(event1);
         events.add(event2);
@@ -182,40 +182,68 @@ public final class DataProcessManagerTest {
         doReturn(new ArrayList<>()).when(mUserManager).getUserProfiles();
 
         // Fake database usage data.
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[]{
+                new MatrixCursor(
-                        AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE,
+                        new String[] {
-                        AppUsageEventEntity.KEY_TIMESTAMP,
+                            AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE,
-                        AppUsageEventEntity.KEY_USER_ID,
+                            AppUsageEventEntity.KEY_TIMESTAMP,
-                        AppUsageEventEntity.KEY_INSTANCE_ID,
+                            AppUsageEventEntity.KEY_USER_ID,
-                        AppUsageEventEntity.KEY_PACKAGE_NAME
+                            AppUsageEventEntity.KEY_INSTANCE_ID,
-                });
+                            AppUsageEventEntity.KEY_PACKAGE_NAME
+                        });
         // Adds fake data into the cursor.
-        cursor.addRow(new Object[] {
+        cursor.addRow(
-                AppUsageEventType.ACTIVITY_RESUMED.getNumber(), /*timestamp=*/ 3, /*userId=*/ 1,
+                new Object[] {
-                /*instanceId=*/ 2, packageName});
+                    AppUsageEventType.ACTIVITY_RESUMED.getNumber(),
-        cursor.addRow(new Object[] {
+                    /* timestamp= */ 3,
-                AppUsageEventType.ACTIVITY_STOPPED.getNumber(), /*timestamp=*/ 4, /*userId=*/ 1,
+                    /* userId= */ 1,
-                /*instanceId=*/ 2, packageName});
+                    /* instanceId= */ 2,
-        cursor.addRow(new Object[] {
+                    packageName
-                AppUsageEventType.ACTIVITY_RESUMED.getNumber(), /*timestamp=*/ 5, /*userId=*/ 1,
+                });
-                /*instanceId=*/ 2, packageName});
+        cursor.addRow(
-        cursor.addRow(new Object[] {
+                new Object[] {
-                AppUsageEventType.ACTIVITY_STOPPED.getNumber(), /*timestamp=*/ 6, /*userId=*/ 1,
+                    AppUsageEventType.ACTIVITY_STOPPED.getNumber(),
-                /*instanceId=*/ 2, packageName});
+                    /* timestamp= */ 4,
-        DatabaseUtils.sFakeSupplier = new Supplier<>() {
+                    /* userId= */ 1,
-            private int mTimes = 0;
+                    /* instanceId= */ 2,
-            @Override
+                    packageName
-            public Cursor get() {
+                });
-                mTimes++;
+        cursor.addRow(
-                return mTimes <= 2 ? null : cursor;
+                new Object[] {
-            }
+                    AppUsageEventType.ACTIVITY_RESUMED.getNumber(),
-        };
+                    /* timestamp= */ 5,
+                    /* userId= */ 1,
+                    /* instanceId= */ 2,
+                    packageName
+                });
+        cursor.addRow(
+                new Object[] {
+                    AppUsageEventType.ACTIVITY_STOPPED.getNumber(),
+                    /* timestamp= */ 6,
+                    /* userId= */ 1,
+                    /* instanceId= */ 2,
+                    packageName
+                });
+        DatabaseUtils.sFakeSupplier =
+                new Supplier<>() {
+                    private int mTimes = 0;
 
-        final DataProcessManager dataProcessManager = new DataProcessManager(
+                    @Override
-                mContext, /*handler=*/ null, /*rawStartTimestamp=*/ 2L,
+                    public Cursor get() {
-                /*lastFullChargeTimestamp=*/ 1L, /*callbackFunction=*/ null,
+                        mTimes++;
-                hourlyBatteryLevelsPerDay, /*batteryHistoryMap=*/ new HashMap<>());
+                        return mTimes <= 2 ? null : cursor;
+                    }
+                };
+
+        final DataProcessManager dataProcessManager =
+                new DataProcessManager(
+                        mContext,
+                        /* handler= */ null,
+                        /* rawStartTimestamp= */ 2L,
+                        /* lastFullChargeTimestamp= */ 1L,
+                        /* callbackFunction= */ null,
+                        hourlyBatteryLevelsPerDay,
+                        /* batteryHistoryMap= */ new HashMap<>());
         dataProcessManager.start();
 
         assertThat(dataProcessManager.getIsCurrentAppUsageLoaded()).isTrue();
@@ -226,17 +254,17 @@ public final class DataProcessManagerTest {
         Collections.sort(appUsageEventList, DataProcessor.APP_USAGE_EVENT_TIMESTAMP_COMPARATOR);
         assertThat(appUsageEventList.size()).isEqualTo(6);
         assertAppUsageEvent(
-                appUsageEventList.get(0), AppUsageEventType.ACTIVITY_RESUMED, /*timestamp=*/ 1);
+                appUsageEventList.get(0), AppUsageEventType.ACTIVITY_RESUMED, /* timestamp= */ 1);
         assertAppUsageEvent(
-                appUsageEventList.get(1), AppUsageEventType.ACTIVITY_STOPPED, /*timestamp=*/ 2);
+                appUsageEventList.get(1), AppUsageEventType.ACTIVITY_STOPPED, /* timestamp= */ 2);
         assertAppUsageEvent(
-                appUsageEventList.get(2), AppUsageEventType.ACTIVITY_RESUMED, /*timestamp=*/ 3);
+                appUsageEventList.get(2), AppUsageEventType.ACTIVITY_RESUMED, /* timestamp= */ 3);
         assertAppUsageEvent(
-                appUsageEventList.get(3), AppUsageEventType.ACTIVITY_STOPPED, /*timestamp=*/ 4);
+                appUsageEventList.get(3), AppUsageEventType.ACTIVITY_STOPPED, /* timestamp= */ 4);
         assertAppUsageEvent(
-                appUsageEventList.get(4), AppUsageEventType.ACTIVITY_RESUMED, /*timestamp=*/ 5);
+                appUsageEventList.get(4), AppUsageEventType.ACTIVITY_RESUMED, /* timestamp= */ 5);
         assertAppUsageEvent(
-                appUsageEventList.get(5), AppUsageEventType.ACTIVITY_STOPPED, /*timestamp=*/ 6);
+                appUsageEventList.get(5), AppUsageEventType.ACTIVITY_STOPPED, /* timestamp= */ 6);
 
         final Map<Integer, Map<Integer, Map<Long, Map<String, List<AppUsagePeriod>>>>>
                 appUsagePeriodMap = dataProcessManager.getAppUsagePeriodMap();
@@ -267,18 +295,20 @@ public final class DataProcessManagerTest {
     @LooperMode(LooperMode.Mode.LEGACY)
     public void start_currentUserLocked_emptyAppUsageList() throws RemoteException {
         final UsageEvents.Event event =
-                getUsageEvent(UsageEvents.Event.ACTIVITY_RESUMED, /*timestamp=*/ 1, "package");
+                getUsageEvent(UsageEvents.Event.ACTIVITY_RESUMED, /* timestamp= */ 1, "package");
         final List<UsageEvents.Event> events = new ArrayList<>();
         events.add(event);
         doReturn(getUsageEvents(events))
                 .when(mUsageStatsManager)
                 .queryEventsForUser(anyLong(), anyLong(), anyInt(), any());
         doReturn(false).when(mUserManager).isUserUnlocked(anyInt());
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[]{
+                new MatrixCursor(
-                        AppUsageEventEntity.KEY_UID,
+                        new String[] {
-                        AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_UID,
-                        AppUsageEventEntity.KEY_TIMESTAMP});
+                            AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_TIMESTAMP
+                        });
         // Adds fake data into the cursor.
         cursor.addRow(new Object[] {101L, "app name1", 1001L});
         DatabaseUtils.sFakeSupplier = () -> cursor;
@@ -293,25 +323,30 @@ public final class DataProcessManagerTest {
     @Test
     @LooperMode(LooperMode.Mode.LEGACY)
     public void getBatteryLevelData_emptyHistoryMap_returnNull() {
-        assertThat(DataProcessManager.getBatteryLevelData(
+        assertThat(
-                mContext,
+                        DataProcessManager.getBatteryLevelData(
-                /*handler=*/ null,
+                                mContext,
-                /*isFromPeriodJob=*/ false,
+                                /* handler= */ null,
-                /*asyncResponseDelegate=*/ null)).isNull();
+                                /* isFromPeriodJob= */ false,
-        assertThat(DataProcessManager.getBatteryLevelData(
+                                /* asyncResponseDelegate= */ null))
-                mContext,
+                .isNull();
-                /*handler=*/ null,
+        assertThat(
-                /*isFromPeriodJob=*/ true,
+                        DataProcessManager.getBatteryLevelData(
-                /*asyncResponseDelegate=*/ null)).isNull();
+                                mContext,
+                                /* handler= */ null,
+                                /* isFromPeriodJob= */ true,
+                                /* asyncResponseDelegate= */ null))
+                .isNull();
     }
 
     @Test
     public void getBatteryLevelData_allDataInOneHour_returnExpectedResult() {
         // The timestamps and the current time are within half hour before an even hour.
         final long[] timestamps = {
-                DateUtils.HOUR_IN_MILLIS * 2 - 300L,
+            DateUtils.HOUR_IN_MILLIS * 2 - 300L,
-                DateUtils.HOUR_IN_MILLIS * 2 - 200L,
+            DateUtils.HOUR_IN_MILLIS * 2 - 200L,
-                DateUtils.HOUR_IN_MILLIS * 2 - 100L};
+            DateUtils.HOUR_IN_MILLIS * 2 - 100L
+        };
         final int[] levels = {100, 99, 98};
         DataProcessManager.sFakeBatteryHistoryMap = createHistoryMap(timestamps, levels);
         DataProcessor.sTestCurrentTimeMillis = timestamps[timestamps.length - 1];
@@ -319,13 +354,12 @@ public final class DataProcessManagerTest {
         final BatteryLevelData resultData =
                 DataProcessManager.getBatteryLevelData(
                         mContext,
-                        /*handler=*/ null,
+                        /* handler= */ null,
-                        /*isFromPeriodJob=*/ false,
+                        /* isFromPeriodJob= */ false,
-                        /*asyncResponseDelegate=*/ null);
+                        /* asyncResponseDelegate= */ null);
 
-        final List<Long> expectedDailyTimestamps = List.of(
+        final List<Long> expectedDailyTimestamps =
-                DateUtils.HOUR_IN_MILLIS * 2 - 300L,
+                List.of(DateUtils.HOUR_IN_MILLIS * 2 - 300L, DateUtils.HOUR_IN_MILLIS * 2 - 100L);
-                DateUtils.HOUR_IN_MILLIS * 2 - 100L);
         final List<Integer> expectedDailyLevels = List.of(100, 66);
         final List<List<Long>> expectedHourlyTimestamps = List.of(expectedDailyTimestamps);
         final List<List<Integer>> expectedHourlyLevels = List.of(expectedDailyLevels);
@@ -348,13 +382,14 @@ public final class DataProcessManagerTest {
         final BatteryLevelData resultData =
                 DataProcessManager.getBatteryLevelData(
                         mContext,
-                        /*handler=*/ null,
+                        /* handler= */ null,
-                        /*isFromPeriodJob=*/ false,
+                        /* isFromPeriodJob= */ false,
-                        /*asyncResponseDelegate=*/ null);
+                        /* asyncResponseDelegate= */ null);
 
-        final List<Long> expectedDailyTimestamps = List.of(
+        final List<Long> expectedDailyTimestamps =
-                1640966400000L,  // 2022-01-01 00:00:00
+                List.of(
-                1640970000000L); // 2022-01-01 01:00:00
+                        1640966400000L, // 2022-01-01 00:00:00
+                        1640970000000L); // 2022-01-01 01:00:00
         final List<Integer> expectedDailyLevels = List.of(100, 66);
         final List<List<Long>> expectedHourlyTimestamps = List.of(expectedDailyTimestamps);
         final List<List<Integer>> expectedHourlyLevels = List.of(expectedDailyLevels);
@@ -400,16 +435,11 @@ public final class DataProcessManagerTest {
     private static ContentValues getContentValuesWithBatteryLevel(final int level) {
         final ContentValues values = new ContentValues();
         final DeviceBatteryState deviceBatteryState =
-                DeviceBatteryState
+                DeviceBatteryState.newBuilder().setBatteryLevel(level).build();
-                        .newBuilder()
-                        .setBatteryLevel(level)
-                        .build();
         final BatteryInformation batteryInformation =
-                BatteryInformation
+                BatteryInformation.newBuilder().setDeviceBatteryState(deviceBatteryState).build();
-                        .newBuilder()
+        values.put(
-                        .setDeviceBatteryState(deviceBatteryState)
+                BatteryHistEntry.KEY_BATTERY_INFORMATION,
-                        .build();
-        values.put(BatteryHistEntry.KEY_BATTERY_INFORMATION,
                 ConvertUtils.convertBatteryInformationToString(batteryInformation));
         return values;
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtilsTest.java

@@ -117,9 +117,7 @@ public final class DatabaseUtilsTest {
                         .setType(AppUsageEventType.ACTIVITY_STOPPED)
                         .build();
         final AppUsageEvent appUsageEvent3 =
-                AppUsageEvent.newBuilder()
+                AppUsageEvent.newBuilder().setType(AppUsageEventType.DEVICE_SHUTDOWN).build();
-                        .setType(AppUsageEventType.DEVICE_SHUTDOWN)
-                        .build();
         appUsageEventList.add(appUsageEvent1);
         appUsageEventList.add(appUsageEvent2);
         appUsageEventList.add(appUsageEvent3);
@@ -135,10 +133,9 @@ public final class DatabaseUtilsTest {
         // Verifies the inserted ContentValues into content provider.
         final ContentValues[] valuesArray =
                 new ContentValues[] {valuesList.get(0), valuesList.get(1)};
-        verify(mMockContentResolver).bulkInsert(
+        verify(mMockContentResolver).bulkInsert(DatabaseUtils.APP_USAGE_EVENT_URI, valuesArray);
-                DatabaseUtils.APP_USAGE_EVENT_URI, valuesArray);
+        verify(mMockContentResolver)
-        verify(mMockContentResolver).notifyChange(
+                .notifyChange(DatabaseUtils.APP_USAGE_EVENT_URI, /* observer= */ null);
-                DatabaseUtils.APP_USAGE_EVENT_URI, /*observer=*/ null);
     }
 
     @Test
@@ -161,12 +158,10 @@ public final class DatabaseUtilsTest {
         final ContentValues contentValues =
                 DatabaseUtils.sendBatteryEventData(mContext, batteryEvent);
 
-        assertThat(contentValues.getAsInteger(BatteryEventEntity.KEY_TIMESTAMP))
+        assertThat(contentValues.getAsInteger(BatteryEventEntity.KEY_TIMESTAMP)).isEqualTo(10001L);
-                .isEqualTo(10001L);
         assertThat(contentValues.getAsInteger(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE))
                 .isEqualTo(BatteryEventType.POWER_CONNECTED.getNumber());
-        assertThat(contentValues.getAsInteger(BatteryEventEntity.KEY_BATTERY_LEVEL))
+        assertThat(contentValues.getAsInteger(BatteryEventEntity.KEY_BATTERY_LEVEL)).isEqualTo(66);
-                .isEqualTo(66);
         // Verifies the inserted ContentValues into content provider.
         verify(mMockContentResolver).insert(DatabaseUtils.BATTERY_EVENT_URI, contentValues);
     }
@@ -175,9 +170,12 @@ public final class DatabaseUtilsTest {
     public void sendBatteryEntryData_nullBatteryIntent_returnsNullValue() {
         doReturn(null).when(mContext).registerReceiver(any(), any());
         assertThat(
-                DatabaseUtils.sendBatteryEntryData(
+                        DatabaseUtils.sendBatteryEntryData(
-                        mContext, System.currentTimeMillis(), /*batteryEntryList=*/ null,
+                                mContext,
-                        mBatteryUsageStats, /*isFullChargeStart=*/ false))
+                                System.currentTimeMillis(),
+                                /* batteryEntryList= */ null,
+                                mBatteryUsageStats,
+                                /* isFullChargeStart= */ false))
                 .isNull();
     }
 
@@ -200,7 +198,7 @@ public final class DatabaseUtilsTest {
                         System.currentTimeMillis(),
                         batteryEntryList,
                         mBatteryUsageStats,
-                        /*isFullChargeStart=*/ false);
+                        /* isFullChargeStart= */ false);
 
         assertThat(valuesList).hasSize(2);
         // Verifies the ContentValues content.
@@ -209,10 +207,9 @@ public final class DatabaseUtilsTest {
         // Verifies the inserted ContentValues into content provider.
         final ContentValues[] valuesArray =
                 new ContentValues[] {valuesList.get(0), valuesList.get(1)};
-        verify(mMockContentResolver).bulkInsert(
+        verify(mMockContentResolver).bulkInsert(DatabaseUtils.BATTERY_CONTENT_URI, valuesArray);
-                DatabaseUtils.BATTERY_CONTENT_URI, valuesArray);
+        verify(mMockContentResolver)
-        verify(mMockContentResolver).notifyChange(
+                .notifyChange(DatabaseUtils.BATTERY_CONTENT_URI, /* observer= */ null);
-                DatabaseUtils.BATTERY_CONTENT_URI, /*observer=*/ null);
     }
 
     @Test
@@ -225,14 +222,14 @@ public final class DatabaseUtilsTest {
                         System.currentTimeMillis(),
                         new ArrayList<>(),
                         mBatteryUsageStats,
-                        /*isFullChargeStart=*/ false);
+                        /* isFullChargeStart= */ false);
 
         assertThat(valuesList).hasSize(1);
         verifyFakeBatteryEntryContentValues(valuesList.get(0));
         // Verifies the inserted ContentValues into content provider.
         verify(mMockContentResolver).insert(any(), any());
-        verify(mMockContentResolver).notifyChange(
+        verify(mMockContentResolver)
-                DatabaseUtils.BATTERY_CONTENT_URI, /*observer=*/ null);
+                .notifyChange(DatabaseUtils.BATTERY_CONTENT_URI, /* observer= */ null);
     }
 
     @Test
@@ -243,16 +240,16 @@ public final class DatabaseUtilsTest {
                 DatabaseUtils.sendBatteryEntryData(
                         mContext,
                         System.currentTimeMillis(),
-                        /*batteryEntryList=*/ null,
+                        /* batteryEntryList= */ null,
                         mBatteryUsageStats,
-                        /*isFullChargeStart=*/ false);
+                        /* isFullChargeStart= */ false);
 
         assertThat(valuesList).hasSize(1);
         verifyFakeBatteryEntryContentValues(valuesList.get(0));
         // Verifies the inserted ContentValues into content provider.
         verify(mMockContentResolver).insert(any(), any());
-        verify(mMockContentResolver).notifyChange(
+        verify(mMockContentResolver)
-                DatabaseUtils.BATTERY_CONTENT_URI, /*observer=*/ null);
+                .notifyChange(DatabaseUtils.BATTERY_CONTENT_URI, /* observer= */ null);
     }
 
     @Test
@@ -263,16 +260,16 @@ public final class DatabaseUtilsTest {
                 DatabaseUtils.sendBatteryEntryData(
                         mContext,
                         System.currentTimeMillis(),
-                        /*batteryEntryList=*/ null,
+                        /* batteryEntryList= */ null,
-                        /*batteryUsageStats=*/ null,
+                        /* batteryUsageStats= */ null,
-                        /*isFullChargeStart=*/ false);
+                        /* isFullChargeStart= */ false);
 
         assertThat(valuesList).hasSize(1);
         verifyFakeBatteryEntryContentValues(valuesList.get(0));
         // Verifies the inserted ContentValues into content provider.
         verify(mMockContentResolver).insert(any(), any());
-        verify(mMockContentResolver).notifyChange(
+        verify(mMockContentResolver)
-                DatabaseUtils.BATTERY_CONTENT_URI, /*observer=*/ null);
+                .notifyChange(DatabaseUtils.BATTERY_CONTENT_URI, /* observer= */ null);
     }
 
     @Test
@@ -282,16 +279,20 @@ public final class DatabaseUtilsTest {
         DatabaseUtils.sFakeSupplier = () -> cursor;
 
         final long earliestTimestamp = 10001L;
-        assertThat(DatabaseUtils.getAppUsageStartTimestampOfUser(
+        assertThat(
-                mContext, /*userId=*/ 0, earliestTimestamp)).isEqualTo(earliestTimestamp);
+                        DatabaseUtils.getAppUsageStartTimestampOfUser(
+                                mContext, /* userId= */ 0, earliestTimestamp))
+                .isEqualTo(earliestTimestamp);
     }
 
     @Test
     public void getAppUsageStartTimestampOfUser_nullCursor_returnEarliestTimestamp() {
         DatabaseUtils.sFakeSupplier = () -> null;
         final long earliestTimestamp = 10001L;
-        assertThat(DatabaseUtils.getAppUsageStartTimestampOfUser(
+        assertThat(
-                mContext, /*userId=*/ 0, earliestTimestamp)).isEqualTo(earliestTimestamp);
+                        DatabaseUtils.getAppUsageStartTimestampOfUser(
+                                mContext, /* userId= */ 0, earliestTimestamp))
+                .isEqualTo(earliestTimestamp);
     }
 
     @Test
@@ -304,50 +305,62 @@ public final class DatabaseUtilsTest {
         DatabaseUtils.sFakeSupplier = () -> cursor;
 
         final long earliestTimestamp1 = 1001L;
-        assertThat(DatabaseUtils.getAppUsageStartTimestampOfUser(
+        assertThat(
-                mContext, /*userId=*/ 0, earliestTimestamp1)).isEqualTo(returnedTimestamp + 1);
+                        DatabaseUtils.getAppUsageStartTimestampOfUser(
+                                mContext, /* userId= */ 0, earliestTimestamp1))
+                .isEqualTo(returnedTimestamp + 1);
         final long earliestTimestamp2 = 100001L;
-        assertThat(DatabaseUtils.getAppUsageStartTimestampOfUser(
+        assertThat(
-                mContext, /*userId=*/ 0, earliestTimestamp2)).isEqualTo(earliestTimestamp2);
+                        DatabaseUtils.getAppUsageStartTimestampOfUser(
+                                mContext, /* userId= */ 0, earliestTimestamp2))
+                .isEqualTo(earliestTimestamp2);
     }
 
     @Test
     public void getAppUsageEventForUsers_emptyCursorContent_returnEmptyMap() {
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[]{
+                new MatrixCursor(
-                        AppUsageEventEntity.KEY_UID,
+                        new String[] {
-                        AppUsageEventEntity.KEY_USER_ID,
+                            AppUsageEventEntity.KEY_UID,
-                        AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_USER_ID,
-                        AppUsageEventEntity.KEY_TIMESTAMP,
+                            AppUsageEventEntity.KEY_PACKAGE_NAME,
-                        AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE});
+                            AppUsageEventEntity.KEY_TIMESTAMP,
+                            AppUsageEventEntity.KEY_APP_USAGE_EVENT_TYPE
+                        });
         DatabaseUtils.sFakeSupplier = () -> cursor;
 
-        assertThat(DatabaseUtils.getAppUsageEventForUsers(
+        assertThat(
-                mContext,
+                        DatabaseUtils.getAppUsageEventForUsers(
-                /*calendar=*/ null,
+                                mContext,
-                /*userIds=*/ new ArrayList<>(),
+                                /* calendar= */ null,
-                /*startTimestampOfLevelData=*/ 0)).isEmpty();
+                                /* userIds= */ new ArrayList<>(),
+                                /* startTimestampOfLevelData= */ 0))
+                .isEmpty();
     }
 
     @Test
     public void getAppUsageEventForUsers_nullCursor_returnEmptyMap() {
         DatabaseUtils.sFakeSupplier = () -> null;
-        assertThat(DatabaseUtils.getAppUsageEventForUsers(
+        assertThat(
-                mContext,
+                        DatabaseUtils.getAppUsageEventForUsers(
-                /*calendar=*/ null,
+                                mContext,
-                /*userIds=*/ new ArrayList<>(),
+                                /* calendar= */ null,
-                /*startTimestampOfLevelData=*/ 0)).isEmpty();
+                                /* userIds= */ new ArrayList<>(),
+                                /* startTimestampOfLevelData= */ 0))
+                .isEmpty();
     }
 
     @Test
     public void getAppUsageEventForUsers_returnExpectedMap() {
         final Long timestamp1 = 1001L;
         final Long timestamp2 = 1002L;
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[]{
+                new MatrixCursor(
-                        AppUsageEventEntity.KEY_UID,
+                        new String[] {
-                        AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_UID,
-                        AppUsageEventEntity.KEY_TIMESTAMP});
+                            AppUsageEventEntity.KEY_PACKAGE_NAME,
+                            AppUsageEventEntity.KEY_TIMESTAMP
+                        });
         // Adds fake data into the cursor.
         cursor.addRow(new Object[] {101L, "app name1", timestamp1});
         cursor.addRow(new Object[] {101L, "app name2", timestamp2});
@@ -355,11 +368,12 @@ public final class DatabaseUtilsTest {
         cursor.addRow(new Object[] {101L, "app name4", timestamp2});
         DatabaseUtils.sFakeSupplier = () -> cursor;
 
-        final List<AppUsageEvent> appUsageEventList = DatabaseUtils.getAppUsageEventForUsers(
+        final List<AppUsageEvent> appUsageEventList =
-                mContext,
+                DatabaseUtils.getAppUsageEventForUsers(
-                /*calendar=*/ null,
+                        mContext,
-                /*userIds=*/ new ArrayList<>(),
+                        /* calendar= */ null,
-                /*startTimestampOfLevelData=*/ 0);
+                        /* userIds= */ new ArrayList<>(),
+                        /* startTimestampOfLevelData= */ 0);
 
         assertThat(appUsageEventList.get(0).getPackageName()).isEqualTo("app name1");
         assertThat(appUsageEventList.get(1).getPackageName()).isEqualTo("app name2");
@@ -369,11 +383,13 @@ public final class DatabaseUtilsTest {
 
     @Test
     public void getHistoryMap_emptyCursorContent_returnEmptyMap() {
-        final MatrixCursor cursor = new MatrixCursor(
+        final MatrixCursor cursor =
-                new String[] {
+                new MatrixCursor(
-                        BatteryHistEntry.KEY_UID,
+                        new String[] {
-                        BatteryHistEntry.KEY_USER_ID,
+                            BatteryHistEntry.KEY_UID,
-                        BatteryHistEntry.KEY_TIMESTAMP});
+                            BatteryHistEntry.KEY_USER_ID,
+                            BatteryHistEntry.KEY_TIMESTAMP
+                        });
         DatabaseUtils.sFakeSupplier = () -> cursor;
 
         assertThat(DatabaseUtils.getHistoryMapSinceQueryTimestamp(mContext, 0)).isEmpty();
@@ -391,14 +407,22 @@ public final class DatabaseUtilsTest {
         final Long timestamp2 = Long.valueOf(1002L);
         final MatrixCursor cursor = getMatrixCursor();
         // Adds fake data into the cursor.
-        cursor.addRow(new Object[] {
+        cursor.addRow(
-                "app name1", timestamp1, 1, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, true});
+                new Object[] {
-        cursor.addRow(new Object[] {
+                    "app name1", timestamp1, 1, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, true
-                "app name2", timestamp2, 2, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false});
+                });
-        cursor.addRow(new Object[] {
+        cursor.addRow(
-                "app name3", timestamp2, 3, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false});
+                new Object[] {
-        cursor.addRow(new Object[] {
+                    "app name2", timestamp2, 2, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false
-                "app name4", timestamp2, 4, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false});
+                });
+        cursor.addRow(
+                new Object[] {
+                    "app name3", timestamp2, 3, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false
+                });
+        cursor.addRow(
+                new Object[] {
+                    "app name4", timestamp2, 4, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false
+                });
         DatabaseUtils.sFakeSupplier = () -> cursor;
 
         final Map<Long, Map<String, BatteryHistEntry>> batteryHistMap =
@@ -421,8 +445,9 @@ public final class DatabaseUtilsTest {
     public void getHistoryMap_withWorkProfile_returnExpectedMap()
             throws PackageManager.NameNotFoundException {
         doReturn("com.fake.package").when(mContext).getPackageName();
-        doReturn(mMockContext).when(mContext).createPackageContextAsUser(
+        doReturn(mMockContext)
-                "com.fake.package", /*flags=*/ 0, UserHandle.OWNER);
+                .when(mContext)
+                .createPackageContextAsUser("com.fake.package", /* flags= */ 0, UserHandle.OWNER);
         doReturn(UserHandle.CURRENT).when(mContext).getUser();
         doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
         doReturn(true).when(mUserManager).isManagedProfile();
@@ -440,9 +465,8 @@ public final class DatabaseUtilsTest {
     public void removeUsageSource_hasNoData() {
         DatabaseUtils.removeUsageSource(mContext);
         assertThat(
-                DatabaseUtils
+                        DatabaseUtils.getSharedPreferences(mContext)
-                        .getSharedPreferences(mContext)
+                                .contains(DatabaseUtils.KEY_LAST_USAGE_SOURCE))
-                        .contains(DatabaseUtils.KEY_LAST_USAGE_SOURCE))
                 .isFalse();
     }
 
@@ -457,9 +481,8 @@ public final class DatabaseUtilsTest {
         DatabaseUtils.removeUsageSource(mContext);
 
         assertThat(
-                DatabaseUtils
+                        DatabaseUtils.getSharedPreferences(mContext)
-                        .getSharedPreferences(mContext)
+                                .contains(DatabaseUtils.KEY_LAST_USAGE_SOURCE))
-                        .contains(DatabaseUtils.KEY_LAST_USAGE_SOURCE))
                 .isFalse();
     }
 
@@ -482,9 +505,10 @@ public final class DatabaseUtilsTest {
         assertThat(DatabaseUtils.getUsageSource(mContext, mUsageStatsManager))
                 .isEqualTo(USAGE_SOURCE_TASK_ROOT_ACTIVITY);
         assertThat(
-                DatabaseUtils
+                        DatabaseUtils.getSharedPreferences(mContext)
-                        .getSharedPreferences(mContext)
+                                .getInt(
-                        .getInt(DatabaseUtils.KEY_LAST_USAGE_SOURCE, USAGE_SOURCE_CURRENT_ACTIVITY))
+                                        DatabaseUtils.KEY_LAST_USAGE_SOURCE,
+                                        USAGE_SOURCE_CURRENT_ACTIVITY))
                 .isEqualTo(USAGE_SOURCE_TASK_ROOT_ACTIVITY);
     }
 
@@ -495,9 +519,10 @@ public final class DatabaseUtilsTest {
         assertThat(DatabaseUtils.getUsageSource(mContext, mUsageStatsManager))
                 .isEqualTo(USAGE_SOURCE_CURRENT_ACTIVITY);
         assertThat(
-                DatabaseUtils
+                        DatabaseUtils.getSharedPreferences(mContext)
-                        .getSharedPreferences(mContext)
+                                .getInt(
-                        .getInt(DatabaseUtils.KEY_LAST_USAGE_SOURCE, USAGE_SOURCE_CURRENT_ACTIVITY))
+                                        DatabaseUtils.KEY_LAST_USAGE_SOURCE,
+                                        USAGE_SOURCE_CURRENT_ACTIVITY))
                 .isEqualTo(USAGE_SOURCE_CURRENT_ACTIVITY);
     }
 
@@ -506,20 +531,16 @@ public final class DatabaseUtilsTest {
         final String preferenceKey = "test_preference_key";
         DatabaseUtils.recordDateTime(mContext, preferenceKey);
 
-        assertThat(DatabaseUtils.getSharedPreferences(mContext).contains(preferenceKey))
+        assertThat(DatabaseUtils.getSharedPreferences(mContext).contains(preferenceKey)).isTrue();
-                .isTrue();
     }
 
     @Test
     public void dump_dumpExpectedData() {
-        DatabaseUtils.recordDateTime(mContext,
+        DatabaseUtils.recordDateTime(mContext, Intent.ACTION_BATTERY_LEVEL_CHANGED);
-                Intent.ACTION_BATTERY_LEVEL_CHANGED);
+        DatabaseUtils.recordDateTime(
-        DatabaseUtils.recordDateTime(mContext,
+                mContext, BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING);
-                BatteryUsageBroadcastReceiver.ACTION_BATTERY_UNPLUGGING);
+        DatabaseUtils.recordDateTime(mContext, DatabaseUtils.KEY_LAST_LOAD_FULL_CHARGE_TIME);
-        DatabaseUtils.recordDateTime(mContext,
+        DatabaseUtils.recordDateTime(mContext, DatabaseUtils.KEY_LAST_UPLOAD_FULL_CHARGE_TIME);
-                DatabaseUtils.KEY_LAST_LOAD_FULL_CHARGE_TIME);
-        DatabaseUtils.recordDateTime(mContext,
-                DatabaseUtils.KEY_LAST_UPLOAD_FULL_CHARGE_TIME);
         final StringWriter stringWriter = new StringWriter();
         final PrintWriter printWriter = new PrintWriter(stringWriter);
 
@@ -570,8 +591,7 @@ public final class DatabaseUtilsTest {
                 .isEqualTo(BatteryManager.BATTERY_STATUS_FULL);
         assertThat(deviceBatteryState.getBatteryHealth())
                 .isEqualTo(BatteryManager.BATTERY_HEALTH_COLD);
-        assertThat(values.getAsString("packageName"))
+        assertThat(values.getAsString("packageName")).isEqualTo(ConvertUtils.FAKE_PACKAGE_NAME);
-                .isEqualTo(ConvertUtils.FAKE_PACKAGE_NAME);
     }
 
     private static Intent getBatteryIntent() {
@@ -586,10 +606,11 @@ public final class DatabaseUtilsTest {
     private static MatrixCursor getMatrixCursor() {
         return new MatrixCursor(
                 new String[] {
-                        BatteryHistEntry.KEY_PACKAGE_NAME,
+                    BatteryHistEntry.KEY_PACKAGE_NAME,
-                        BatteryHistEntry.KEY_TIMESTAMP,
+                    BatteryHistEntry.KEY_TIMESTAMP,
-                        BatteryHistEntry.KEY_UID,
+                    BatteryHistEntry.KEY_UID,
-                        BatteryHistEntry.KEY_CONSUMER_TYPE,
+                    BatteryHistEntry.KEY_CONSUMER_TYPE,
-                        BatteryHistEntry.KEY_IS_FULL_CHARGE_CYCLE_START});
+                    BatteryHistEntry.KEY_IS_FULL_CHARGE_CYCLE_START
+                });
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/PeriodicJobManagerTest.java

@@ -57,7 +57,7 @@ public final class PeriodicJobManagerTest {
 
     @Test
     public void refreshJob_refreshesAlarmJob() {
-        mPeriodicJobManager.refreshJob(/*fromBoot=*/ false);
+        mPeriodicJobManager.refreshJob(/* fromBoot= */ false);
 
         final ShadowAlarmManager.ScheduledAlarm alarm =
                 mShadowAlarmManager.peekNextScheduledAlarm();
@@ -71,12 +71,13 @@ public final class PeriodicJobManagerTest {
     public void getTriggerAtMillis_withoutOffset_returnsExpectedResult() {
         long timeSlotUnit = PeriodicJobManager.DATA_FETCH_INTERVAL_MINUTE;
         // Sets the current time.
-        Duration currentTimeDuration =
+        Duration currentTimeDuration = Duration.ofMinutes(timeSlotUnit * 2);
-                Duration.ofMinutes(timeSlotUnit * 2);
         FakeClock fakeClock = new FakeClock();
         fakeClock.setCurrentTime(currentTimeDuration);
 
-        assertThat(PeriodicJobManager.getTriggerAtMillis(mContext, fakeClock, /*fromBoot=*/ false))
+        assertThat(
+                        PeriodicJobManager.getTriggerAtMillis(
+                                mContext, fakeClock, /* fromBoot= */ false))
                 .isEqualTo(currentTimeDuration.plusMinutes(timeSlotUnit).toMillis());
     }
 
@@ -86,10 +87,9 @@ public final class PeriodicJobManagerTest {
         // Sets the current time.
         Duration currentTimeDuration = Duration.ofMinutes(timeSlotUnit * 2);
         FakeClock fakeClock = new FakeClock();
-        fakeClock.setCurrentTime(
+        fakeClock.setCurrentTime(currentTimeDuration.plusMinutes(1L).plusMillis(51L));
-                currentTimeDuration.plusMinutes(1L).plusMillis(51L));
 
-        assertThat(PeriodicJobManager.getTriggerAtMillis(mContext, fakeClock, /*fromBoot=*/ true))
+        assertThat(PeriodicJobManager.getTriggerAtMillis(mContext, fakeClock, /* fromBoot= */ true))
                 .isEqualTo(currentTimeDuration.plusMinutes(timeSlotUnit).toMillis());
     }
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/PeriodicJobReceiverTest.java

@@ -86,14 +86,14 @@ public final class PeriodicJobReceiverTest {
 
     @Test
     public void onReceive_nullIntent_notRefreshesJob() {
-        mReceiver.onReceive(mContext, /*intent=*/ null);
+        mReceiver.onReceive(mContext, /* intent= */ null);
         assertThat(mShadowAlarmManager.peekNextScheduledAlarm()).isNull();
     }
 
     @Test
     public void onReceive_containsExpiredData_clearsExpiredDataFromDatabase()
             throws InterruptedException {
-        insertExpiredData(/*shiftDay=*/ DatabaseUtils.DATA_RETENTION_INTERVAL_DAY);
+        insertExpiredData(/* shiftDay= */ DatabaseUtils.DATA_RETENTION_INTERVAL_DAY);
 
         mReceiver.onReceive(mContext, JOB_UPDATE_INTENT);
 
@@ -104,7 +104,7 @@ public final class PeriodicJobReceiverTest {
     @Test
     public void onReceive_withoutExpiredData_notClearsExpiredDataFromDatabase()
             throws InterruptedException {
-        insertExpiredData(/*shiftDay=*/ DatabaseUtils.DATA_RETENTION_INTERVAL_DAY - 1);
+        insertExpiredData(/* shiftDay= */ DatabaseUtils.DATA_RETENTION_INTERVAL_DAY - 1);
 
         mReceiver.onReceive(mContext, JOB_UPDATE_INTENT);
 
@@ -129,5 +129,4 @@ public final class PeriodicJobReceiverTest {
         // Ensures the testing environment is correct.
         assertThat(mDao.getAllAfter(0)).hasSize(3);
     }
-
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/PowerGaugePreferenceTest.java

@@ -53,8 +53,12 @@ public class PowerGaugePreferenceTest {
         MockitoAnnotations.initMocks(this);
 
         mContext = RuntimeEnvironment.application;
-        mRootView = LayoutInflater.from(mContext)
+        mRootView =
-                .inflate(com.android.settingslib.widget.preference.app.R.layout.preference_app, null);
+                LayoutInflater.from(mContext)
+                        .inflate(
+                                com.android.settingslib.widget.preference.app.R.layout
+                                        .preference_app,
+                                null);
         mWidgetView =
                 LayoutInflater.from(mContext).inflate(R.layout.preference_widget_summary, null);
         final LinearLayout widgetFrame = mRootView.findViewById(android.R.id.widget_frame);

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/PowerUsageAdvancedTest.java

@@ -55,14 +55,10 @@ public final class PowerUsageAdvancedTest {
     private Predicate<PowerAnomalyEvent> mCardFilterPredicate;
     private Predicate<PowerAnomalyEvent> mSlotFilterPredicate;
 
-    @Mock
+    @Mock private BatteryTipsController mBatteryTipsController;
-    private BatteryTipsController mBatteryTipsController;
+    @Mock private BatteryChartPreferenceController mBatteryChartPreferenceController;
-    @Mock
+    @Mock private ScreenOnTimeController mScreenOnTimeController;
-    private BatteryChartPreferenceController mBatteryChartPreferenceController;
+    @Mock private BatteryUsageBreakdownController mBatteryUsageBreakdownController;
-    @Mock
-    private ScreenOnTimeController mScreenOnTimeController;
-    @Mock
-    private BatteryUsageBreakdownController mBatteryUsageBreakdownController;
 
     @Before
     public void setUp() {
@@ -75,10 +71,13 @@ public final class PowerUsageAdvancedTest {
         mPowerUsageAdvanced.mBatteryChartPreferenceController = mBatteryChartPreferenceController;
         mPowerUsageAdvanced.mScreenOnTimeController = mScreenOnTimeController;
         mPowerUsageAdvanced.mBatteryUsageBreakdownController = mBatteryUsageBreakdownController;
-        mPowerUsageAdvanced.mBatteryLevelData = Optional.of(new BatteryLevelData(Map.of(
+        mPowerUsageAdvanced.mBatteryLevelData =
-                1694354400000L, 1,      // 2023-09-10 22:00:00
+                Optional.of(
-                1694361600000L, 2,      // 2023-09-11 00:00:00
+                        new BatteryLevelData(
-                1694368800000L, 3)));    // 2023-09-11 02:00:00
+                                Map.of(
+                                        1694354400000L, 1, // 2023-09-10 22:00:00
+                                        1694361600000L, 2, // 2023-09-11 00:00:00
+                                        1694368800000L, 3))); // 2023-09-11 02:00:00
         doReturn(mContext).when(mPowerUsageAdvanced).getContext();
         mSlotFilterPredicate = PowerAnomalyEvent::hasWarningItemInfo;
     }
@@ -86,15 +85,17 @@ public final class PowerUsageAdvancedTest {
     @Test
     public void getFilterAnomalyEvent_withEmptyOrNullList_getNull() {
         prepareCardFilterPredicate(null);
-        assertThat(PowerUsageAdvanced
+        assertThat(PowerUsageAdvanced.getAnomalyEvent(null, mCardFilterPredicate)).isNull();
-                .getAnomalyEvent(null, mCardFilterPredicate)).isNull();
+        assertThat(PowerUsageAdvanced.getAnomalyEvent(null, mSlotFilterPredicate)).isNull();
-        assertThat(PowerUsageAdvanced
+        assertThat(
-                .getAnomalyEvent(null, mSlotFilterPredicate)).isNull();
+                        PowerUsageAdvanced.getAnomalyEvent(
-        assertThat(PowerUsageAdvanced.getAnomalyEvent(
+                                BatteryTestUtils.createEmptyPowerAnomalyEventList(),
-                BatteryTestUtils.createEmptyPowerAnomalyEventList(), mCardFilterPredicate))
+                                mCardFilterPredicate))
                 .isNull();
-        assertThat(PowerUsageAdvanced.getAnomalyEvent(
+        assertThat(
-                BatteryTestUtils.createEmptyPowerAnomalyEventList(), mSlotFilterPredicate))
+                        PowerUsageAdvanced.getAnomalyEvent(
+                                BatteryTestUtils.createEmptyPowerAnomalyEventList(),
+                                mSlotFilterPredicate))
                 .isNull();
     }
 
@@ -104,12 +105,10 @@ public final class PowerUsageAdvancedTest {
                 BatteryTestUtils.createNonEmptyPowerAnomalyEventList();
 
         final PowerAnomalyEvent slotEvent =
-                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList,
+                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList, mSlotFilterPredicate);
-                        mSlotFilterPredicate);
         prepareCardFilterPredicate(slotEvent);
         final PowerAnomalyEvent cardEvent =
-                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList,
+                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList, mCardFilterPredicate);
-                        mCardFilterPredicate);
 
         assertThat(cardEvent).isEqualTo(BatteryTestUtils.createAdaptiveBrightnessAnomalyEvent());
         assertThat(slotEvent).isNull();
@@ -123,12 +122,10 @@ public final class PowerUsageAdvancedTest {
         DatabaseUtils.setDismissedPowerAnomalyKeys(mContext, PowerAnomalyKey.KEY_BRIGHTNESS.name());
 
         final PowerAnomalyEvent slotEvent =
-                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList,
+                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList, mSlotFilterPredicate);
-                        mSlotFilterPredicate);
         prepareCardFilterPredicate(slotEvent);
         final PowerAnomalyEvent cardEvent =
-                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList,
+                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList, mCardFilterPredicate);
-                        mCardFilterPredicate);
 
         assertThat(cardEvent).isEqualTo(BatteryTestUtils.createScreenTimeoutAnomalyEvent());
         assertThat(slotEvent).isNull();
@@ -144,12 +141,10 @@ public final class PowerUsageAdvancedTest {
         }
 
         final PowerAnomalyEvent slotEvent =
-                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList,
+                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList, mSlotFilterPredicate);
-                        mSlotFilterPredicate);
         prepareCardFilterPredicate(slotEvent);
         final PowerAnomalyEvent cardEvent =
-                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList,
+                PowerUsageAdvanced.getAnomalyEvent(powerAnomalyEventList, mCardFilterPredicate);
-                        mCardFilterPredicate);
 
         assertThat(cardEvent).isNull();
         assertThat(slotEvent).isNull();
@@ -165,9 +160,10 @@ public final class PowerUsageAdvancedTest {
                 .isEqualTo(event.getEventId());
         verify(mPowerUsageAdvanced.mBatteryTipsController).setOnAnomalyConfirmListener(isNull());
         verify(mPowerUsageAdvanced.mBatteryTipsController).setOnAnomalyRejectListener(isNull());
-        verify(mPowerUsageAdvanced.mBatteryChartPreferenceController).onHighlightSlotIndexUpdate(
+        verify(mPowerUsageAdvanced.mBatteryChartPreferenceController)
-                eq(BatteryChartViewModel.SELECTED_INDEX_INVALID),
+                .onHighlightSlotIndexUpdate(
-                eq(BatteryChartViewModel.SELECTED_INDEX_INVALID));
+                        eq(BatteryChartViewModel.SELECTED_INDEX_INVALID),
+                        eq(BatteryChartViewModel.SELECTED_INDEX_INVALID));
     }
 
     @Test
@@ -180,10 +176,14 @@ public final class PowerUsageAdvancedTest {
                 .isEqualTo(event.getEventId());
         verify(mBatteryTipsController).setOnAnomalyConfirmListener(isNull());
         verify(mBatteryTipsController).setOnAnomalyRejectListener(isNull());
-        assertThat(mPowerUsageAdvanced.mBatteryLevelData.get().getIndexByTimestamps(
+        assertThat(
-                event.getWarningItemInfo().getStartTimestamp(),
+                        mPowerUsageAdvanced
-                event.getWarningItemInfo().getEndTimestamp()
+                                .mBatteryLevelData
-        )).isEqualTo(Pair.create(1, 0));
+                                .get()
+                                .getIndexByTimestamps(
+                                        event.getWarningItemInfo().getStartTimestamp(),
+                                        event.getWarningItemInfo().getEndTimestamp()))
+                .isEqualTo(Pair.create(1, 0));
         verify(mBatteryChartPreferenceController).onHighlightSlotIndexUpdate(eq(1), eq(0));
         verify(mBatteryTipsController).setOnAnomalyConfirmListener(notNull());
     }
@@ -192,8 +192,7 @@ public final class PowerUsageAdvancedTest {
     public void onDisplayAnomalyEventUpdated_withSettingsCardAndAppsSlotEvent_showExpected() {
         final PowerAnomalyEvent settingsEvent =
                 BatteryTestUtils.createAdaptiveBrightnessAnomalyEvent();
-        final PowerAnomalyEvent appsEvent =
+        final PowerAnomalyEvent appsEvent = BatteryTestUtils.createAppAnomalyEvent();
-                BatteryTestUtils.createAppAnomalyEvent();
 
         mPowerUsageAdvanced.onDisplayAnomalyEventUpdated(settingsEvent, appsEvent);
 
@@ -207,8 +206,9 @@ public final class PowerUsageAdvancedTest {
     private void prepareCardFilterPredicate(PowerAnomalyEvent slotEvent) {
         final Set<String> dismissedPowerAnomalyKeys =
                 DatabaseUtils.getDismissedPowerAnomalyKeys(mContext);
-        mCardFilterPredicate = event -> !dismissedPowerAnomalyKeys.contains(
+        mCardFilterPredicate =
-                event.getDismissRecordKey())
+                event ->
-                && (event.equals(slotEvent) || !event.hasWarningItemInfo());
+                        !dismissedPowerAnomalyKeys.contains(event.getDismissRecordKey())
+                                && (event.equals(slotEvent) || !event.hasWarningItemInfo());
     }
-}
+}

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/PowerUsageBaseTest.java

@@ -52,10 +52,8 @@ import java.util.List;
 @Config(shadows = ShadowDashboardFragment.class)
 public class PowerUsageBaseTest {
 
-    @Mock
+    @Mock private LoaderManager mLoaderManager;
-    private LoaderManager mLoaderManager;
+    @Mock private Loader<BatteryUsageStats> mBatteryUsageStatsLoader;
-    @Mock
-    private Loader<BatteryUsageStats> mBatteryUsageStatsLoader;
     private TestFragment mFragment;
 
     @Before
@@ -77,16 +75,19 @@ public class PowerUsageBaseTest {
         final Bundle bundle = new Bundle();
         bundle.putInt(KEY_REFRESH_TYPE, BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_STATUS);
         bundle.putBoolean(KEY_INCLUDE_HISTORY, false);
-        doReturn(mBatteryUsageStatsLoader).when(mLoaderManager).getLoader(
+        doReturn(mBatteryUsageStatsLoader)
-                PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER);
         doReturn(false).when(mBatteryUsageStatsLoader).isReset();
 
         mFragment.restartBatteryStatsLoader(
                 BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_STATUS);
 
         verify(mLoaderManager)
-                .restartLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER),
+                .restartLoader(
-                        refEq(bundle), any());
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER),
+                        refEq(bundle),
+                        any());
     }
 
     @Test
@@ -94,16 +95,19 @@ public class PowerUsageBaseTest {
         final Bundle bundle = new Bundle();
         bundle.putInt(KEY_REFRESH_TYPE, BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_STATUS);
         bundle.putBoolean(KEY_INCLUDE_HISTORY, false);
-        doReturn(mBatteryUsageStatsLoader).when(mLoaderManager).getLoader(
+        doReturn(mBatteryUsageStatsLoader)
-                PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER);
         doReturn(true).when(mBatteryUsageStatsLoader).isReset();
 
         mFragment.restartBatteryStatsLoader(
                 BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_STATUS);
 
         verify(mLoaderManager)
-                .initLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER),
+                .initLoader(
-                        refEq(bundle), any());
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER),
+                        refEq(bundle),
+                        any());
     }
 
     @Test
@@ -111,14 +115,18 @@ public class PowerUsageBaseTest {
         final Bundle bundle = new Bundle();
         bundle.putInt(KEY_REFRESH_TYPE, BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_STATUS);
         bundle.putBoolean(KEY_INCLUDE_HISTORY, false);
-        doReturn(null).when(mLoaderManager).getLoader(
+        doReturn(null)
-                PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER);
 
         mFragment.restartBatteryStatsLoader(
                 BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_STATUS);
 
-        verify(mLoaderManager).initLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER),
+        verify(mLoaderManager)
-                refEq(bundle), any());
+                .initLoader(
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_USAGE_STATS_LOADER),
+                        refEq(bundle),
+                        any());
     }
 
     private static class TestFragment extends PowerUsageBase {

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/PowerUsageSummaryTest.java

@@ -70,9 +70,10 @@ import java.util.List;
 
 // TODO: Improve this test class so that it starts up the real activity and fragment.
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {
+@Config(
-        com.android.settings.testutils.shadow.ShadowFragment.class,
+        shadows = {
-})
+            com.android.settings.testutils.shadow.ShadowFragment.class,
+        })
 public class PowerUsageSummaryTest {
     private static Intent sAdditionalBatteryInfoIntent;
 
@@ -81,26 +82,16 @@ public class PowerUsageSummaryTest {
         sAdditionalBatteryInfoIntent = new Intent("com.example.app.ADDITIONAL_BATTERY_INFO");
     }
 
-    @Mock
+    @Mock private SettingsActivity mSettingsActivity;
-    private SettingsActivity mSettingsActivity;
+    @Mock private LoaderManager mLoaderManager;
-    @Mock
+    @Mock private Loader<BatteryTip> mBatteryTipLoader;
-    private LoaderManager mLoaderManager;
+    @Mock private Loader<BatteryInfo> mBatteryInfoLoader;
-    @Mock
+    @Mock private ContentResolver mContentResolver;
-    private Loader<BatteryTip> mBatteryTipLoader;
+    @Mock private BatteryBroadcastReceiver mBatteryBroadcastReceiver;
-    @Mock
+    @Mock private VisibilityLoggerMixin mVisibilityLoggerMixin;
-    private Loader<BatteryInfo> mBatteryInfoLoader;
+    @Mock private PreferenceScreen mPreferenceScreen;
-    @Mock
+    @Mock private Preference mBatteryUsagePreference;
-    private ContentResolver mContentResolver;
+    @Mock private Preference mHelpPreference;
-    @Mock
-    private BatteryBroadcastReceiver mBatteryBroadcastReceiver;
-    @Mock
-    private VisibilityLoggerMixin mVisibilityLoggerMixin;
-    @Mock
-    private PreferenceScreen mPreferenceScreen;
-    @Mock
-    private Preference mBatteryUsagePreference;
-    @Mock
-    private Preference mHelpPreference;
 
     private Context mRealContext;
     private TestFragment mFragment;
@@ -120,8 +111,8 @@ public class PowerUsageSummaryTest {
                 .thenReturn(sAdditionalBatteryInfoIntent);
         mFragment.mBatteryUtils = Mockito.spy(new BatteryUtils(mRealContext));
         ReflectionHelpers.setField(mFragment, "mVisibilityLoggerMixin", mVisibilityLoggerMixin);
-        ReflectionHelpers.setField(mFragment, "mBatteryBroadcastReceiver",
+        ReflectionHelpers.setField(
-                mBatteryBroadcastReceiver);
+                mFragment, "mBatteryBroadcastReceiver", mBatteryBroadcastReceiver);
         doReturn(mPreferenceScreen).when(mFragment).getPreferenceScreen();
         when(mFragment.getContentResolver()).thenReturn(mContentResolver);
         when(mFragment.findPreference(KEY_BATTERY_USAGE)).thenReturn(mBatteryUsagePreference);
@@ -157,42 +148,46 @@ public class PowerUsageSummaryTest {
 
     @Test
     public void restartBatteryTipLoader() {
-        //TODO: add policy logic here when BatteryTipPolicy is implemented
+        // TODO: add policy logic here when BatteryTipPolicy is implemented
-        doReturn(mBatteryTipLoader).when(mLoaderManager).getLoader(
+        doReturn(mBatteryTipLoader)
-                PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER);
         doReturn(false).when(mBatteryTipLoader).isReset();
 
         mFragment.restartBatteryTipLoader();
 
-        verify(mLoaderManager).restartLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER),
+        verify(mLoaderManager)
-                eq(Bundle.EMPTY), any());
+                .restartLoader(
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER), eq(Bundle.EMPTY), any());
     }
 
     @Test
     public void restartBatteryTipLoader_nullLoader_initLoader() {
-        doReturn(null).when(mLoaderManager).getLoader(
+        doReturn(null)
-                PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER);
 
         mFragment.restartBatteryTipLoader();
 
-        verify(mLoaderManager).initLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER),
+        verify(mLoaderManager)
-                eq(Bundle.EMPTY), any());
+                .initLoader(
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER), eq(Bundle.EMPTY), any());
     }
 
     @Test
     public void restartBatteryTipLoader_loaderReset_initLoader() {
-        doReturn(mBatteryTipLoader).when(mLoaderManager).getLoader(
+        doReturn(mBatteryTipLoader)
-                PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER);
         doReturn(true).when(mBatteryTipLoader).isReset();
 
         mFragment.restartBatteryTipLoader();
 
-
+        verify(mLoaderManager)
-        verify(mLoaderManager).initLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER),
+                .initLoader(
-                eq(Bundle.EMPTY), any());
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_TIP_LOADER), eq(Bundle.EMPTY), any());
     }
 
-
     @Test
     public void refreshUi_contextNull_doNothing() {
         doReturn(null).when(mFragment).getContext();
@@ -256,18 +251,19 @@ public class PowerUsageSummaryTest {
     public void onResume_registerContentObserver() {
         mFragment.onResume();
 
-        verify(mContentResolver).registerContentObserver(
+        verify(mContentResolver)
-                Settings.Global.getUriFor(Settings.Global.BATTERY_ESTIMATES_LAST_UPDATE_TIME),
+                .registerContentObserver(
-                false,
+                        Settings.Global.getUriFor(
-                mFragment.mSettingsObserver);
+                                Settings.Global.BATTERY_ESTIMATES_LAST_UPDATE_TIME),
+                        false,
+                        mFragment.mSettingsObserver);
     }
 
     @Test
     public void onPause_unregisterContentObserver() {
         mFragment.onPause();
 
-        verify(mContentResolver).unregisterContentObserver(
+        verify(mContentResolver).unregisterContentObserver(mFragment.mSettingsObserver);
-                mFragment.mSettingsObserver);
     }
 
     @Test
@@ -276,9 +272,11 @@ public class PowerUsageSummaryTest {
 
         mFragment.restartBatteryInfoLoader();
 
-        verify(mLoaderManager, never()).restartLoader(
+        verify(mLoaderManager, never())
-                PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER, Bundle.EMPTY,
+                .restartLoader(
-                mFragment.mBatteryInfoLoaderCallbacks);
+                        PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER,
+                        Bundle.EMPTY,
+                        mFragment.mBatteryInfoLoaderCallbacks);
     }
 
     @Test
@@ -287,45 +285,59 @@ public class PowerUsageSummaryTest {
 
         mFragment.restartBatteryInfoLoader();
 
-        verify(mLoaderManager, never()).restartLoader(
+        verify(mLoaderManager, never())
-                PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER, Bundle.EMPTY,
+                .restartLoader(
-                mFragment.mBatteryInfoLoaderCallbacks);
+                        PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER,
+                        Bundle.EMPTY,
+                        mFragment.mBatteryInfoLoaderCallbacks);
     }
 
     @Test
     public void restartBatteryInfoLoader() {
-        doReturn(mBatteryInfoLoader).when(mLoaderManager).getLoader(
+        doReturn(mBatteryInfoLoader)
-                PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER);
         doReturn(false).when(mBatteryTipLoader).isReset();
 
         mFragment.restartBatteryInfoLoader();
 
-        verify(mLoaderManager).restartLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER),
+        verify(mLoaderManager)
-                eq(Bundle.EMPTY), any());
+                .restartLoader(
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER),
+                        eq(Bundle.EMPTY),
+                        any());
     }
 
     @Test
     public void restartBatteryInfoLoader_nullLoader_initLoader() {
-        doReturn(null).when(mLoaderManager).getLoader(
+        doReturn(null)
-                PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER);
 
         mFragment.restartBatteryInfoLoader();
 
-        verify(mLoaderManager).initLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER),
+        verify(mLoaderManager)
-                eq(Bundle.EMPTY), any());
+                .initLoader(
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER),
+                        eq(Bundle.EMPTY),
+                        any());
     }
 
     @Test
     public void restartBatteryInfoLoader_loaderReset_initLoader() {
         mFragment.setIsBatteryPresent(true);
-        doReturn(mBatteryInfoLoader).when(mLoaderManager).getLoader(
+        doReturn(mBatteryInfoLoader)
-                PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER);
+                .when(mLoaderManager)
+                .getLoader(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER);
         doReturn(true).when(mBatteryInfoLoader).isReset();
 
         mFragment.restartBatteryInfoLoader();
 
-        verify(mLoaderManager).initLoader(eq(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER),
+        verify(mLoaderManager)
-                eq(Bundle.EMPTY), any());
+                .initLoader(
+                        eq(PowerUsageBase.LoaderIndex.BATTERY_INFO_LOADER),
+                        eq(Bundle.EMPTY),
+                        any());
     }
 
     private static class TestFragment extends PowerUsageSummary {
@@ -357,5 +369,4 @@ public class PowerUsageSummaryTest {
             return mLoaderManager;
         }
     }
-
 }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ScreenOnTimeControllerTest.java

@@ -46,10 +46,8 @@ public final class ScreenOnTimeControllerTest {
     private Context mContext;
     private ScreenOnTimeController mScreenOnTimeController;
 
-    @Mock
+    @Mock private PreferenceCategory mRootPreference;
-    private PreferenceCategory mRootPreference;
+    @Mock private TextViewPreference mScreenOnTimeTextPreference;
-    @Mock
-    private TextViewPreference mScreenOnTimeTextPreference;
 
     @Before
     public void setUp() {

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/SpinnerPreferenceTest.java

@@ -42,14 +42,13 @@ public final class SpinnerPreferenceTest {
     private Context mContext;
     private SpinnerPreference mSpinnerPreference;
 
-    @Mock
+    @Mock private Spinner mMockSpinner;
-    private Spinner mMockSpinner;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = spy(RuntimeEnvironment.application);
-        mSpinnerPreference = new SpinnerPreference(mContext, /*attrs=*/ null);
+        mSpinnerPreference = new SpinnerPreference(mContext, /* attrs= */ null);
     }
 
     @Test
@@ -59,7 +58,7 @@ public final class SpinnerPreferenceTest {
 
     @Test
     public void initializeSpinner_returnExpectedResult() {
-        final String[] items = new String[]{"item1", "item2"};
+        final String[] items = new String[] {"item1", "item2"};
         mSpinnerPreference.initializeSpinner(items, null);
         assertThat(mSpinnerPreference.mItems).isEqualTo(items);
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/TextViewPreferenceTest.java

@@ -41,13 +41,13 @@ public final class TextViewPreferenceTest {
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = spy(RuntimeEnvironment.application);
-        mTextViewPreference = new TextViewPreference(mContext, /*attrs=*/ null);
+        mTextViewPreference = new TextViewPreference(mContext, /* attrs= */ null);
     }
 
     @Test
     public void constructor_returnExpectedResult() {
-        assertThat(mTextViewPreference.getLayoutResource()).isEqualTo(
+        assertThat(mTextViewPreference.getLayoutResource())
-                R.layout.preference_text_view);
+                .isEqualTo(R.layout.preference_text_view);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/TimestampUtilsTest.java

@@ -36,11 +36,9 @@ public class TimestampUtilsTest {
     @Test
     public void getNextHourTimestamp_returnExpectedResult() {
         // 2021-02-28 06:00:00 => 2021-02-28 07:00:00
-        assertThat(TimestampUtils.getNextHourTimestamp(1614463200000L))
+        assertThat(TimestampUtils.getNextHourTimestamp(1614463200000L)).isEqualTo(1614466800000L);
-                .isEqualTo(1614466800000L);
         // 2021-12-31 23:59:59 => 2022-01-01 00:00:00
-        assertThat(TimestampUtils.getNextHourTimestamp(16409663999999L))
+        assertThat(TimestampUtils.getNextHourTimestamp(16409663999999L)).isEqualTo(16409664000000L);
-                .isEqualTo(16409664000000L);
     }
 
     @Test
@@ -66,11 +64,9 @@ public class TimestampUtilsTest {
     @Test
     public void getTimestampOfNextDay_returnExpectedResult() {
         // 2021-02-28 06:00:00 => 2021-03-01 00:00:00
-        assertThat(TimestampUtils.getNextDayTimestamp(1614463200000L))
+        assertThat(TimestampUtils.getNextDayTimestamp(1614463200000L)).isEqualTo(1614528000000L);
-                .isEqualTo(1614528000000L);
         // 2021-12-31 16:00:00 => 2022-01-01 00:00:00
-        assertThat(TimestampUtils.getNextDayTimestamp(1640937600000L))
+        assertThat(TimestampUtils.getNextDayTimestamp(1640937600000L)).isEqualTo(1640966400000L);
-                .isEqualTo(1640966400000L);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/bugreport/BugReportContentProviderTest.java

@@ -52,7 +52,7 @@ public final class BugReportContentProviderTest {
         mPrintWriter = new PrintWriter(mStringWriter);
         mContext = ApplicationProvider.getApplicationContext();
         mBugReportContentProvider = new BugReportContentProvider();
-        mBugReportContentProvider.attachInfo(mContext, /*info=*/ null);
+        mBugReportContentProvider.attachInfo(mContext, /* info= */ null);
         // Inserts fake data into database for testing.
         BatteryTestUtils.setUpBatteryStateDatabase(mContext);
         BatteryTestUtils.insertDataToBatteryStateTable(
@@ -60,15 +60,15 @@ public final class BugReportContentProviderTest {
         BatteryTestUtils.insertDataToBatteryStateTable(
                 mContext, System.currentTimeMillis(), PACKAGE_NAME2);
         BatteryTestUtils.insertDataToAppUsageEventTable(
-                mContext, /*userId=*/ 1, System.currentTimeMillis(), PACKAGE_NAME3);
+                mContext, /* userId= */ 1, System.currentTimeMillis(), PACKAGE_NAME3);
         BatteryTestUtils.insertDataToAppUsageEventTable(
-                mContext, /*userId=*/ 1, System.currentTimeMillis(), PACKAGE_NAME4);
+                mContext, /* userId= */ 1, System.currentTimeMillis(), PACKAGE_NAME4);
     }
 
     @Test
     public void dump_nullContext_notDumpsBatteryUsageData() {
         mBugReportContentProvider = new BugReportContentProvider();
-        mBugReportContentProvider.attachInfo(/*context=*/ null, /*info=*/ null);
+        mBugReportContentProvider.attachInfo(/* context= */ null, /* info= */ null);
 
         mBugReportContentProvider.dump(FileDescriptor.out, mPrintWriter, new String[] {});
 

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/AppUsageEventDaoTest.java

@@ -61,13 +61,13 @@ public final class AppUsageEventDaoTest {
         BatteryTestUtils.insertDataToAppUsageEventTable(
                 mContext, USER_ID2, TIMESTAMP2, PACKAGE_NAME2);
         BatteryTestUtils.insertDataToAppUsageEventTable(
-                mContext, USER_ID1, TIMESTAMP1, PACKAGE_NAME1, /*multiple=*/ true);
+                mContext, USER_ID1, TIMESTAMP1, PACKAGE_NAME1, /* multiple= */ true);
     }
 
     @After
     public void closeDb() {
         mDatabase.close();
-        BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
+        BatteryStateDatabase.setBatteryStateDatabase(/* database= */ null);
     }
 
     @Test
@@ -147,7 +147,7 @@ public final class AppUsageEventDaoTest {
 
     @Test
     public void getInstance_createNewInstance() throws Exception {
-        BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
+        BatteryStateDatabase.setBatteryStateDatabase(/* database= */ null);
         assertThat(BatteryStateDatabase.getInstance(mContext)).isNotNull();
     }
 

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/AppUsageEventEntityTest.java

@@ -35,16 +35,16 @@ public final class AppUsageEventEntityTest {
         final int instanceId = 100001;
         final String taskRootPackageName = "com.android.settings2";
 
-        AppUsageEventEntity entity = AppUsageEventEntity
+        AppUsageEventEntity entity =
-                .newBuilder()
+                AppUsageEventEntity.newBuilder()
-                .setUid(uid)
+                        .setUid(uid)
-                .setUserId(userId)
+                        .setUserId(userId)
-                .setTimestamp(timestamp)
+                        .setTimestamp(timestamp)
-                .setAppUsageEventType(appUsageEventType)
+                        .setAppUsageEventType(appUsageEventType)
-                .setPackageName(packageName)
+                        .setPackageName(packageName)
-                .setInstanceId(instanceId)
+                        .setInstanceId(instanceId)
-                .setTaskRootPackageName(taskRootPackageName)
+                        .setTaskRootPackageName(taskRootPackageName)
-                .build();
+                        .build();
 
         // Verifies the app relative information.
         assertThat(entity.uid).isEqualTo(uid);

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryEventDaoTest.java

@@ -57,22 +57,23 @@ public final class BatteryEventDaoTest {
     @After
     public void closeDb() {
         mDatabase.close();
-        BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
+        BatteryStateDatabase.setBatteryStateDatabase(/* database= */ null);
     }
 
-
     @Test
     public void getLastFullChargeTimestamp_normalFlow_expectedBehavior() throws Exception {
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+        mBatteryEventDao.insert(
-                .setTimestamp(TIMESTAMP1)
+                BatteryEventEntity.newBuilder()
-                .setBatteryEventType(3)
+                        .setTimestamp(TIMESTAMP1)
-                .setBatteryLevel(100)
+                        .setBatteryEventType(3)
-                .build());
+                        .setBatteryLevel(100)
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+                        .build());
-                .setTimestamp(TIMESTAMP2)
+        mBatteryEventDao.insert(
-                .setBatteryEventType(4)
+                BatteryEventEntity.newBuilder()
-                .setBatteryLevel(96)
+                        .setTimestamp(TIMESTAMP2)
-                .build());
+                        .setBatteryEventType(4)
+                        .setBatteryLevel(96)
+                        .build());
 
         final Cursor cursor = mBatteryEventDao.getLastFullChargeTimestamp();
         assertThat(cursor.getCount()).isEqualTo(1);
@@ -83,11 +84,12 @@ public final class BatteryEventDaoTest {
     @Test
     public void getLastFullChargeTimestamp_noLastFullChargeTime_returns0() throws Exception {
         mBatteryEventDao.clearAll();
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+        mBatteryEventDao.insert(
-                .setTimestamp(TIMESTAMP2)
+                BatteryEventEntity.newBuilder()
-                .setBatteryEventType(4)
+                        .setTimestamp(TIMESTAMP2)
-                .setBatteryLevel(96)
+                        .setBatteryEventType(4)
-                .build());
+                        .setBatteryLevel(96)
+                        .build());
 
         final Cursor cursor = mBatteryEventDao.getLastFullChargeTimestamp();
 
@@ -98,26 +100,25 @@ public final class BatteryEventDaoTest {
 
     @Test
     public void getAllAfter_normalFlow_returnExpectedResult() {
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+        mBatteryEventDao.insert(
-                .setTimestamp(100L)
+                BatteryEventEntity.newBuilder()
-                .setBatteryEventType(1)
+                        .setTimestamp(100L)
-                .setBatteryLevel(66)
+                        .setBatteryEventType(1)
-                .build());
+                        .setBatteryLevel(66)
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+                        .build());
-                .setTimestamp(200L)
+        mBatteryEventDao.insert(
-                .setBatteryEventType(2)
+                BatteryEventEntity.newBuilder()
-                .setBatteryLevel(88)
+                        .setTimestamp(200L)
-                .build());
+                        .setBatteryEventType(2)
+                        .setBatteryLevel(88)
+                        .build());
 
         final Cursor cursor = mBatteryEventDao.getAllAfter(160L, List.of(1, 2));
         assertThat(cursor.getCount()).isEqualTo(1);
         cursor.moveToFirst();
-        assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP)))
+        assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP))).isEqualTo(200L);
-                .isEqualTo(200L);
+        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE))).isEqualTo(2);
-        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE)))
+        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL))).isEqualTo(88);
-                .isEqualTo(2);
-        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL)))
-                .isEqualTo(88);
 
         mBatteryEventDao.clearAll();
         assertThat(mBatteryEventDao.getAll()).isEmpty();
@@ -125,26 +126,25 @@ public final class BatteryEventDaoTest {
 
     @Test
     public void getAllAfter_filterBatteryTypes_returnExpectedResult() {
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+        mBatteryEventDao.insert(
-                .setTimestamp(100L)
+                BatteryEventEntity.newBuilder()
-                .setBatteryEventType(1)
+                        .setTimestamp(100L)
-                .setBatteryLevel(66)
+                        .setBatteryEventType(1)
-                .build());
+                        .setBatteryLevel(66)
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+                        .build());
-                .setTimestamp(200L)
+        mBatteryEventDao.insert(
-                .setBatteryEventType(2)
+                BatteryEventEntity.newBuilder()
-                .setBatteryLevel(88)
+                        .setTimestamp(200L)
-                .build());
+                        .setBatteryEventType(2)
+                        .setBatteryLevel(88)
+                        .build());
 
         final Cursor cursor = mBatteryEventDao.getAllAfter(0L, List.of(1));
         assertThat(cursor.getCount()).isEqualTo(1);
         cursor.moveToFirst();
-        assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP)))
+        assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP))).isEqualTo(100L);
-                .isEqualTo(100L);
+        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE))).isEqualTo(1);
-        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE)))
+        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL))).isEqualTo(66);
-                .isEqualTo(1);
-        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL)))
-                .isEqualTo(66);
 
         mBatteryEventDao.clearAll();
         assertThat(mBatteryEventDao.getAll()).isEmpty();
@@ -152,26 +152,25 @@ public final class BatteryEventDaoTest {
 
     @Test
     public void getAllAfter_filterTimestamp_returnExpectedResult() {
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+        mBatteryEventDao.insert(
-                .setTimestamp(100L)
+                BatteryEventEntity.newBuilder()
-                .setBatteryEventType(1)
+                        .setTimestamp(100L)
-                .setBatteryLevel(66)
+                        .setBatteryEventType(1)
-                .build());
+                        .setBatteryLevel(66)
-        mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
+                        .build());
-                .setTimestamp(200L)
+        mBatteryEventDao.insert(
-                .setBatteryEventType(1)
+                BatteryEventEntity.newBuilder()
-                .setBatteryLevel(88)
+                        .setTimestamp(200L)
-                .build());
+                        .setBatteryEventType(1)
+                        .setBatteryLevel(88)
+                        .build());
 
         final Cursor cursor = mBatteryEventDao.getAllAfter(200L, List.of(1));
         assertThat(cursor.getCount()).isEqualTo(1);
         cursor.moveToFirst();
-        assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP)))
+        assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP))).isEqualTo(200L);
-                .isEqualTo(200L);
+        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE))).isEqualTo(1);
-        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE)))
+        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL))).isEqualTo(88);
-                .isEqualTo(1);
-        assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL)))
-                .isEqualTo(88);
 
         mBatteryEventDao.clearAll();
         assertThat(mBatteryEventDao.getAll()).isEmpty();

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryEventEntityTest.java

@@ -32,12 +32,12 @@ public final class BatteryEventEntityTest {
         final int batteryEventType = 1;
         final int batteryLevel = 66;
 
-        BatteryEventEntity entity = BatteryEventEntity
+        BatteryEventEntity entity =
-                .newBuilder()
+                BatteryEventEntity.newBuilder()
-                .setTimestamp(timestamp)
+                        .setTimestamp(timestamp)
-                .setBatteryEventType(batteryEventType)
+                        .setBatteryEventType(batteryEventType)
-                .setBatteryLevel(batteryLevel)
+                        .setBatteryLevel(batteryLevel)
-                .build();
+                        .build();
 
         // Verifies the app relative information.
         assertThat(entity.timestamp).isEqualTo(timestamp);

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateDaoTest.java

@@ -57,14 +57,17 @@ public final class BatteryStateDaoTest {
         BatteryTestUtils.insertDataToBatteryStateTable(mContext, TIMESTAMP3, PACKAGE_NAME3);
         BatteryTestUtils.insertDataToBatteryStateTable(mContext, TIMESTAMP2, PACKAGE_NAME2);
         BatteryTestUtils.insertDataToBatteryStateTable(
-                mContext, TIMESTAMP1, PACKAGE_NAME1, /*multiple=*/ true,
+                mContext,
-                /*isFullChargeStart=*/ true);
+                TIMESTAMP1,
+                PACKAGE_NAME1,
+                /* multiple= */ true,
+                /* isFullChargeStart= */ true);
     }
 
     @After
     public void closeDb() {
         mDatabase.close();
-        BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
+        BatteryStateDatabase.setBatteryStateDatabase(/* database= */ null);
     }
 
     @Test
@@ -136,29 +139,25 @@ public final class BatteryStateDaoTest {
 
     @Test
     public void getInstance_createNewInstance_returnsExpectedResult() throws Exception {
-        BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
+        BatteryStateDatabase.setBatteryStateDatabase(/* database= */ null);
         assertThat(BatteryStateDatabase.getInstance(mContext)).isNotNull();
     }
 
     @Test
     public void getDistinctTimestampCount_normalFlow_returnsExpectedResult() {
-        assertThat(mBatteryStateDao.getDistinctTimestampCount(/*timestamp=*/ 0))
+        assertThat(mBatteryStateDao.getDistinctTimestampCount(/* timestamp= */ 0)).isEqualTo(3);
-                .isEqualTo(3);
+        assertThat(mBatteryStateDao.getDistinctTimestampCount(TIMESTAMP1)).isEqualTo(2);
-        assertThat(mBatteryStateDao.getDistinctTimestampCount(TIMESTAMP1))
-                .isEqualTo(2);
     }
 
     @Test
     public void getDistinctTimestamps_normalFlow_returnsExpectedResult() {
-        final List<Long> timestamps =
+        final List<Long> timestamps = mBatteryStateDao.getDistinctTimestamps(/* timestamp= */ 0);
-                mBatteryStateDao.getDistinctTimestamps(/*timestamp=*/ 0);
 
         assertThat(timestamps).hasSize(3);
         assertThat(timestamps).containsExactly(TIMESTAMP1, TIMESTAMP2, TIMESTAMP3);
     }
 
-    private static void assertBatteryState(
+    private static void assertBatteryState(BatteryState state, long timestamp, String packageName) {
-            BatteryState state, long timestamp, String packageName) {
         assertThat(state.timestamp).isEqualTo(timestamp);
         assertThat(state.packageName).isEqualTo(packageName);
     }

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateTest.java

@@ -41,15 +41,13 @@ public final class BatteryStateTest {
     @Before
     public void setUp() {
         final DeviceBatteryState deviceBatteryState =
-                DeviceBatteryState
+                DeviceBatteryState.newBuilder()
-                        .newBuilder()
                         .setBatteryLevel(BATTERY_LEVEL)
                         .setBatteryStatus(BATTERY_STATUS)
                         .setBatteryHealth(BATTERY_HEALTH)
                         .build();
         mBatteryInformation =
-                BatteryInformation
+                BatteryInformation.newBuilder()
-                        .newBuilder()
                         .setDeviceBatteryState(deviceBatteryState)
                         .setBootTimestamp(101L)
                         .setIsHidden(true)
@@ -78,8 +76,8 @@ public final class BatteryStateTest {
         assertThat(state.timestamp).isEqualTo(100001L);
         assertThat(state.consumerType).isEqualTo(2);
         assertThat(state.isFullChargeCycleStart).isTrue();
-        assertThat(state.batteryInformation).isEqualTo(
+        assertThat(state.batteryInformation)
-                ConvertUtils.convertBatteryInformationToString(mBatteryInformation));
+                .isEqualTo(ConvertUtils.convertBatteryInformationToString(mBatteryInformation));
     }
 
     private static BatteryState create(BatteryInformation batteryInformation) {

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryUsageSlotDaoTest.java

@@ -61,7 +61,7 @@ public final class BatteryUsageSlotDaoTest {
     @After
     public void closeDb() {
         mDatabase.close();
-        BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
+        BatteryStateDatabase.setBatteryStateDatabase(/* database= */ null);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryUsageSlotEntityTest.java

@@ -31,11 +31,11 @@ public final class BatteryUsageSlotEntityTest {
         final long timestamp = 10001L;
         final String batteryUsageSlotString = "batteryUsageSlotString";
 
-        BatteryUsageSlotEntity entity = BatteryUsageSlotEntity
+        BatteryUsageSlotEntity entity =
-                .newBuilder()
+                BatteryUsageSlotEntity.newBuilder()
-                .setTimestamp(timestamp)
+                        .setTimestamp(timestamp)
-                .setBatteryUsageSlot(batteryUsageSlotString)
+                        .setBatteryUsageSlot(batteryUsageSlotString)
-                .build();
+                        .build();
 
         // Verifies the app relative information.
         assertThat(entity.timestamp).isEqualTo(timestamp);