Home | History | Annotate | Download | only in os 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.internal.os;
     18 
     19 import android.os.BatteryStats;
     20 import android.os.Parcel;
     21 import android.support.test.filters.SmallTest;
     22 
     23 import junit.framework.Assert;
     24 import junit.framework.TestCase;
     25 
     26 /**
     27  * Provides test cases for android.os.BatteryStats.
     28  */
     29 public class BatteryStatsServTest extends TestCase {
     30     private static final String TAG = "BatteryStatsServTest";
     31 
     32     public static class TestServ extends BatteryStatsImpl.Uid.Pkg.Serv {
     33         TestServ(MockBatteryStatsImpl bsi) {
     34             super(bsi);
     35         }
     36 
     37         void populate() {
     38             mStartTime = 1010;
     39             mRunningSince = 2021;
     40             mRunning = true;
     41             mStarts = 4042;
     42             mLaunchedTime = 5053;
     43             mLaunchedSince = 6064;
     44             mLaunched = true;
     45             mLaunches = 8085;
     46             mLoadedStartTime = 9096;
     47             mLoadedStarts = 10017;
     48             mLoadedLaunches = 11118;
     49             mLastStartTime = 12219;
     50             mLastStarts = 13310;
     51             mLastLaunches = 14411;
     52             mUnpluggedStartTime = 15512;
     53             mUnpluggedStarts = 16613;
     54             mUnpluggedLaunches = 17714;
     55         }
     56 
     57         long getStartTime() {
     58             return mStartTime;
     59         }
     60 
     61         long getRunningSince() {
     62             return mRunningSince;
     63         }
     64 
     65         void setRunning(boolean val) {
     66             mRunning = val;
     67         }
     68 
     69         boolean getRunning() {
     70             return mRunning;
     71         }
     72 
     73         int getStarts() {
     74             return mStarts;
     75         }
     76 
     77         long getLaunchedTime() {
     78             return mLaunchedTime;
     79         }
     80 
     81         long getLaunchedSince() {
     82             return mLaunchedSince;
     83         }
     84 
     85         void setLaunched(boolean val) {
     86             mLaunched = val;
     87         }
     88 
     89         boolean getLaunched() {
     90             return mLaunched;
     91         }
     92 
     93         int getLaunches() {
     94             return mLaunches;
     95         }
     96 
     97         long getLoadedStartTime() {
     98             return mLoadedStartTime;
     99         }
    100 
    101         int getLoadedStarts() {
    102             return mLoadedStarts;
    103         }
    104 
    105         int getLoadedLaunches() {
    106             return mLoadedLaunches;
    107         }
    108 
    109         long getLastStartTime() {
    110             return mLastStartTime;
    111         }
    112 
    113         int getLastStarts() {
    114             return mLastStarts;
    115         }
    116 
    117         int getLastLaunches() {
    118             return mLastLaunches;
    119         }
    120 
    121         long getUnpluggedStartTime() {
    122             return mUnpluggedStartTime;
    123         }
    124 
    125         int getUnpluggedStarts() {
    126             return mUnpluggedStarts;
    127         }
    128 
    129         int getUnpluggedLaunches() {
    130             return mUnpluggedLaunches;
    131         }
    132     }
    133 
    134     /**
    135      * Test that the constructor and detach methods touch the time bast observer list.
    136      */
    137     @SmallTest
    138     public void testConstructAndDetach() throws Exception  {
    139         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    140 
    141         TestServ serv = new TestServ(bsi);
    142         Assert.assertTrue(bsi.getOnBatteryTimeBase().hasObserver(serv));
    143 
    144         serv.detach();
    145         Assert.assertFalse(bsi.getOnBatteryTimeBase().hasObserver(serv));
    146     }
    147 
    148     /**
    149      * Test OnTimeStarted
    150      */
    151     @SmallTest
    152     public void testOnTimeStarted() throws Exception  {
    153         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    154         TestServ serv = new TestServ(bsi);
    155 
    156         serv.populate();
    157         serv.setRunning(true);
    158         serv.onTimeStarted(111111, 20000, 222222);
    159         Assert.assertEquals(18989, serv.getUnpluggedStartTime());
    160         Assert.assertEquals(4042, serv.getUnpluggedStarts());
    161         Assert.assertEquals(8085, serv.getUnpluggedLaunches());
    162 
    163         serv.populate();
    164         serv.setRunning(false);
    165         serv.onTimeStarted(111111, 20000, 222222);
    166         Assert.assertEquals(1010, serv.getUnpluggedStartTime());
    167         Assert.assertEquals(4042, serv.getUnpluggedStarts());
    168         Assert.assertEquals(8085, serv.getUnpluggedLaunches());
    169     }
    170 
    171     /**
    172      * Test parceling and unparceling.
    173      */
    174     @SmallTest
    175     public void testParceling() throws Exception  {
    176         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    177         TestServ orig = new TestServ(bsi);
    178         orig.populate();
    179 
    180         Parcel parcel = Parcel.obtain();
    181         orig.writeToParcelLocked(parcel);
    182 
    183         parcel.setDataPosition(0);
    184 
    185         TestServ serv = new TestServ(bsi);
    186         serv.readFromParcelLocked(parcel);
    187 
    188         Assert.assertEquals(1010, serv.getStartTime());
    189         Assert.assertEquals(2021, serv.getRunningSince());
    190         Assert.assertTrue(serv.getRunning());
    191         Assert.assertEquals(4042, serv.getStarts());
    192         Assert.assertEquals(5053, serv.getLaunchedTime());
    193         Assert.assertEquals(6064, serv.getLaunchedSince());
    194         Assert.assertTrue(serv.getLaunched());
    195         Assert.assertEquals(8085, serv.getLaunches());
    196         Assert.assertEquals(9096, serv.getLoadedStartTime());
    197         Assert.assertEquals(10017, serv.getLoadedStarts());
    198         Assert.assertEquals(11118, serv.getLoadedLaunches());
    199         Assert.assertEquals(0, serv.getLastStartTime());
    200         Assert.assertEquals(0, serv.getLastStarts());
    201         Assert.assertEquals(0, serv.getLastLaunches());
    202         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    203         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    204         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    205     }
    206 
    207     /**
    208      * Test getLaunchTimeToNow()
    209      */
    210     @SmallTest
    211     public void testLaunchTimeToNow() throws Exception  {
    212         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    213         TestServ serv = new TestServ(bsi);
    214 
    215         serv.populate();
    216         serv.setLaunched(true);
    217         Assert.assertEquals(8989, serv.getLaunchTimeToNowLocked(10000));
    218 
    219         serv.populate();
    220         serv.setLaunched(false);
    221         Assert.assertEquals(5053, serv.getLaunchTimeToNowLocked(10000));
    222 
    223     }
    224 
    225     /**
    226      * Test getStartTimeToNow()
    227      */
    228     @SmallTest
    229     public void testStartTimeToNow() throws Exception  {
    230         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    231         TestServ serv = new TestServ(bsi);
    232 
    233         serv.populate();
    234         serv.setRunning(true);
    235         Assert.assertEquals(18989, serv.getStartTimeToNowLocked(20000));
    236 
    237         serv.populate();
    238         serv.setRunning(false);
    239         Assert.assertEquals(1010, serv.getStartTimeToNowLocked(20000));
    240     }
    241 
    242     /**
    243      * Test startLaunchedLocked while not previously launched
    244      */
    245     @SmallTest
    246     public void testStartLaunchedLockedWhileLaunched() throws Exception  {
    247         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    248             @Override
    249             public long getBatteryUptimeLocked() {
    250                 return 777777L;
    251             }
    252         };
    253 
    254         TestServ serv = new TestServ(bsi);
    255 
    256         serv.populate();
    257         serv.setLaunched(true);
    258         serv.startLaunchedLocked();
    259 
    260         // No changes
    261         Assert.assertEquals(1010, serv.getStartTime());
    262         Assert.assertEquals(2021, serv.getRunningSince());
    263         Assert.assertTrue(serv.getRunning());
    264         Assert.assertEquals(4042, serv.getStarts());
    265         Assert.assertEquals(5053, serv.getLaunchedTime());
    266         Assert.assertEquals(6064, serv.getLaunchedSince());
    267         Assert.assertTrue(serv.getLaunched());
    268         Assert.assertEquals(8085, serv.getLaunches());
    269         Assert.assertEquals(9096, serv.getLoadedStartTime());
    270         Assert.assertEquals(10017, serv.getLoadedStarts());
    271         Assert.assertEquals(11118, serv.getLoadedLaunches());
    272         Assert.assertEquals(12219, serv.getLastStartTime());
    273         Assert.assertEquals(13310, serv.getLastStarts());
    274         Assert.assertEquals(14411, serv.getLastLaunches());
    275         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    276         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    277         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    278     }
    279 
    280     /**
    281      * Test startLaunchedLocked while previously launched
    282      */
    283     @SmallTest
    284     public void testStartLaunchedLockedWhileNotLaunched() throws Exception  {
    285         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    286             @Override
    287             public long getBatteryUptimeLocked() {
    288                 return 777777L;
    289             }
    290         };
    291 
    292         TestServ serv = new TestServ(bsi);
    293 
    294         serv.populate();
    295         serv.setLaunched(false);
    296         serv.startLaunchedLocked();
    297         Assert.assertEquals(1010, serv.getStartTime());
    298         Assert.assertEquals(2021, serv.getRunningSince());
    299         Assert.assertTrue(serv.getRunning());
    300         Assert.assertEquals(4042, serv.getStarts());
    301         Assert.assertEquals(5053, serv.getLaunchedTime());
    302         Assert.assertEquals(777777L, serv.getLaunchedSince()); // <-- changed
    303         Assert.assertTrue(serv.getLaunched()); // <-- changed
    304         Assert.assertEquals(8086, serv.getLaunches()); // <-- changed
    305         Assert.assertEquals(9096, serv.getLoadedStartTime());
    306         Assert.assertEquals(10017, serv.getLoadedStarts());
    307         Assert.assertEquals(11118, serv.getLoadedLaunches());
    308         Assert.assertEquals(12219, serv.getLastStartTime());
    309         Assert.assertEquals(13310, serv.getLastStarts());
    310         Assert.assertEquals(14411, serv.getLastLaunches());
    311         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    312         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    313         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    314     }
    315 
    316     /**
    317      * Test stopLaunchedLocked when not previously launched.
    318      */
    319     @SmallTest
    320     public void testStopLaunchedLockedWhileNotLaunched() throws Exception  {
    321         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    322             @Override
    323             public long getBatteryUptimeLocked() {
    324                 return 777777L;
    325             }
    326         };
    327         TestServ serv = new TestServ(bsi);
    328 
    329         serv.populate();
    330         serv.setLaunched(false);
    331 
    332         serv.stopLaunchedLocked();
    333 
    334         // No changes
    335         Assert.assertEquals(1010, serv.getStartTime());
    336         Assert.assertEquals(2021, serv.getRunningSince());
    337         Assert.assertTrue(serv.getRunning());
    338         Assert.assertEquals(4042, serv.getStarts());
    339         Assert.assertEquals(5053, serv.getLaunchedTime());
    340         Assert.assertEquals(6064, serv.getLaunchedSince());
    341         Assert.assertFalse(serv.getLaunched());
    342         Assert.assertEquals(8085, serv.getLaunches());
    343         Assert.assertEquals(9096, serv.getLoadedStartTime());
    344         Assert.assertEquals(10017, serv.getLoadedStarts());
    345         Assert.assertEquals(11118, serv.getLoadedLaunches());
    346         Assert.assertEquals(12219, serv.getLastStartTime());
    347         Assert.assertEquals(13310, serv.getLastStarts());
    348         Assert.assertEquals(14411, serv.getLastLaunches());
    349         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    350         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    351         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    352     }
    353 
    354     /**
    355      * Test stopLaunchedLocked when previously launched, with measurable time between
    356      * start and stop.
    357      */
    358     @SmallTest
    359     public void testStopLaunchedLockedWhileLaunchedNormal() throws Exception  {
    360         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    361             @Override
    362             public long getBatteryUptimeLocked() {
    363                 return 777777L;
    364             }
    365         };
    366         TestServ serv = new TestServ(bsi);
    367 
    368         serv.populate();
    369         serv.setLaunched(true);
    370 
    371         serv.stopLaunchedLocked();
    372 
    373         Assert.assertEquals(1010, serv.getStartTime());
    374         Assert.assertEquals(2021, serv.getRunningSince());
    375         Assert.assertTrue(serv.getRunning());
    376         Assert.assertEquals(4042, serv.getStarts());
    377         Assert.assertEquals(777777L-6064+5053, serv.getLaunchedTime()); // <-- changed
    378         Assert.assertEquals(6064, serv.getLaunchedSince());
    379         Assert.assertFalse(serv.getLaunched());
    380         Assert.assertEquals(8085, serv.getLaunches());
    381         Assert.assertEquals(9096, serv.getLoadedStartTime());
    382         Assert.assertEquals(10017, serv.getLoadedStarts());
    383         Assert.assertEquals(11118, serv.getLoadedLaunches());
    384         Assert.assertEquals(12219, serv.getLastStartTime());
    385         Assert.assertEquals(13310, serv.getLastStarts());
    386         Assert.assertEquals(14411, serv.getLastLaunches());
    387         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    388         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    389         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    390     }
    391 
    392     /**
    393      * Test stopLaunchedLocked when previously launched, with no measurable time between
    394      * start and stop.
    395      */
    396     @SmallTest
    397     public void testStopLaunchedLockedWhileLaunchedTooQuick() throws Exception  {
    398         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    399             @Override
    400             public long getBatteryUptimeLocked() {
    401                 return 6064L;
    402             }
    403         };
    404         TestServ serv = new TestServ(bsi);
    405 
    406         serv.populate();
    407         serv.setLaunched(true);
    408 
    409         serv.stopLaunchedLocked();
    410 
    411         Assert.assertEquals(1010, serv.getStartTime());
    412         Assert.assertEquals(2021, serv.getRunningSince());
    413         Assert.assertTrue(serv.getRunning());
    414         Assert.assertEquals(4042, serv.getStarts());
    415         Assert.assertEquals(5053, serv.getLaunchedTime());
    416         Assert.assertEquals(6064, serv.getLaunchedSince());
    417         Assert.assertFalse(serv.getLaunched());
    418         Assert.assertEquals(8085-1, serv.getLaunches()); // <-- changed
    419         Assert.assertEquals(9096, serv.getLoadedStartTime());
    420         Assert.assertEquals(10017, serv.getLoadedStarts());
    421         Assert.assertEquals(11118, serv.getLoadedLaunches());
    422         Assert.assertEquals(12219, serv.getLastStartTime());
    423         Assert.assertEquals(13310, serv.getLastStarts());
    424         Assert.assertEquals(14411, serv.getLastLaunches());
    425         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    426         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    427         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    428     }
    429 
    430     /**
    431      * Test startRunningLocked while previously running
    432      */
    433     @SmallTest
    434     public void testStartRunningLockedWhileRunning() throws Exception  {
    435         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    436             @Override
    437             public long getBatteryUptimeLocked() {
    438                 return 777777L;
    439             }
    440         };
    441         TestServ serv = new TestServ(bsi);
    442 
    443         serv.populate();
    444         serv.setRunning(true);
    445 
    446         serv.startRunningLocked();
    447 
    448         // no change
    449         Assert.assertEquals(1010, serv.getStartTime());
    450         Assert.assertEquals(2021, serv.getRunningSince());
    451         Assert.assertTrue(serv.getRunning());
    452         Assert.assertEquals(4042, serv.getStarts());
    453         Assert.assertEquals(5053, serv.getLaunchedTime());
    454         Assert.assertEquals(6064, serv.getLaunchedSince());
    455         Assert.assertTrue(serv.getLaunched());
    456         Assert.assertEquals(8085, serv.getLaunches());
    457         Assert.assertEquals(9096, serv.getLoadedStartTime());
    458         Assert.assertEquals(10017, serv.getLoadedStarts());
    459         Assert.assertEquals(11118, serv.getLoadedLaunches());
    460         Assert.assertEquals(12219, serv.getLastStartTime());
    461         Assert.assertEquals(13310, serv.getLastStarts());
    462         Assert.assertEquals(14411, serv.getLastLaunches());
    463         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    464         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    465         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    466     }
    467 
    468     /**
    469      * Test startRunningLocked while not previously launched
    470      */
    471     @SmallTest
    472     public void testStartRunningLockedWhileNotRunning() throws Exception  {
    473         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    474             @Override
    475             public long getBatteryUptimeLocked() {
    476                 return 777777L;
    477             }
    478         };
    479         TestServ serv = new TestServ(bsi);
    480 
    481         serv.populate();
    482         serv.setRunning(false);
    483 
    484         serv.startRunningLocked();
    485 
    486         Assert.assertEquals(1010, serv.getStartTime());
    487         Assert.assertEquals(777777L, serv.getRunningSince());
    488         Assert.assertTrue(serv.getRunning());
    489         Assert.assertEquals(4042+1, serv.getStarts());
    490         Assert.assertEquals(5053, serv.getLaunchedTime());
    491         Assert.assertEquals(6064, serv.getLaunchedSince());
    492         Assert.assertTrue(serv.getLaunched());
    493         Assert.assertEquals(8085, serv.getLaunches());
    494         Assert.assertEquals(9096, serv.getLoadedStartTime());
    495         Assert.assertEquals(10017, serv.getLoadedStarts());
    496         Assert.assertEquals(11118, serv.getLoadedLaunches());
    497         Assert.assertEquals(12219, serv.getLastStartTime());
    498         Assert.assertEquals(13310, serv.getLastStarts());
    499         Assert.assertEquals(14411, serv.getLastLaunches());
    500         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    501         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    502         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    503     }
    504 
    505     /**
    506      * Test stopRunningLocked when previously launched, with measurable time between
    507      * start and stop.
    508      */
    509     @SmallTest
    510     public void testStopRunningLockedWhileRunningNormal() throws Exception  {
    511         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    512             @Override
    513             public long getBatteryUptimeLocked() {
    514                 return 777777L;
    515             }
    516         };
    517         TestServ serv = new TestServ(bsi);
    518 
    519         serv.populate();
    520         serv.setRunning(true);
    521 
    522         serv.stopRunningLocked();
    523 
    524         Assert.assertEquals(777777L-2021+1010, serv.getStartTime()); // <-- changed
    525         Assert.assertEquals(2021, serv.getRunningSince());
    526         Assert.assertFalse(serv.getRunning()); // <-- changed
    527         Assert.assertEquals(4042, serv.getStarts());
    528         Assert.assertEquals(5053, serv.getLaunchedTime());
    529         Assert.assertEquals(6064, serv.getLaunchedSince());
    530         Assert.assertTrue(serv.getLaunched());
    531         Assert.assertEquals(8085, serv.getLaunches());
    532         Assert.assertEquals(9096, serv.getLoadedStartTime());
    533         Assert.assertEquals(10017, serv.getLoadedStarts());
    534         Assert.assertEquals(11118, serv.getLoadedLaunches());
    535         Assert.assertEquals(12219, serv.getLastStartTime());
    536         Assert.assertEquals(13310, serv.getLastStarts());
    537         Assert.assertEquals(14411, serv.getLastLaunches());
    538         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    539         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    540         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    541     }
    542 
    543     /**
    544      * Test stopRunningLocked when previously launched, with measurable time between
    545      * start and stop.
    546      */
    547     @SmallTest
    548     public void testStopRunningLockedWhileRunningTooQuick() throws Exception  {
    549         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() {
    550             @Override
    551             public long getBatteryUptimeLocked() {
    552                 return 2021;
    553             }
    554         };
    555         TestServ serv = new TestServ(bsi);
    556 
    557         serv.populate();
    558         serv.setRunning(true);
    559 
    560         serv.stopRunningLocked();
    561 
    562         Assert.assertEquals(1010, serv.getStartTime());
    563         Assert.assertEquals(2021, serv.getRunningSince());
    564         Assert.assertFalse(serv.getRunning()); // <-- changed
    565         Assert.assertEquals(4042-1, serv.getStarts()); // <-- changed
    566         Assert.assertEquals(5053, serv.getLaunchedTime());
    567         Assert.assertEquals(6064, serv.getLaunchedSince());
    568         Assert.assertTrue(serv.getLaunched());
    569         Assert.assertEquals(8085, serv.getLaunches());
    570         Assert.assertEquals(9096, serv.getLoadedStartTime());
    571         Assert.assertEquals(10017, serv.getLoadedStarts());
    572         Assert.assertEquals(11118, serv.getLoadedLaunches());
    573         Assert.assertEquals(12219, serv.getLastStartTime());
    574         Assert.assertEquals(13310, serv.getLastStarts());
    575         Assert.assertEquals(14411, serv.getLastLaunches());
    576         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    577         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    578         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    579     }
    580 
    581     /**
    582      * Test that getBatteryStats returns the BatteryStatsImpl passed in to the contstructor.
    583      */
    584     @SmallTest
    585     public void testGetBatteryStats() throws Exception  {
    586         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    587         TestServ serv = new TestServ(bsi);
    588 
    589         Assert.assertEquals(bsi, serv.getBatteryStats());
    590     }
    591 
    592     /**
    593      * Test getLaunches
    594      */
    595     @SmallTest
    596     public void testGetLaunches() throws Exception  {
    597         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    598         TestServ serv = new TestServ(bsi);
    599         serv.populate();
    600 
    601         Assert.assertEquals(8085, serv.getLaunches(BatteryStats.STATS_SINCE_CHARGED));
    602         Assert.assertEquals(8085-11118, serv.getLaunches(BatteryStats.STATS_CURRENT));
    603         Assert.assertEquals(8085-17714, serv.getLaunches(BatteryStats.STATS_SINCE_UNPLUGGED));
    604 
    605         // No change to fields
    606         Assert.assertEquals(1010, serv.getStartTime());
    607         Assert.assertEquals(2021, serv.getRunningSince());
    608         Assert.assertTrue(serv.getRunning());
    609         Assert.assertEquals(4042, serv.getStarts());
    610         Assert.assertEquals(5053, serv.getLaunchedTime());
    611         Assert.assertEquals(6064, serv.getLaunchedSince());
    612         Assert.assertTrue(serv.getLaunched());
    613         Assert.assertEquals(8085, serv.getLaunches());
    614         Assert.assertEquals(9096, serv.getLoadedStartTime());
    615         Assert.assertEquals(10017, serv.getLoadedStarts());
    616         Assert.assertEquals(11118, serv.getLoadedLaunches());
    617         Assert.assertEquals(12219, serv.getLastStartTime());
    618         Assert.assertEquals(13310, serv.getLastStarts());
    619         Assert.assertEquals(14411, serv.getLastLaunches());
    620         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    621         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    622         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    623     }
    624 
    625     /**
    626      * Test getStartTime while running
    627      */
    628     @SmallTest
    629     public void testGetStartTimeRunning() throws Exception  {
    630         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    631         TestServ serv = new TestServ(bsi);
    632         serv.populate();
    633         serv.setRunning(true);
    634 
    635         final long startTimeToNow = 1010 + 20000 - 2021;
    636 
    637         Assert.assertEquals(startTimeToNow,
    638                 serv.getStartTime(20000, BatteryStats.STATS_SINCE_CHARGED));
    639         Assert.assertEquals(startTimeToNow-9096,
    640                 serv.getStartTime(20000, BatteryStats.STATS_CURRENT));
    641         Assert.assertEquals(startTimeToNow-15512,
    642                 serv.getStartTime(20000, BatteryStats.STATS_SINCE_UNPLUGGED));
    643 
    644         // No change to fields
    645         Assert.assertEquals(1010, serv.getStartTime());
    646         Assert.assertEquals(2021, serv.getRunningSince());
    647         Assert.assertTrue(serv.getRunning());
    648         Assert.assertEquals(4042, serv.getStarts());
    649         Assert.assertEquals(5053, serv.getLaunchedTime());
    650         Assert.assertEquals(6064, serv.getLaunchedSince());
    651         Assert.assertTrue(serv.getLaunched());
    652         Assert.assertEquals(8085, serv.getLaunches());
    653         Assert.assertEquals(9096, serv.getLoadedStartTime());
    654         Assert.assertEquals(10017, serv.getLoadedStarts());
    655         Assert.assertEquals(11118, serv.getLoadedLaunches());
    656         Assert.assertEquals(12219, serv.getLastStartTime());
    657         Assert.assertEquals(13310, serv.getLastStarts());
    658         Assert.assertEquals(14411, serv.getLastLaunches());
    659         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    660         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    661         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    662     }
    663 
    664     /**
    665      * Test getStartTime while not running
    666      */
    667     @SmallTest
    668     public void testGetStartTimeNotRunning() throws Exception  {
    669         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    670         TestServ serv = new TestServ(bsi);
    671         serv.populate();
    672         serv.setRunning(false);
    673 
    674         final long startTimeToNow = 1010;
    675 
    676         Assert.assertEquals(startTimeToNow,
    677                 serv.getStartTime(20000, BatteryStats.STATS_SINCE_CHARGED));
    678         Assert.assertEquals(startTimeToNow-9096,
    679                 serv.getStartTime(20000, BatteryStats.STATS_CURRENT));
    680         Assert.assertEquals(startTimeToNow-15512,
    681                 serv.getStartTime(20000, BatteryStats.STATS_SINCE_UNPLUGGED));
    682 
    683         // No change to fields
    684         Assert.assertEquals(1010, serv.getStartTime());
    685         Assert.assertEquals(2021, serv.getRunningSince());
    686         Assert.assertFalse(serv.getRunning());
    687         Assert.assertEquals(4042, serv.getStarts());
    688         Assert.assertEquals(5053, serv.getLaunchedTime());
    689         Assert.assertEquals(6064, serv.getLaunchedSince());
    690         Assert.assertTrue(serv.getLaunched());
    691         Assert.assertEquals(8085, serv.getLaunches());
    692         Assert.assertEquals(9096, serv.getLoadedStartTime());
    693         Assert.assertEquals(10017, serv.getLoadedStarts());
    694         Assert.assertEquals(11118, serv.getLoadedLaunches());
    695         Assert.assertEquals(12219, serv.getLastStartTime());
    696         Assert.assertEquals(13310, serv.getLastStarts());
    697         Assert.assertEquals(14411, serv.getLastLaunches());
    698         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    699         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    700         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    701     }
    702 
    703 
    704     /**
    705      * Test getStarts
    706      */
    707     @SmallTest
    708     public void testGetStarts() throws Exception  {
    709         MockBatteryStatsImpl bsi = new MockBatteryStatsImpl();
    710         TestServ serv = new TestServ(bsi);
    711         serv.populate();
    712 
    713         Assert.assertEquals(4042, serv.getStarts(BatteryStats.STATS_SINCE_CHARGED));
    714         Assert.assertEquals(4042-10017, serv.getStarts(BatteryStats.STATS_CURRENT));
    715         Assert.assertEquals(4042-16613, serv.getStarts(BatteryStats.STATS_SINCE_UNPLUGGED));
    716 
    717         // No change to fields
    718         Assert.assertEquals(1010, serv.getStartTime());
    719         Assert.assertEquals(2021, serv.getRunningSince());
    720         Assert.assertTrue(serv.getRunning());
    721         Assert.assertEquals(4042, serv.getStarts());
    722         Assert.assertEquals(5053, serv.getLaunchedTime());
    723         Assert.assertEquals(6064, serv.getLaunchedSince());
    724         Assert.assertTrue(serv.getLaunched());
    725         Assert.assertEquals(8085, serv.getLaunches());
    726         Assert.assertEquals(9096, serv.getLoadedStartTime());
    727         Assert.assertEquals(10017, serv.getLoadedStarts());
    728         Assert.assertEquals(11118, serv.getLoadedLaunches());
    729         Assert.assertEquals(12219, serv.getLastStartTime());
    730         Assert.assertEquals(13310, serv.getLastStarts());
    731         Assert.assertEquals(14411, serv.getLastLaunches());
    732         Assert.assertEquals(15512, serv.getUnpluggedStartTime());
    733         Assert.assertEquals(16613, serv.getUnpluggedStarts());
    734         Assert.assertEquals(17714, serv.getUnpluggedLaunches());
    735     }
    736 
    737 }
    738 
    739