diff options
| -rw-r--r-- | tools/powermodel/src/com/android/powermodel/RawBatteryStats.java | 887 | ||||
| -rw-r--r-- | tools/powermodel/test/com/android/powermodel/RawBatteryStatsTest.java | 96 |
2 files changed, 983 insertions, 0 deletions
diff --git a/tools/powermodel/src/com/android/powermodel/RawBatteryStats.java b/tools/powermodel/src/com/android/powermodel/RawBatteryStats.java new file mode 100644 index 000000000000..28004f50ee8d --- /dev/null +++ b/tools/powermodel/src/com/android/powermodel/RawBatteryStats.java @@ -0,0 +1,887 @@ +/* + * Copyright (C) 2018 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.powermodel; + +import java.io.InputStream; +import java.io.IOException; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.reflect.Array; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; + +public class RawBatteryStats { + /** + * The factory objects for the records. Initialized in the static block. + */ + private static HashMap<String,RecordFactory> sFactories + = new HashMap<String,RecordFactory>(); + + /** + * The Record objects that have been parsed. + */ + private ArrayList<Record> mRecords = new ArrayList<Record>(); + + /** + * The Record objects that have been parsed, indexed by type. + * + * Don't use this before {@link #indexRecords()} has been called. + */ + private ImmutableMap<String,ImmutableList<Record>> mRecordsByType; + + /** + * The warnings that have been issued during parsing. + */ + private ArrayList<Warning> mWarnings = new ArrayList<Warning>(); + + /** + * The version of the BatteryStats dumpsys that we are using. This value + * is set to -1 initially, and then when parsing the (hopefully) first + * line, 'vers', it is set to the correct version. + */ + private int mDumpsysVersion = -1; + + /** + * Enum used in the Line annotation to mark whether a field is expected to be + * system-wide or scoped to an app. + */ + public enum Scope { + SYSTEM, + UID + } + + /** + * Enum used to indicated the expected number of results. + */ + public enum Count { + SINGLE, + MULTIPLE + } + + /** + * Annotates classes that represent a line of CSV in the batterystats CSV + */ + @Retention(RetentionPolicy.RUNTIME) + @Target(ElementType.TYPE) + @interface Line { + String tag(); + Scope scope(); + Count count(); + } + + /** + * Annotates fields that should be parsed automatically from CSV + */ + @Retention(RetentionPolicy.RUNTIME) + @Target(ElementType.FIELD) + @interface Field { + /** + * The "column" of this field in the most recent version of the CSV. + * When parsing old versions, fields that were added will be automatically + * removed and the indices will be fixed up. + * + * The header fields (version, uid, category, type) will be automatically + * handled for the base Line type. The index 0 should start after those. + */ + int index(); + + /** + * First version that this field appears in. + */ + int added() default 0; + } + + /** + * Each line in the BatteryStats CSV is tagged with a category, that says + * which of the time collection modes was used for the data. + */ + public enum Category { + INFO("i"), + LAST("l"), + UNPLUGGED("u"), + CURRENT("c"); + + public final String tag; + + Category(String tag) { + this.tag = tag; + } + } + + /** + * Base class for all lines in a batterystats CSV file. + */ + public static class Record { + /** + * Whether all of the fields for the indicated version of this record + * have been filled in. + */ + public boolean complete; + + + @Field(index=-4) + public int lineVersion; + + @Field(index=-3) + public int uid; + + @Field(index=-2) + public Category category; + + @Field(index=-1) + public String lineType; + } + + @Line(tag="gmcd", scope=Scope.SYSTEM, count=Count.SINGLE) + public static class GlobalModemController extends Record { + @Field(index=0) + public long idleMs; + + @Field(index=1) + public long rxTimeMs; + + @Field(index=2) + public long powerMaMs; + + @Field(index=3) + public long[] txTimeMs; + } + + @Line(tag="uid", scope=Scope.UID, count=Count.MULTIPLE) + public static class Uid extends Record { + @Field(index=0) + public int uidKey; + + @Field(index=1) + public String pkg; + } + + @Line(tag="vers", scope=Scope.SYSTEM, count=Count.SINGLE) + public static class Version extends Record { + @Field(index=0) + public int dumpsysVersion; + + @Field(index=1) + public int parcelVersion; + + @Field(index=2) + public String startPlatformVersion; + + @Field(index=3) + public String endPlatformVersion; + } + + /** + * Codes for the warnings to classify warnings without parsing them. + */ + public enum WarningId { + /** + * A row didn't have enough fields to match any records and let us extract + * a line type. + */ + TOO_FEW_FIELDS_FOR_LINE_TYPE, + + /** + * We couldn't find a Record for the given line type. + */ + NO_MATCHING_LINE_TYPE, + + /** + * Couldn't set the value of a field. Usually this is because the + * contents of a numeric type couldn't be parsed. + */ + BAD_FIELD_TYPE, + + /** + * There were extra field values in the input text. + */ + TOO_MANY_FIELDS, + + /** + * There were fields that we were expecting (for this version + * of the dumpsys) that weren't provided in the CSV data. + */ + NOT_ENOUGH_FIELDS, + + /** + * The dumpsys version in the 'vers' CSV line couldn't be parsed. + */ + BAD_DUMPSYS_VERSION + } + + /** + * A non-fatal problem detected during parsing. + */ + public static class Warning { + private int mLineNumber; + private WarningId mId; + private ArrayList<String> mFields; + private String mMessage; + private String[] mExtras; + + public Warning(int lineNumber, WarningId id, ArrayList<String> fields, String message, + String[] extras) { + mLineNumber = lineNumber; + mId = id; + mFields = fields; + mMessage = message; + mExtras = extras; + } + + public int getLineNumber() { + return mLineNumber; + } + + public ArrayList<String> getFields() { + return mFields; + } + + public String getMessage() { + return mMessage; + } + + public String[] getExtras() { + return mExtras; + } + } + + /** + * Base class for classes to set fields on Record objects via reflection. + */ + private abstract static class FieldSetter { + private int mIndex; + private int mAdded; + protected java.lang.reflect.Field mField; + + FieldSetter(int index, int added, java.lang.reflect.Field field) { + mIndex = index; + mAdded = added; + mField = field; + } + + String getName() { + return mField.getName(); + } + + int getIndex() { + return mIndex; + } + + int getAdded() { + return mAdded; + } + + boolean isArray() { + return mField.getType().isArray(); + } + + abstract void setField(int lineNumber, Record object, String value) throws ParseException; + abstract void setArray(int lineNumber, Record object, ArrayList<String> values, + int startIndex, int endIndex) throws ParseException; + + @Override + public String toString() { + final String className = getClass().getName(); + int startIndex = Math.max(className.lastIndexOf('.'), className.lastIndexOf('$')); + if (startIndex < 0) { + startIndex = 0; + } else { + startIndex++; + } + return className.substring(startIndex) + "(index=" + mIndex + " added=" + mAdded + + " field=" + mField.getName() + + " type=" + mField.getType().getSimpleName() + + ")"; + } + } + + /** + * Sets int fields on Record objects using reflection. + */ + private static class IntFieldSetter extends FieldSetter { + IntFieldSetter(int index, int added, java.lang.reflect.Field field) { + super(index, added, field); + } + + void setField(int lineNumber, Record object, String value) throws ParseException { + try { + mField.setInt(object, Integer.parseInt(value.trim())); + } catch (NumberFormatException ex) { + throw new ParseException(lineNumber, "can't parse as integer: " + value); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + + void setArray(int lineNumber, Record object, ArrayList<String> values, + int startIndex, int endIndex) throws ParseException { + try { + final int[] array = new int[endIndex-startIndex]; + for (int i=startIndex; i<endIndex; i++) { + final String value = values.get(startIndex+i); + try { + array[i] = Integer.parseInt(value.trim()); + } catch (NumberFormatException ex) { + throw new ParseException(lineNumber, "can't parse field " + + i + " as integer: " + value); + } + } + mField.set(object, array); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + } + + /** + * Sets long fields on Record objects using reflection. + */ + private static class LongFieldSetter extends FieldSetter { + LongFieldSetter(int index, int added, java.lang.reflect.Field field) { + super(index, added, field); + } + + void setField(int lineNumber, Record object, String value) throws ParseException { + try { + mField.setLong(object, Long.parseLong(value.trim())); + } catch (NumberFormatException ex) { + throw new ParseException(lineNumber, "can't parse as long: " + value); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + + void setArray(int lineNumber, Record object, ArrayList<String> values, + int startIndex, int endIndex) throws ParseException { + try { + final long[] array = new long[endIndex-startIndex]; + for (int i=0; i<(endIndex-startIndex); i++) { + final String value = values.get(startIndex+i); + try { + array[i] = Long.parseLong(value.trim()); + } catch (NumberFormatException ex) { + throw new ParseException(lineNumber, "can't parse field " + + i + " as long: " + value); + } + } + mField.set(object, array); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + } + + /** + * Sets String fields on Record objects using reflection. + */ + private static class StringFieldSetter extends FieldSetter { + StringFieldSetter(int index, int added, java.lang.reflect.Field field) { + super(index, added, field); + } + + void setField(int lineNumber, Record object, String value) throws ParseException { + try { + mField.set(object, value); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + + void setArray(int lineNumber, Record object, ArrayList<String> values, + int startIndex, int endIndex) throws ParseException { + try { + final String[] array = new String[endIndex-startIndex]; + for (int i=0; i<(endIndex-startIndex); i++) { + array[i] = values.get(startIndex+1); + } + mField.set(object, array); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + } + + /** + * Sets enum fields on Record objects using reflection. + * + * To be parsed automatically, enums must have a public final String tag + * field, which is the string that will appear in the csv for that enum value. + */ + private static class EnumFieldSetter extends FieldSetter { + private final HashMap<String,Enum> mTags = new HashMap<String,Enum>(); + + EnumFieldSetter(int index, int added, java.lang.reflect.Field field) { + super(index, added, field); + + // Build the mapping of tags to values. + final Class<?> fieldType = field.getType(); + + java.lang.reflect.Field tagField = null; + try { + tagField = fieldType.getField("tag"); + } catch (NoSuchFieldException ex) { + throw new RuntimeException("Missing tag field." + + " To be parsed automatically, enums must have" + + " a String field called tag. Enum class: " + fieldType.getName() + + " Containing class: " + field.getDeclaringClass().getName() + + " Field: " + field.getName()); + + } + if (!String.class.equals(tagField.getType())) { + throw new RuntimeException("Tag field is not string." + + " To be parsed automatically, enums must have" + + " a String field called tag. Enum class: " + fieldType.getName() + + " Containing class: " + field.getDeclaringClass().getName() + + " Field: " + field.getName() + + " Tag field type: " + tagField.getType().getName()); + } + + for (final Object enumValue: fieldType.getEnumConstants()) { + String tag = null; + try { + tag = (String)tagField.get(enumValue); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + mTags.put(tag, (Enum)enumValue); + } + } + + void setField(int lineNumber, Record object, String value) throws ParseException { + final Enum enumValue = mTags.get(value); + if (enumValue == null) { + throw new ParseException(lineNumber, "Could not find enum for field " + + getName() + " for tag: " + value); + } + try { + mField.set(object, enumValue); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + + void setArray(int lineNumber, Record object, ArrayList<String> values, + int startIndex, int endIndex) throws ParseException { + try { + final Object array = Array.newInstance(mField.getType().getComponentType(), + endIndex-startIndex); + for (int i=0; i<(endIndex-startIndex); i++) { + final String value = values.get(startIndex+i); + final Enum enumValue = mTags.get(value); + if (enumValue == null) { + throw new ParseException(lineNumber, "Could not find enum for field " + + getName() + " for tag: " + value); + } + Array.set(array, i, enumValue); + } + mField.set(object, array); + } catch (IllegalAccessException | IllegalArgumentException + | ExceptionInInitializerError ex) { + throw new RuntimeException(ex); + } + } + } + + /** + * Factory for the record classes. Uses reflection to create + * the fields. + */ + private static class RecordFactory { + private String mTag; + private Class<? extends Record> mSubclass; + private ArrayList<FieldSetter> mFieldSetters; + + RecordFactory(String tag, Class<? extends Record> subclass, + ArrayList<FieldSetter> fieldSetters) { + mTag = tag; + mSubclass = subclass; + mFieldSetters = fieldSetters; + } + + /** + * Create an object of one of the subclasses of Record, and fill + * in the fields marked with the Field annotation. + * + * @return a new Record with the fields filled in. If there are missing + * fields, the {@link Record.complete} field will be set to false. + */ + Record create(RawBatteryStats bs, int dumpsysVersion, int lineNumber, + ArrayList<String> fieldValues) { + final boolean debug = false; + Record record = null; + try { + if (debug) { + System.err.println("Creating object: " + mSubclass.getSimpleName()); + } + record = mSubclass.newInstance(); + } catch (IllegalAccessException | InstantiationException + | ExceptionInInitializerError | SecurityException ex) { + throw new RuntimeException("Exception creating " + mSubclass.getName() + + " for '" + mTag + "' record.", ex); + } + record.complete = true; + int fieldIndex = 0; + int setterIndex = 0; + while (fieldIndex < fieldValues.size() && setterIndex < mFieldSetters.size()) { + final FieldSetter setter = mFieldSetters.get(setterIndex); + + if (dumpsysVersion >= 0 && dumpsysVersion < setter.getAdded()) { + // The version being parsed doesn't have the field for this setter, + // so skip the setter but not the field. + setterIndex++; + continue; + } + + final String value = fieldValues.get(fieldIndex); + try { + if (debug) { + System.err.println(" setting field " + setter + " to: " + value); + } + if (setter.isArray()) { + setter.setArray(lineNumber, record, fieldValues, + fieldIndex, fieldValues.size()); + // The rest of the fields have been consumed. + fieldIndex = fieldValues.size(); + setterIndex = mFieldSetters.size(); + break; + } else { + setter.setField(lineNumber, record, value); + } + } catch (ParseException ex) { + bs.addWarning(lineNumber, WarningId.BAD_FIELD_TYPE, fieldValues, + ex.getMessage(), mTag, value); + record.complete = false; + } + + fieldIndex++; + setterIndex++; + } + + // If there are extra fields, this record is complete, there are just + // extra values, so we issue a warning but don't mark it incomplete. + if (fieldIndex < fieldValues.size()) { + bs.addWarning(lineNumber, WarningId.TOO_MANY_FIELDS, fieldValues, + "Line '" + mTag + "' has extra fields.", + mTag, Integer.toString(fieldIndex), Integer.toString(fieldValues.size())); + if (debug) { + for (int i=0; i<mFieldSetters.size(); i++) { + System.err.println(" setter: [" + i + "] " + mFieldSetters.get(i)); + } + } + } + + // If we have any fields that are missing, add a warning and return null. + for (; setterIndex < mFieldSetters.size(); setterIndex++) { + final FieldSetter setter = mFieldSetters.get(setterIndex); + if (dumpsysVersion >= 0 && dumpsysVersion >= setter.getAdded()) { + bs.addWarning(lineNumber, WarningId.NOT_ENOUGH_FIELDS, fieldValues, + "Line '" + mTag + "' missing field: index=" + setterIndex + + " name=" + setter.getName(), + mTag, Integer.toString(setterIndex)); + record.complete = false; + } + } + + return record; + } + } + + /** + * Parse the input stream and return a RawBatteryStats object. + */ + public static RawBatteryStats parse(InputStream input) throws ParseException, IOException { + final RawBatteryStats result = new RawBatteryStats(); + result.parseImpl(input); + return result; + } + + /** + * Get a record. + * <p> + * If multiple of that record are found, returns the first one. There will already + * have been a warning recorded if the count annotation did not match what was in the + * csv. + * <p> + * Returns null if there are no records of that type. + */ + public <T extends Record> T getSingle(Class<T> cl) { + final List<Record> list = mRecordsByType.get(cl.getName()); + if (list == null) { + return null; + } + // Notes: + // - List can never be empty because the list itself wouldn't have been added. + // - Cast is safe because list was populated based on class name (let's assume + // there's only one class loader involved here). + return (T)list.get(0); + } + + /** + * Get a record. + * <p> + * If multiple of that record are found, returns the first one that matches that uid. + * <p> + * Returns null if there are no records of that type that match the given uid. + */ + public <T extends Record> T getSingle(Class<T> cl, int uid) { + final List<Record> list = mRecordsByType.get(cl.getName()); + if (list == null) { + return null; + } + for (final Record record: list) { + if (record.uid == uid) { + // Cast is safe because list was populated based on class name (let's assume + // there's only one class loader involved here). + return (T)record; + } + } + return null; + } + + /** + * Get all the records of the given type. + */ + public <T extends Record> List<T> getMultiple(Class<T> cl) { + final List<Record> list = mRecordsByType.get(cl.getName()); + if (list == null) { + return ImmutableList.<T>of(); + } + // Cast is safe because list was populated based on class name (let's assume + // there's only one class loader involved here). + return ImmutableList.copyOf((List<T>)list); + } + + /** + * No public constructor. Use {@link #parse}. + */ + private RawBatteryStats() { + } + + /** + * Get the list of Record objects that were parsed from the csv. + */ + public List<Record> getRecords() { + return mRecords; + } + + /** + * Gets the warnings that were encountered during parsing. + */ + public List<Warning> getWarnings() { + return mWarnings; + } + + /** + * Implementation of the csv parsing. + */ + private void parseImpl(InputStream input) throws ParseException, IOException { + // Parse the csv + CsvParser.parse(input, new CsvParser.LineProcessor() { + @Override + public void onLine(int lineNumber, ArrayList<String> fields) + throws ParseException { + handleCsvLine(lineNumber, fields); + } + }); + + // Gather the records by class name for the getSingle() and getMultiple() functions. + indexRecords(); + } + + /** + * Handle a line of CSV input, creating the right Record object. + */ + private void handleCsvLine(int lineNumber, ArrayList<String> fields) throws ParseException { + // The standard rows all have the 4 core fields. Anything less isn't what we're + // looking for. + if (fields.size() <= 4) { + addWarning(lineNumber, WarningId.TOO_FEW_FIELDS_FOR_LINE_TYPE, fields, + "Line with too few fields (" + fields.size() + ")", + Integer.toString(fields.size())); + return; + } + + final String lineType = fields.get(3); + + // Handle the vers line specially, because we need the version number + // to make the rest of the machinery work. + if ("vers".equals(lineType)) { + final String versionText = fields.get(4); + try { + mDumpsysVersion = Integer.parseInt(versionText); + } catch (NumberFormatException ex) { + addWarning(lineNumber, WarningId.BAD_DUMPSYS_VERSION, fields, + "Couldn't parse dumpsys version number: '" + versionText, + versionText); + } + } + + // Find the right factory. + final RecordFactory factory = sFactories.get(lineType); + if (factory == null) { + addWarning(lineNumber, WarningId.NO_MATCHING_LINE_TYPE, fields, + "No Record for line type '" + lineType + "'", + lineType); + return; + } + + // Create the record. + final Record record = factory.create(this, mDumpsysVersion, lineNumber, fields); + mRecords.add(record); + } + + /** + * Add to the list of warnings. + */ + private void addWarning(int lineNumber, WarningId id, + ArrayList<String> fields, String message, String... extras) { + mWarnings.add(new Warning(lineNumber, id, fields, message, extras)); + final boolean debug = false; + if (debug) { + final StringBuilder text = new StringBuilder("line "); + text.append(lineNumber); + text.append(": WARNING: "); + text.append(message); + text.append("\n fields: "); + for (int i=0; i<fields.size(); i++) { + final String field = fields.get(i); + if (field.indexOf('"') >= 0) { + text.append('"'); + text.append(field.replace("\"", "\"\"")); + text.append('"'); + } else { + text.append(field); + } + if (i != fields.size() - 1) { + text.append(','); + } + } + text.append('\n'); + for (String extra: extras) { + text.append(" extra: "); + text.append(extra); + text.append('\n'); + } + System.err.print(text.toString()); + } + } + + /** + * Group records by class name. + */ + private void indexRecords() { + final HashMap<String,ArrayList<Record>> map = new HashMap<String,ArrayList<Record>>(); + + // Iterate over all of the records + for (Record record: mRecords) { + final String className = record.getClass().getName(); + + ArrayList<Record> list = map.get(className); + if (list == null) { + list = new ArrayList<Record>(); + map.put(className, list); + } + + list.add(record); + } + + // Make it immutable + final HashMap<String,ImmutableList<Record>> result + = new HashMap<String,ImmutableList<Record>>(); + for (HashMap.Entry<String,ArrayList<Record>> entry: map.entrySet()) { + result.put(entry.getKey(), ImmutableList.copyOf(entry.getValue())); + } + + // Initialize here so uninitialized access will result in NPE. + mRecordsByType = ImmutableMap.copyOf(result); + } + + /** + * Init the factory classes. + */ + static { + for (Class<?> cl: RawBatteryStats.class.getClasses()) { + final Line lineAnnotation = cl.getAnnotation(Line.class); + if (lineAnnotation != null && Record.class.isAssignableFrom(cl)) { + final ArrayList<FieldSetter> fieldSetters = new ArrayList<FieldSetter>(); + + for (java.lang.reflect.Field field: cl.getFields()) { + final Field fa = field.getAnnotation(Field.class); + if (fa != null) { + final Class<?> fieldType = field.getType(); + final Class<?> innerType = fieldType.isArray() + ? fieldType.getComponentType() + : fieldType; + if (Integer.TYPE.equals(innerType)) { + fieldSetters.add(new IntFieldSetter(fa.index(), fa.added(), field)); + } else if (Long.TYPE.equals(innerType)) { + fieldSetters.add(new LongFieldSetter(fa.index(), fa.added(), field)); + } else if (String.class.equals(innerType)) { + fieldSetters.add(new StringFieldSetter(fa.index(), fa.added(), field)); + } else if (innerType.isEnum()) { + fieldSetters.add(new EnumFieldSetter(fa.index(), fa.added(), field)); + } else { + throw new RuntimeException("Unsupported field type '" + + fieldType.getName() + "' on " + + cl.getName() + "." + field.getName()); + } + } + } + // Sort by index + Collections.sort(fieldSetters, new Comparator<FieldSetter>() { + @Override + public int compare(FieldSetter a, FieldSetter b) { + return a.getIndex() - b.getIndex(); + } + }); + // Only the last one can be an array + for (int i=0; i<fieldSetters.size()-1; i++) { + if (fieldSetters.get(i).isArray()) { + throw new RuntimeException("Only the last (highest index) @Field" + + " in class " + cl.getName() + " can be an array: " + + fieldSetters.get(i).getName()); + } + } + // Add to the map + sFactories.put(lineAnnotation.tag(), new RecordFactory(lineAnnotation.tag(), + (Class<Record>)cl, fieldSetters)); + } + } + } +} + diff --git a/tools/powermodel/test/com/android/powermodel/RawBatteryStatsTest.java b/tools/powermodel/test/com/android/powermodel/RawBatteryStatsTest.java new file mode 100644 index 000000000000..fbcac41a9e1c --- /dev/null +++ b/tools/powermodel/test/com/android/powermodel/RawBatteryStatsTest.java @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2018 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.powermodel; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.util.List; +import org.junit.Test; +import org.junit.Assert; + +/** + * Tests {@link RawBatteryStats}. + */ +public class RawBatteryStatsTest { + private static final int BS_VERSION = 32; + + private static InputStream makeCsv(String... lines) { + return makeCsv(BS_VERSION, lines); + } + + private static InputStream makeCsv(int version, String... lines) { + final StringBuilder result = new StringBuilder("9,0,i,vers,"); + result.append(version); + result.append(",177,PPR1.180326.002,PQ1A.181105.015\n"); + for (String line: lines) { + result.append(line); + result.append('\n'); + } + return new ByteArrayInputStream(result.toString().getBytes(StandardCharsets.UTF_8)); + } + + @Test public void testVersion() throws Exception { + final InputStream is = makeCsv(); + + final RawBatteryStats bs = RawBatteryStats.parse(is); + final List<RawBatteryStats.Record> records = bs.getRecords(); + final RawBatteryStats.Version line = (RawBatteryStats.Version)records.get(0); + + Assert.assertEquals(0, bs.getWarnings().size()); + Assert.assertEquals(true, line.complete); + + Assert.assertEquals(9, line.lineVersion); + Assert.assertEquals(0, line.uid); + Assert.assertEquals(RawBatteryStats.Category.INFO, line.category); + Assert.assertEquals("vers", line.lineType); + + Assert.assertEquals(BS_VERSION, line.dumpsysVersion); + Assert.assertEquals(177, line.parcelVersion); + Assert.assertEquals("PPR1.180326.002", line.startPlatformVersion); + Assert.assertEquals("PQ1A.181105.015", line.endPlatformVersion); + } + + @Test public void testUid() throws Exception { + final InputStream is = makeCsv("9,0,i,uid,1000,com.example.app"); + + final RawBatteryStats bs = RawBatteryStats.parse(is); + final List<RawBatteryStats.Record> records = bs.getRecords(); + final RawBatteryStats.Uid line = (RawBatteryStats.Uid)records.get(1); + + Assert.assertEquals(1000, line.uidKey); + Assert.assertEquals("com.example.app", line.pkg); + } + + @Test public void testVarargs() throws Exception { + final InputStream is = makeCsv("9,0,i,gmcd,1,2,3,4,5,6,7"); + + final RawBatteryStats bs = RawBatteryStats.parse(is); + final List<RawBatteryStats.Record> records = bs.getRecords(); + final RawBatteryStats.GlobalModemController line + = (RawBatteryStats.GlobalModemController)records.get(1); + + Assert.assertEquals(1, line.idleMs); + Assert.assertEquals(2, line.rxTimeMs); + Assert.assertEquals(3, line.powerMaMs); + Assert.assertEquals(4, line.txTimeMs.length); + Assert.assertEquals(4, line.txTimeMs[0]); + Assert.assertEquals(5, line.txTimeMs[1]); + Assert.assertEquals(6, line.txTimeMs[2]); + Assert.assertEquals(7, line.txTimeMs[3]); + } +} |