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