| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.internal.os; |
| |
| import android.os.BatteryStats; |
| import android.os.Parcel; |
| import android.support.test.filters.SmallTest; |
| import android.util.StringBuilderPrinter; |
| |
| import junit.framework.Assert; |
| import junit.framework.TestCase; |
| |
| import com.android.internal.os.BatteryStatsImpl.Clocks; |
| import com.android.internal.os.BatteryStatsImpl.TimeBase; |
| import com.android.internal.os.BatteryStatsImpl.Timer; |
| |
| /** |
| * Provides test cases for android.os.BatteryStats. |
| */ |
| public class BatteryStatsTimerTest extends TestCase { |
| private static final String TAG = "BatteryStatsTest"; |
| |
| class TestTimer extends Timer { |
| long nextComputeRunTime; |
| long lastComputeRunTimeRealtime; |
| |
| int nextComputeCurrentCount; |
| |
| TestTimer(Clocks clocks, int type, TimeBase timeBase, Parcel in) { |
| super(clocks, type, timeBase, in); |
| } |
| |
| TestTimer(Clocks clocks, int type, TimeBase timeBase) { |
| super(clocks, type, timeBase); |
| } |
| |
| protected long computeRunTimeLocked(long curBatteryRealtime) { |
| lastComputeRunTimeRealtime = curBatteryRealtime; |
| return nextComputeRunTime; |
| } |
| |
| protected int computeCurrentCountLocked() { |
| return nextComputeCurrentCount; |
| } |
| |
| public int getCount() { |
| return mCount; |
| } |
| |
| public void setCount(int val) { |
| mCount = val; |
| } |
| |
| public int getLoadedCount() { |
| return mLoadedCount; |
| } |
| |
| public void setLoadedCount(int val) { |
| mLoadedCount = val; |
| } |
| |
| public int getLastCount() { |
| return mLastCount; |
| } |
| |
| public void setLastCount(int val) { |
| mLastCount = val; |
| } |
| |
| public int getUnpluggedCount() { |
| return mUnpluggedCount; |
| } |
| |
| public void setUnpluggedCount(int val) { |
| mUnpluggedCount = val; |
| } |
| |
| public long getTotalTime() { |
| return mTotalTime; |
| } |
| |
| public void setTotalTime(long val) { |
| mTotalTime = val; |
| } |
| |
| public long getLoadedTime() { |
| return mLoadedTime; |
| } |
| |
| public void setLoadedTime(long val) { |
| mLoadedTime = val; |
| } |
| |
| public long getLastTime() { |
| return mLastTime; |
| } |
| |
| public void setLastTime(long val) { |
| mLastTime = val; |
| } |
| |
| public long getUnpluggedTime() { |
| return mUnpluggedTime; |
| } |
| |
| public void setUnpluggedTime(long val) { |
| mUnpluggedTime = val; |
| } |
| |
| public long getTimeBeforeMark() { |
| return mTimeBeforeMark; |
| } |
| |
| public void setTimeBeforeMark(long val) { |
| mTimeBeforeMark = val; |
| } |
| } |
| |
| /** |
| * Tests that the flow through TimeBase.setRunning propagates through |
| * to the timer. |
| */ |
| @SmallTest |
| public void testRunning() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer = new TestTimer(clocks, 0, timeBase); |
| timer.nextComputeCurrentCount = 3000; |
| |
| // Test that starting the timer counts the unplugged time and counters |
| timer.nextComputeRunTime = 4; |
| timer.onTimeStarted(10, 20, 50); |
| Assert.assertEquals(50, timer.lastComputeRunTimeRealtime); |
| Assert.assertEquals(4, timer.getUnpluggedTime()); |
| Assert.assertEquals(3000, timer.getUnpluggedCount()); |
| |
| // Test that stopping the timer updates mTotalTime and mCount |
| timer.nextComputeRunTime = 17; |
| timer.onTimeStopped(100, 130, 170); |
| Assert.assertEquals(17, timer.getTotalTime()); |
| Assert.assertEquals(3000, timer.getCount()); |
| } |
| |
| /** |
| * Tests that the parcel can be parceled and unparceled without losing anything. |
| */ |
| @SmallTest |
| public void testParceling() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| MockClocks clocks = new MockClocks(); |
| |
| // Test write then read |
| TestTimer timer1 = new TestTimer(clocks, 0, timeBase); |
| timer1.setCount(1); |
| timer1.setLoadedCount(3); |
| timer1.setLastCount(4); |
| timer1.setUnpluggedCount(5); |
| timer1.setTotalTime(9223372036854775807L); |
| timer1.setLoadedTime(9223372036854775806L); |
| timer1.setLastTime(9223372036854775805L); |
| timer1.setUnpluggedTime(9223372036854775804L); |
| timer1.setTimeBeforeMark(9223372036854775803L); |
| timer1.nextComputeRunTime = 201; |
| timer1.nextComputeCurrentCount = 2; |
| |
| Parcel parcel = Parcel.obtain(); |
| Timer.writeTimerToParcel(parcel, timer1, 77); |
| |
| parcel.setDataPosition(0); |
| Assert.assertTrue("parcel null object", parcel.readInt() != 0); |
| |
| TestTimer timer2 = new TestTimer(clocks, 0, timeBase, parcel); |
| Assert.assertEquals(2, timer2.getCount()); // from computeTotalCountLocked() |
| Assert.assertEquals(3, timer2.getLoadedCount()); |
| Assert.assertEquals(0, timer2.getLastCount()); // NOT saved |
| Assert.assertEquals(5, timer2.getUnpluggedCount()); |
| Assert.assertEquals(201, timer2.getTotalTime()); // from computeRunTimeLocked() |
| Assert.assertEquals(9223372036854775806L, timer2.getLoadedTime()); |
| Assert.assertEquals(0, timer2.getLastTime()); // NOT saved |
| Assert.assertEquals(9223372036854775804L, timer2.getUnpluggedTime()); |
| Assert.assertEquals(9223372036854775803L, timer2.getTimeBeforeMark()); |
| |
| parcel.recycle(); |
| } |
| |
| /** |
| * Tests that the parcel can be parceled and unparceled without losing anything. |
| */ |
| @SmallTest |
| public void testParcelingNull() throws Exception { |
| // Test writing null |
| Parcel parcel = Parcel.obtain(); |
| Timer.writeTimerToParcel(parcel, null, 88); |
| |
| parcel.setDataPosition(0); |
| Assert.assertEquals(0, parcel.readInt()); |
| |
| parcel.recycle(); |
| } |
| |
| /** |
| * Tests that reset() clears the correct times. |
| */ |
| @SmallTest |
| public void testResetNoDetach() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer = new TestTimer(clocks, 0, timeBase); |
| timer.setCount(1); |
| timer.setLoadedCount(2); |
| timer.setLastCount(3); |
| timer.setUnpluggedCount(4); |
| timer.setTotalTime(9223372036854775807L); |
| timer.setLoadedTime(9223372036854775806L); |
| timer.setLastTime(9223372036854775805L); |
| timer.setUnpluggedTime(9223372036854775804L); |
| timer.setTimeBeforeMark(9223372036854775803L); |
| |
| timer.reset(false); |
| |
| Assert.assertEquals(0, timer.getCount()); |
| Assert.assertEquals(0, timer.getLoadedCount()); |
| Assert.assertEquals(0, timer.getLastCount()); |
| Assert.assertEquals(4, timer.getUnpluggedCount()); |
| Assert.assertEquals(0, timer.getTotalTime()); |
| Assert.assertEquals(0, timer.getLoadedTime()); |
| Assert.assertEquals(0, timer.getLastTime()); |
| Assert.assertEquals(9223372036854775804L, timer.getUnpluggedTime()); |
| Assert.assertEquals(0, timer.getTimeBeforeMark()); |
| |
| // reset(false) shouldn't remove it from the list |
| Assert.assertEquals(true, timeBase.hasObserver(timer)); |
| } |
| |
| /** |
| * Tests that reset() clears the correct times. |
| */ |
| @SmallTest |
| public void testResetDetach() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer = new TestTimer(clocks, 0, timeBase); |
| timer.setCount(1); |
| timer.setLoadedCount(2); |
| timer.setLastCount(3); |
| timer.setUnpluggedCount(4); |
| timer.setTotalTime(9223372036854775807L); |
| timer.setLoadedTime(9223372036854775806L); |
| timer.setLastTime(9223372036854775805L); |
| timer.setUnpluggedTime(9223372036854775804L); |
| timer.setTimeBeforeMark(9223372036854775803L); |
| |
| timer.reset(true); |
| |
| Assert.assertEquals(0, timer.getCount()); |
| Assert.assertEquals(0, timer.getLoadedCount()); |
| Assert.assertEquals(0, timer.getLastCount()); |
| Assert.assertEquals(4, timer.getUnpluggedCount()); |
| Assert.assertEquals(0, timer.getTotalTime()); |
| Assert.assertEquals(0, timer.getLoadedTime()); |
| Assert.assertEquals(0, timer.getLastTime()); |
| Assert.assertEquals(9223372036854775804L, timer.getUnpluggedTime()); |
| Assert.assertEquals(0, timer.getTimeBeforeMark()); |
| |
| // reset(true) should remove it from the list |
| Assert.assertEquals(false, timeBase.hasObserver(timer)); |
| } |
| |
| /** |
| * Tests reading and writing the summary to a parcel |
| */ |
| @SmallTest |
| public void testSummaryParceling() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| timeBase.setRunning(true, 10, 20); |
| timeBase.setRunning(false, 45, 60); |
| Assert.assertEquals(40, timeBase.getRealtime(200)); |
| // the past uptime is 35 and the past runtime is 40 |
| |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer1 = new TestTimer(clocks, 0, timeBase); |
| timer1.setCount(1); |
| timer1.setLoadedCount(2); |
| timer1.setLastCount(3); |
| timer1.setUnpluggedCount(4); |
| timer1.setTotalTime(9223372036854775807L); |
| timer1.setLoadedTime(9223372036854775806L); |
| timer1.setLastTime(9223372036854775805L); |
| timer1.setUnpluggedTime(9223372036854775804L); |
| timer1.setTimeBeforeMark(9223372036854775803L); |
| |
| Parcel parcel = Parcel.obtain(); |
| timer1.nextComputeRunTime = 9223372036854775800L; |
| timer1.nextComputeCurrentCount = 1; |
| timer1.writeSummaryFromParcelLocked(parcel, 201); |
| Assert.assertEquals(40, timer1.lastComputeRunTimeRealtime); |
| |
| TestTimer timer2 = new TestTimer(clocks, 0, timeBase); |
| |
| // Make sure that all the values get touched |
| timer2.setCount(666); |
| timer2.setLoadedCount(666); |
| timer2.setLastCount(666); |
| timer2.setUnpluggedCount(666); |
| timer2.setTotalTime(666); |
| timer2.setLoadedTime(666); |
| timer2.setLastTime(666); |
| timer2.setUnpluggedTime(666); |
| timer2.setTimeBeforeMark(666); |
| |
| parcel.setDataPosition(0); |
| |
| parcel.setDataPosition(0); |
| timer2.readSummaryFromParcelLocked(parcel); |
| |
| Assert.assertEquals(1, timer2.getCount()); |
| Assert.assertEquals(1, timer2.getLoadedCount()); |
| Assert.assertEquals(0, timer2.getLastCount()); |
| Assert.assertEquals(1, timer2.getUnpluggedCount()); |
| Assert.assertEquals(9223372036854775800L, timer2.getTotalTime()); |
| Assert.assertEquals(9223372036854775800L, timer2.getLoadedTime()); |
| Assert.assertEquals(0, timer2.getLastTime()); |
| Assert.assertEquals(9223372036854775800L, timer2.getUnpluggedTime()); |
| Assert.assertEquals(9223372036854775800L, timer2.getTimeBeforeMark()); |
| |
| parcel.recycle(); |
| } |
| |
| /** |
| * Tests getTotalTimeLocked |
| */ |
| @SmallTest |
| public void testGetTotalTimeLocked() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| timeBase.setRunning(true, 10, 20); |
| timeBase.setRunning(false, 45, 60); |
| Assert.assertEquals(40, timeBase.getRealtime(200)); |
| |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer = new TestTimer(clocks, 0, timeBase); |
| timer.setCount(1); |
| timer.setLoadedCount(2); |
| timer.setLastCount(3); |
| timer.setUnpluggedCount(4); |
| timer.setTotalTime(100); |
| timer.setLoadedTime(200); |
| timer.setLastTime(300); |
| timer.setUnpluggedTime(400); |
| timer.setTimeBeforeMark(500); |
| |
| timer.nextComputeRunTime = 10000; |
| |
| // Timer.getTotalTimeLocked(STATS_SINCE_CHARGED) |
| timer.lastComputeRunTimeRealtime = -1; |
| Assert.assertEquals(10000, |
| timer.getTotalTimeLocked(66, BatteryStats.STATS_SINCE_CHARGED)); |
| Assert.assertEquals(40, timer.lastComputeRunTimeRealtime); |
| |
| // Timer.getTotalTimeLocked(STATS_CURRENT) |
| timer.lastComputeRunTimeRealtime = -1; |
| Assert.assertEquals(9800, timer.getTotalTimeLocked(66, BatteryStats.STATS_CURRENT)); |
| Assert.assertEquals(40, timer.lastComputeRunTimeRealtime); |
| |
| // Timer.getTotalTimeLocked(STATS_SINCE_UNPLUGGED) |
| timer.lastComputeRunTimeRealtime = -1; |
| Assert.assertEquals(9600, timer.getTotalTimeLocked(66, BatteryStats.STATS_SINCE_UNPLUGGED)); |
| Assert.assertEquals(40, timer.lastComputeRunTimeRealtime); |
| } |
| |
| /** |
| * Tests getCountLocked |
| */ |
| @SmallTest |
| public void testGetCountLocked() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| timeBase.setRunning(true, 10, 20); |
| timeBase.setRunning(false, 45, 60); |
| Assert.assertEquals(40, timeBase.getRealtime(200)); |
| |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer = new TestTimer(clocks, 0, timeBase); |
| timer.setCount(1); |
| timer.setLoadedCount(2); |
| timer.setLastCount(3); |
| timer.setUnpluggedCount(4); |
| timer.setTotalTime(100); |
| timer.setLoadedTime(200); |
| timer.setLastTime(300); |
| timer.setUnpluggedTime(400); |
| timer.setTimeBeforeMark(500); |
| |
| // Timer.getCountLocked(STATS_SINCE_CHARGED) |
| timer.nextComputeCurrentCount = 10000; |
| Assert.assertEquals(10000, timer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED)); |
| |
| // Timer.getCountLocked(STATS_CURRENT) |
| timer.nextComputeCurrentCount = 10000; |
| Assert.assertEquals(9998, timer.getCountLocked(BatteryStats.STATS_CURRENT)); |
| |
| // Timer.getCountLocked(STATS_SINCE_UNPLUGGED) |
| timer.nextComputeCurrentCount = 10000; |
| Assert.assertEquals(9996, timer.getCountLocked(BatteryStats.STATS_SINCE_UNPLUGGED)); |
| } |
| |
| /** |
| * Tests getTimeSinceMarkLocked |
| */ |
| @SmallTest |
| public void testGetTimeSinceMarked() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| timeBase.setRunning(true, 10, 20); |
| timeBase.setRunning(false, 45, 60); |
| Assert.assertEquals(40, timeBase.getRealtime(200)); |
| |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer = new TestTimer(clocks, 0, timeBase); |
| timer.setCount(1); |
| timer.setLoadedCount(2); |
| timer.setLastCount(3); |
| timer.setUnpluggedCount(4); |
| timer.setTotalTime(100); |
| timer.setLoadedTime(200); |
| timer.setLastTime(300); |
| timer.setUnpluggedTime(400); |
| timer.setTimeBeforeMark(500); |
| |
| timer.nextComputeRunTime = 10000; |
| Assert.assertEquals(9500, timer.getTimeSinceMarkLocked(666)); |
| } |
| |
| /** |
| * Tests logState |
| */ |
| @SmallTest |
| public void testLogState() throws Exception { |
| TimeBase timeBase = new TimeBase(); |
| MockClocks clocks = new MockClocks(); |
| |
| TestTimer timer = new TestTimer(clocks, 0, timeBase); |
| timer.setTotalTime(100); |
| timer.setLoadedTime(200); |
| timer.setLastTime(300); |
| timer.setUnpluggedTime(400); |
| timer.setTimeBeforeMark(500); |
| timer.setCount(1); |
| timer.setLoadedCount(2); |
| timer.setLastCount(3); |
| timer.setUnpluggedCount(4); |
| timer.setTotalTime(9223372036854775807L); |
| timer.setLoadedTime(9223372036854775806L); |
| timer.setLastTime(9223372036854775805L); |
| timer.setUnpluggedTime(9223372036854775804L); |
| timer.setTimeBeforeMark(9223372036854775803L); |
| |
| StringBuilder sb = new StringBuilder(); |
| StringBuilderPrinter pw = new StringBuilderPrinter(sb); |
| |
| timer.logState(pw, " "); |
| |
| Assert.assertEquals( |
| " mCount=1 mLoadedCount=2 mLastCount=3 mUnpluggedCount=4\n" |
| + " mTotalTime=9223372036854775807 mLoadedTime=9223372036854775806\n" |
| + " mLastTime=9223372036854775805 mUnpluggedTime=9223372036854775804\n", |
| sb.toString()); |
| } |
| } |
| |