Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Add proto dump flag to services (2/2)"

Browse Source
This commit is contained in:
TreeHugger Robot
2017-10-26 23:45:46 +00:00
committed by Android (Google) Code Review
parent 87d2ba36d1 e78b01ad2d
commit 4b34000a21
7 changed files with 262 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
core/java/android/os/IServiceManager.java
View File

@@ -45,13 +45,13 @@ public interface IServiceManager extends IInterface
* Place a new @a service called @a name into the service
* manager.
*/
void addService(String name, IBinder service, boolean allowIsolated, int dumpPriority)
throws RemoteException;
void addService(String name, IBinder service, boolean allowIsolated, int dumpFlags)
throws RemoteException;
/**
* Return a list of all currently running services.
*/
String[] listServices(int dumpPriority) throws RemoteException;
String[] listServices(int dumpFlags) throws RemoteException;
/**
* Assign a permission controller to the service manager. After set, this
@@ -72,9 +72,13 @@ public interface IServiceManager extends IInterface
/*
* Must update values in IServiceManager.h
*/
int DUMP_PRIORITY_CRITICAL = 1 << 0;
int DUMP_PRIORITY_HIGH = 1 << 1;
int DUMP_PRIORITY_NORMAL = 1 << 2;
int DUMP_PRIORITY_ALL = DUMP_PRIORITY_CRITICAL | DUMP_PRIORITY_HIGH
| DUMP_PRIORITY_NORMAL;
/* Allows services to dump sections according to priorities. */
int DUMP_FLAG_PRIORITY_CRITICAL = 1 << 0;
int DUMP_FLAG_PRIORITY_HIGH = 1 << 1;
int DUMP_FLAG_PRIORITY_NORMAL = 1 << 2;
int DUMP_FLAG_PRIORITY_ALL = DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_HIGH
| DUMP_FLAG_PRIORITY_NORMAL;
/* Allows services to dump sections in protobuf format. */
int DUMP_FLAG_PROTO = 1 << 3;
}

6
core/java/android/os/ServiceManager.java
View File

