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 android.os.BatteryStats;
20import android.os.Parcel;
21import android.support.test.filters.SmallTest;
22
23import junit.framework.Assert;
24import junit.framework.TestCase;
25
26/**
27 * Provides test cases for android.os.BatteryStats.
28 */
29public 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