@@ -83,7 +83,7 @@ public final class ServiceManager {
* @param service the service object
*/
public static void addService(String name, IBinder service) {
addService(name, service, false, IServiceManager.DUMP_PRIORITY_NORMAL);
addService(name, service, false, IServiceManager.DUMP_FLAG_PRIORITY_NORMAL);
}
/**
@@ -96,7 +96,7 @@ public final class ServiceManager {
* to access this service
*/
public static void addService(String name, IBinder service, boolean allowIsolated) {
addService(name, service, allowIsolated, IServiceManager.DUMP_PRIORITY_NORMAL);
addService(name, service, allowIsolated, IServiceManager.DUMP_FLAG_PRIORITY_NORMAL);
}
/**
@@ -143,7 +143,7 @@ public final class ServiceManager {
*/
public static String[] listServices() {
try {
return getIServiceManager().listServices(IServiceManager.DUMP_PRIORITY_ALL);
return getIServiceManager().listServices(IServiceManager.DUMP_FLAG_PRIORITY_ALL);
} catch (RemoteException e) {
Log.e(TAG, "error in listServices", e);
return null;

66
services/core/java/com/android/server/am/ActivityManagerService.java
View File

@@ -53,9 +53,10 @@ import static android.content.res.Configuration.UI_MODE_TYPE_TELEVISION;
import static android.net.NetworkPolicyManager.isProcStateAllowedWhileIdleOrPowerSaveMode;
import static android.net.NetworkPolicyManager.isProcStateAllowedWhileOnRestrictBackground;
import static android.os.Build.VERSION_CODES.N;
import static android.os.IServiceManager.DUMP_PRIORITY_CRITICAL;
import static android.os.IServiceManager.DUMP_PRIORITY_HIGH;
import static android.os.IServiceManager.DUMP_PRIORITY_NORMAL;
import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_CRITICAL;
import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_HIGH;
import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_NORMAL;
import static android.os.IServiceManager.DUMP_FLAG_PROTO;
import static android.os.Process.BLUETOOTH_UID;
import static android.os.Process.FIRST_APPLICATION_UID;
import static android.os.Process.FIRST_ISOLATED_UID;
@@ -722,30 +723,36 @@ public class ActivityManagerService extends IActivityManager.Stub
*/
private final PriorityDump.PriorityDumper mPriorityDumper = new PriorityDump.PriorityDumper() {
@Override
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args) {
doDump(fd, pw, new String[] {"activities"});
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args,
boolean asProto) {
if (asProto) return;
doDump(fd, pw, new String[]{"activities"}, asProto);
}
@Override
public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args) {
doDump(fd, pw, new String[] {"settings"});
doDump(fd, pw, new String[] {"intents"});
doDump(fd, pw, new String[] {"broadcasts"});
doDump(fd, pw, new String[] {"providers"});
doDump(fd, pw, new String[] {"permissions"});
doDump(fd, pw, new String[] {"services"});
doDump(fd, pw, new String[] {"recents"});
doDump(fd, pw, new String[] {"lastanr"});
doDump(fd, pw, new String[] {"starter"});
if (mAssociations.size() > 0) {
doDump(fd, pw, new String[] {"associations"});
public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
if (asProto) {
doDump(fd, pw, new String[0], asProto);
} else {
doDump(fd, pw, new String[]{"settings"}, asProto);
doDump(fd, pw, new String[]{"intents"}, asProto);
doDump(fd, pw, new String[]{"broadcasts"}, asProto);
doDump(fd, pw, new String[]{"providers"}, asProto);
doDump(fd, pw, new String[]{"permissions"}, asProto);
doDump(fd, pw, new String[]{"services"}, asProto);
doDump(fd, pw, new String[]{"recents"}, asProto);
doDump(fd, pw, new String[]{"lastanr"}, asProto);
doDump(fd, pw, new String[]{"starter"}, asProto);
if (mAssociations.size() > 0) {
doDump(fd, pw, new String[]{"associations"}, asProto);
}
doDump(fd, pw, new String[]{"processes"}, asProto);
}
doDump(fd, pw, new String[] {"processes"});
}
@Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
doDump(fd, pw, args);
public void dump(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
doDump(fd, pw, args, asProto);
}
};
@@ -2493,15 +2500,15 @@ public class ActivityManagerService extends IActivityManager.Stub
public void setSystemProcess() {
try {
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_PRIORITY_CRITICAL | DUMP_PRIORITY_NORMAL);
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
DUMP_PRIORITY_HIGH | DUMP_PRIORITY_NORMAL);
DUMP_FLAG_PRIORITY_HIGH | DUMP_FLAG_PRIORITY_NORMAL);
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this),
/* allowIsolated= */ false, DUMP_PRIORITY_CRITICAL);
/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
}
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
@@ -2554,7 +2561,9 @@ public class ActivityManagerService extends IActivityManager.Stub
private final PriorityDump.PriorityDumper mPriorityDumper =
new PriorityDump.PriorityDumper() {
@Override
public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args) {
public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args,
boolean asProto) {
if (asProto) return;
mActivityManagerService.dumpApplicationMemoryUsage(fd, pw, " ", args, false, null);
}
};
@@ -2604,7 +2613,9 @@ public class ActivityManagerService extends IActivityManager.Stub
private final PriorityDump.PriorityDumper mPriorityDumper =
new PriorityDump.PriorityDumper() {
@Override
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args) {
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args,
boolean asProto) {
if (asProto) return;
if (!DumpUtils.checkDumpAndUsageStatsPermission(mActivityManagerService.mContext,
"cpuinfo", pw)) return;
synchronized (mActivityManagerService.mProcessCpuTracker) {
@@ -14847,7 +14858,7 @@ public class ActivityManagerService extends IActivityManager.Stub
/**
* Wrapper function to print out debug data filtered by specified arguments.
*/
private void doDump(FileDescriptor fd, PrintWriter pw, String[] args) {
private void doDump(FileDescriptor fd, PrintWriter pw, String[] args, boolean useProto) {
if (!DumpUtils.checkDumpAndUsageStatsPermission(mContext, TAG, pw)) return;
boolean dumpAll = false;
@@ -14856,7 +14867,6 @@ public class ActivityManagerService extends IActivityManager.Stub
boolean dumpCheckinFormat = false;
boolean dumpVisibleStacksOnly = false;
boolean dumpFocusedStackOnly = false;
boolean useProto = false;
String dumpPackage = null;
int opti = 0;
@@ -14890,8 +14900,6 @@ public class ActivityManagerService extends IActivityManager.Stub
} else if ("-h".equals(opt)) {
ActivityManagerShellCommand.dumpHelp(pw, true);
return;
} else if ("--proto".equals(opt)) {
useProto = true;
} else {
pw.println("Unknown argument: " + opt + "; use -h for help");
}

153
services/core/java/com/android/server/utils/PriorityDump.java
View File

@@ -16,12 +16,19 @@
package com.android.server.utils;
import android.annotation.IntDef;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
/**
* Helper for {@link android.os.Binder#dump(java.io.FileDescriptor, String[])} that supports the
* {@link #PRIORITY_ARG} argument.
* {@link #PRIORITY_ARG} and {@link #PROTO_ARG} arguments.
* <p>
* Typical usage:
*
@@ -31,13 +38,25 @@ public class SpringfieldNuclearPowerPlant extends Binder {
private final PriorityDump.PriorityDumper mPriorityDumper = new PriorityDump.PriorityDumper() {
@Override
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("Donuts in the box: 1");
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
if (asProto) {
ProtoOutputStream proto = new ProtoOutputStream(fd);
proto.write(SpringfieldProto.DONUTS, 1);
proto.flush();
} else {
pw.println("Donuts in the box: 1");
}
}
@Override
public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("Nuclear reactor status: DANGER - MELTDOWN IMMINENT");
if (asProto) {
ProtoOutputStream proto = new ProtoOutputStream(fd);
proto.write(SpringfieldProto.REACTOR_STATUS, DANGER_MELTDOWN_IMMINENT);
proto.flush();
} else {
pw.println("Nuclear reactor status: DANGER - MELTDOWN IMMINENT");
}
}
};
@@ -65,6 +84,9 @@ public class SpringfieldNuclearPowerPlant extends Binder {
$ adb shell dumpsys snpp --dump-priority NORMAL
Nuclear reactor status: DANGER - MELTDOWN IMMINENT
$ adb shell dumpsys snpp --dump-priority CRITICAL --proto
//binary output
* </code></pre>
*
*
@@ -85,95 +107,146 @@ public class SpringfieldNuclearPowerPlant extends Binder {
public final class PriorityDump {
public static final String PRIORITY_ARG = "--dump-priority";
public static final String PROTO_ARG = "--proto";
private PriorityDump() {
throw new UnsupportedOperationException();
}
/** Enum to switch through supported priority types */
@Retention(RetentionPolicy.SOURCE)
@IntDef({PRIORITY_TYPE_INVALID, PRIORITY_TYPE_CRITICAL, PRIORITY_TYPE_HIGH,
PRIORITY_TYPE_NORMAL})
private @interface PriorityType { }
private static final int PRIORITY_TYPE_INVALID = 0;
private static final int PRIORITY_TYPE_CRITICAL = 1;
private static final int PRIORITY_TYPE_HIGH = 2;
private static final int PRIORITY_TYPE_NORMAL = 3;
/**
* Parses {@code} and call the proper {@link PriorityDumper} method when the first argument is
* {@code --dump-priority}, stripping the priority and its type.
* Parses {@code args} matching {@code --dump-priority} and/or {@code --proto}. The matching
* arguments are stripped.
* <p>
* If priority args are passed as an argument, it will call the appropriate method and if proto
* args are passed then the {@code asProto} flag is set.
* <p>
* For example, if called as {@code --dump-priority HIGH arg1 arg2 arg3}, it will call
* <code>dumper.dumpHigh(fd, pw, {"arg1", "arg2", "arg3"}) </code>
* <code>dumper.dumpHigh(fd, pw, {"arg1", "arg2", "arg3"}, false) </code>
* <p>
* If the {@code --dump-priority} is not set, it calls
* {@link PriorityDumper#dump(FileDescriptor, PrintWriter, String[])} passing the whole
* {@link PriorityDumper#dump(FileDescriptor, PrintWriter, String[], boolean)} passing the whole
* {@code args} instead.
*/
public static void dump(PriorityDumper dumper, FileDescriptor fd, PrintWriter pw,
String[] args) {
if (args != null && args.length >= 2 && args[0].equals(PRIORITY_ARG)) {
final String priority = args[1];
switch (priority) {
case "CRITICAL": {
dumper.dumpCritical(fd, pw, getStrippedArgs(args));
return;
}
case "HIGH": {
dumper.dumpHigh(fd, pw, getStrippedArgs(args));
return;
}
case "NORMAL": {
dumper.dumpNormal(fd, pw, getStrippedArgs(args));
return;
boolean asProto = false;
@PriorityType int priority = PRIORITY_TYPE_INVALID;
if (args == null) {
dumper.dump(fd, pw, args, asProto);
return;
}
String[] strippedArgs = new String[args.length];
int strippedCount = 0;
for (int argIndex = 0; argIndex < args.length; argIndex++) {
if (args[argIndex].equals(PROTO_ARG)) {
asProto = true;
} else if (args[argIndex].equals(PRIORITY_ARG)) {
if (argIndex + 1 < args.length) {
argIndex++;
priority = getPriorityType(args[argIndex]);
}
} else {
strippedArgs[strippedCount++] = args[argIndex];
}
}
if (strippedCount < args.length) {
strippedArgs = Arrays.copyOf(strippedArgs, strippedCount);
}
switch (priority) {
case PRIORITY_TYPE_CRITICAL: {
dumper.dumpCritical(fd, pw, strippedArgs, asProto);
return;
}
case PRIORITY_TYPE_HIGH: {
dumper.dumpHigh(fd, pw, strippedArgs, asProto);
return;
}
case PRIORITY_TYPE_NORMAL: {
dumper.dumpNormal(fd, pw, strippedArgs, asProto);
return;
}
default: {
dumper.dump(fd, pw, strippedArgs, asProto);
return;
}
}
dumper.dump(fd, pw, args);
}
/**
* Gets an array without the {@code --dump-priority PRIORITY} prefix.
* Converts priority argument type to enum.
*/
private static String[] getStrippedArgs(String[] args) {
final String[] stripped = new String[args.length - 2];
System.arraycopy(args, 2, stripped, 0, stripped.length);
return stripped;
private static @PriorityType int getPriorityType(String arg) {
switch (arg) {
case "CRITICAL": {
return PRIORITY_TYPE_CRITICAL;
}
case "HIGH": {
return PRIORITY_TYPE_HIGH;
}
case "NORMAL": {
return PRIORITY_TYPE_NORMAL;
}
}
return PRIORITY_TYPE_INVALID;
}
/**
* Helper for {@link android.os.Binder#dump(java.io.FileDescriptor, String[])} that supports the
* {@link #PRIORITY_ARG} argument.
* {@link #PRIORITY_ARG} and {@link #PROTO_ARG} arguments.
*
* @hide
*/
public static interface PriorityDumper {
public interface PriorityDumper {
/**
* Dumps only the critical section.
*/
@SuppressWarnings("unused")
default void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args) {
default void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args,
boolean asProto) {
}
/**
* Dumps only the high-priority section.
*/
@SuppressWarnings("unused")
default void dumpHigh(FileDescriptor fd, PrintWriter pw, String[] args) {
default void dumpHigh(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
}
/**
* Dumps only the normal section.
*/
@SuppressWarnings("unused")
default void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args) {
default void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
}
/**
* Dumps all sections.
* <p>
* This method is called when
* {@link PriorityDump#dump(PriorityDumper, FileDescriptor, PrintWriter, String[])} is
* called without priority arguments. By default, it calls the 3 {@code dumpTYPE} methods,
* so sub-classes just need to implement the priority types they support.
* {@link PriorityDump#dump(PriorityDumper, FileDescriptor, PrintWriter, String[], boolean)}
* is called without priority arguments. By default, it calls the 3 {@code dumpTYPE}
* methods, so sub-classes just need to implement the priority types they support.
*/
@SuppressWarnings("unused")
default void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
dumpCritical(fd, pw, args);
dumpHigh(fd, pw, args);
dumpNormal(fd, pw, args);
default void dump(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
dumpCritical(fd, pw, args, asProto);
dumpHigh(fd, pw, args, asProto);
dumpNormal(fd, pw, args, asProto);
}
}
}

14
services/core/java/com/android/server/wm/WindowManagerService.java
View File

@@ -392,13 +392,14 @@ public class WindowManagerService extends IWindowManager.Stub
private final PriorityDump.PriorityDumper mPriorityDumper = new PriorityDump.PriorityDumper() {
@Override
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args) {
doDump(fd, pw, new String[] {"-a"});
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args,
boolean asProto) {
doDump(fd, pw, new String[] {"-a"}, asProto);
}
@Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
doDump(fd, pw, args);
public void dump(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
doDump(fd, pw, args, asProto);
}
};
@@ -6730,10 +6731,9 @@ public class WindowManagerService extends IWindowManager.Stub
PriorityDump.dump(mPriorityDumper, fd, pw, args);
}
private void doDump(FileDescriptor fd, PrintWriter pw, String[] args) {
private void doDump(FileDescriptor fd, PrintWriter pw, String[] args, boolean useProto) {
if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return;
boolean dumpAll = false;
boolean useProto = false;
int opti = 0;
while (opti < args.length) {
@@ -6744,8 +6744,6 @@ public class WindowManagerService extends IWindowManager.Stub
opti++;
if ("-a".equals(opt)) {
dumpAll = true;
} else if ("--proto".equals(opt)) {
useProto = true;
} else if ("-h".equals(opt)) {
pw.println("Window manager dump options:");
pw.println(" [-a] [-h] [cmd] ...");

7
services/java/com/android/server/SystemServer.java
View File

@@ -125,7 +125,10 @@ import java.util.Timer;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Future;
import static android.os.IServiceManager.DUMP_PRIORITY_CRITICAL;
import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_CRITICAL;
import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_HIGH;
import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_NORMAL;
import static android.os.IServiceManager.DUMP_FLAG_PROTO;
import static android.view.Display.DEFAULT_DISPLAY;
public final class SystemServer {
@@ -827,7 +830,7 @@ public final class SystemServer {
mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
!mFirstBoot, mOnlyCore, new PhoneWindowManager());
ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
DUMP_PRIORITY_CRITICAL);
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
traceEnd();

106
services/tests/servicestests/src/com/android/server/utils/PriorityDumpTest.java
View File

@@ -19,6 +19,7 @@ package com.android.server.utils;
import static com.android.server.utils.PriorityDump.dump;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertArrayEquals;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.verify;
@@ -59,13 +60,13 @@ public class PriorityDumpTest {
@Test
public void testNullArgs() {
dump(mDumper, mFd, mPw, null);
verify(mDumper).dump(same(mFd), same(mPw), eq(null));
verify(mDumper).dump(same(mFd), same(mPw), eq(null), /* asProto= */ eq(false));
}
@Test
public void testNoArgs() {
dump(mDumper, mFd, mPw, EMPTY_ARGS);
verify(mDumper).dump(same(mFd), same(mPw), same(EMPTY_ARGS));
verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
}
@Test
@@ -74,7 +75,7 @@ public class PriorityDumpTest {
"--dumb_priority"
};
dump(mDumper, mFd, mPw, args);
verify(mDumper).dump(same(mFd), same(mPw), same(args));
verify(mDumper).dump(same(mFd), same(mPw), eq(args), /* asProto= */ eq(false));
}
@Test
@@ -83,7 +84,7 @@ public class PriorityDumpTest {
"--dump-priority"
};
dump(mDumper, mFd, mPw, args);
verify(mDumper).dump(same(mFd), same(mPw), same(args));
verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
}
@Test
@@ -92,7 +93,7 @@ public class PriorityDumpTest {
"--dump-priority", "SUPER_HIGH"
};
dump(mDumper, mFd, mPw, args);
verify(mDumper).dump(same(mFd), same(mPw), same(args));
verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
}
@Test
@@ -101,7 +102,9 @@ public class PriorityDumpTest {
"--dump-priority", "SUPER_HIGH", "--high", "--five"
};
dump(mDumper, mFd, mPw, args);
verify(mDumper).dump(same(mFd), same(mPw), same(args));
verify(mDumper).dump(same(mFd), same(mPw), eq(new String[] {
"--high", "--five"
}), /* asProto= */ eq(false));
}
@Test
@@ -117,13 +120,13 @@ public class PriorityDumpTest {
assertSame(mFd, fakeDumper.criticalFd);
assertSame(mPw, fakeDumper.criticalPw);
assertSame(args, fakeDumper.criticalArgs);
assertArrayEquals(args, fakeDumper.criticalArgs);
assertSame(mFd, fakeDumper.highFd);
assertSame(mPw, fakeDumper.highPw);
assertSame(args, fakeDumper.highArgs);
assertArrayEquals(args, fakeDumper.highArgs);
assertSame(mFd, fakeDumper.normalFd);
assertSame(mPw, fakeDumper.normalPw);
assertSame(args, fakeDumper.normalArgs);
assertArrayEquals(args, fakeDumper.normalArgs);
}
@Test
@@ -131,7 +134,8 @@ public class PriorityDumpTest {
dump(mDumper, mFd, mPw, new String[] {
"--dump-priority", "CRITICAL"
});
verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(EMPTY_ARGS));
verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(EMPTY_ARGS),
/* asProto= */ eq(false));
}
@Test
@@ -141,7 +145,27 @@ public class PriorityDumpTest {
});
verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(new String[] {
"--high", "--five"
}));
}), /* asProto= */ eq(false));
}
@Test
public void testCriticalExtraArgsInMiddle() {
dump(mDumper, mFd, mPw, new String[] {
"--high", "--dump-priority", "CRITICAL", "--five"
});
verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(new String[] {
"--high", "--five"
}), /* asProto= */ eq(false));
}
@Test
public void testCriticalExtraArgsAtEnd() {
dump(mDumper, mFd, mPw, new String[] {
"--high", "--five", "--dump-priority", "CRITICAL"
});
verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(new String[] {
"--high", "--five"
}), /* asProto= */ eq(false));
}
@Test
@@ -149,7 +173,7 @@ public class PriorityDumpTest {
dump(mDumper, mFd, mPw, new String[] {
"--dump-priority", "HIGH"
});
verify(mDumper).dumpHigh(same(mFd), same(mPw), eq(EMPTY_ARGS));
verify(mDumper).dumpHigh(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
}
@Test
@@ -159,7 +183,7 @@ public class PriorityDumpTest {
});
verify(mDumper).dumpHigh(same(mFd), same(mPw), eq(new String[] {
"--high", "--five"
}));
}), /* asProto= */ eq(false));
}
@Test
@@ -167,17 +191,58 @@ public class PriorityDumpTest {
dump(mDumper, mFd, mPw, new String[] {
"--dump-priority", "NORMAL"
});
verify(mDumper).dumpNormal(same(mFd), same(mPw), eq(EMPTY_ARGS));
verify(mDumper).dumpNormal(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
}
@Test
public void testNormalExtraArgs() {
dump(mDumper, mFd, mPw, new String[] {
dump(mDumper, mFd, mPw, new String[]{
"--dump-priority", "NORMAL", "--high", "--five"
});
verify(mDumper).dumpNormal(same(mFd), same(mPw), eq(new String[] {
verify(mDumper).dumpNormal(same(mFd), same(mPw), eq(new String[]{
"--high", "--five"
}));
}), /* asProto= */ eq(false));
}
@Test
public void testProtoArgs() {
dump(mDumper, mFd, mPw, new String[]{"--proto"});
verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(true));
}
@Test
public void testProtoArgsWithPriorityArgs() {
dump(mDumper, mFd, mPw, new String[]{"--proto", "--dump-priority", "NORMAL", "--five"});
verify(mDumper).dumpNormal(same(mFd), same(mPw),
eq(new String[]{"--five"}), /* asProto= */ eq(true));
}
@Test
public void testProtoArgsWithPriorityArgsReverseOrder() {
dump(mDumper, mFd, mPw, new String[]{"--dump-priority", "NORMAL", "--proto", "--five"});
verify(mDumper).dumpNormal(same(mFd), same(mPw),
eq(new String[]{"--five"}), /* asProto= */ eq(true));
}
@Test
public void testProtoArgsInMiddle() {
dump(mDumper, mFd, mPw, new String[]{"--unknown", "--proto", "--five"});
verify(mDumper).dump(same(mFd), same(mPw),
eq(new String[]{"--unknown", "--five"}), /* asProto= */ eq(true));
}
@Test
public void testProtoArgsAtEnd() {
dump(mDumper, mFd, mPw, new String[]{"args", "-left", "--behind", "--proto"});
verify(mDumper).dump(same(mFd), same(mPw),
eq(new String[]{"args", "-left", "--behind"}), /* asProto= */ eq(true));
}
@Test
public void testProtoArgsWithInvalidPriorityType() {
dump(mDumper, mFd, mPw, new String[]{"--dump-priority", "HIGH?", "--proto"});
verify(mDumper).dump(same(mFd), same(mPw),
eq(EMPTY_ARGS), /* asProto= */ eq(true));
}
private final class FakeDumper implements PriorityDumper {
@@ -187,21 +252,22 @@ public class PriorityDumpTest {
PrintWriter criticalPw, highPw, normalPw;
@Override
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args) {
public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args,
boolean asProto) {
criticalFd = fd;
criticalPw = pw;
criticalArgs = args;
}
@Override
public void dumpHigh(FileDescriptor fd, PrintWriter pw, String[] args) {
public void dumpHigh(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
highFd = fd;
highPw = pw;
highArgs = args;
}
@Override
public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args) {
public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
normalFd = fd;
normalPw = pw;
normalArgs = args;