[RESTRICT AUTOMERGE]: Give tests more control of crash parser behavior

Added a config object instead of a multitude of arguments.
The config object has options for:
	- crash signal (SIGSEGV, SIGABRT, SIGBUS, etc.)
	- whether or not to check the crash address
	- changing the min crash address threshold
	- what process patterns to match against

Bug: 142482078
Test: cts-tradefed run compatibility-common-util-tests
Test: cts-tradefed run cts -m CtsSecurityTestCases -t android.security.cts.StagefrightTest
Change-Id: Ic8cbecacb71e09bc8e589cdf5d51f3c1c3e12442
Merged-In: Ic8cbecacb71e09bc8e589cdf5d51f3c1c3e12442
diff --git a/common/util/src/com/android/compatibility/common/util/CrashUtils.java b/common/util/src/com/android/compatibility/common/util/CrashUtils.java
index 93d2d2d..60678e87 100644
--- a/common/util/src/com/android/compatibility/common/util/CrashUtils.java
+++ b/common/util/src/com/android/compatibility/common/util/CrashUtils.java
@@ -17,6 +17,10 @@
 package com.android.compatibility.common.util;
 
 import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.ArrayList;
@@ -59,12 +63,9 @@
     private static Pattern sAbortMessageCheckPattern =
             Pattern.compile("(?i)Abort message.*?CHECK_");
 
-    /**
-     * returns true if the signal is a segmentation fault or bus error.
-     */
-    public static boolean isSecuritySignal(Crash c) {
-        return c.signal.toLowerCase().matches("sig(segv|bus)");
-    }
+    public static final String SIGSEGV = "SIGSEGV";
+    public static final String SIGBUS = "SIGBUS";
+    public static final String SIGABRT = "SIGABRT";
 
     /**
      * returns the filename of the process.
@@ -78,31 +79,27 @@
      * Determines if the given input has a {@link com.android.compatibility.common.util.Crash} that
      * should fail an sts test
      *
-     * @param processPatterns list of patterns that match applicable process names
-     * @param checkMinAddr if the minimum fault address should be respected
      * @param crashes list of crashes to check
+     * @param config crash detection configuration object
      * @return if a crash is serious enough to fail an sts test
      */
-    public static boolean securityCrashDetected(
-            List<Crash> crashes, boolean checkMinAddr, Pattern... processPatterns) {
-        return !matchSecurityCrashes(crashes, checkMinAddr, processPatterns).isEmpty();
+    public static boolean securityCrashDetected(List<Crash> crashes, Config config) {
+        return matchSecurityCrashes(crashes, config).size() > 0;
     }
 
     /**
      * Determines which given inputs have a {@link com.android.compatibility.common.util.Crash} that
      * should fail an sts test
      *
-     * @param processPatterns list of patterns that match applicable process names
-     * @param checkMinAddr if the minimum fault address should be respected
      * @param crashes list of crashes to check
+     * @param config crash detection configuration object
      * @return the list of crashes serious enough to fail an sts test
      */
-    public static List<Crash> matchSecurityCrashes(
-            List<Crash> crashes, boolean checkMinAddr, Pattern... processPatterns) {
+    public static List<Crash> matchSecurityCrashes(List<Crash> crashes, Config config) {
         return crashes.stream()
-            .filter(c -> matchesAny(getProcessFileName(c), processPatterns))
-            .filter(c -> isSecuritySignal(c))
-            .filter(c -> !checkMinAddr
+            .filter(c -> matchesAny(getProcessFileName(c), config.getProcessPatterns()))
+            .filter(c -> config.signals.contains(c.signal))
+            .filter(c -> !config.checkMinAddress
                     || c.faultAddress == null || c.faultAddress.compareTo(MIN_CRASH_ADDR) >= 0)
             .collect(Collectors.toList());
     }
@@ -110,7 +107,7 @@
     /**
      * returns true if the input matches any of the patterns.
      */
-    private static boolean matchesAny(String input, Pattern... patterns) {
+    private static boolean matchesAny(String input, Collection<Pattern> patterns) {
         for (Pattern p : patterns) {
             if (p.matcher(input).matches()) {
                 return true;
@@ -166,4 +163,53 @@
 
         return crashes;
     }
+
+    public static class Config {
+        private boolean checkMinAddress = true;
+        private BigInteger minCrashAddress = MIN_CRASH_ADDR;
+        private List<String> signals = Arrays.asList(SIGSEGV, SIGBUS);
+        private List<Pattern> processPatterns = Collections.emptyList();
+
+        public Config setMinAddress(BigInteger minCrashAddress) {
+            this.minCrashAddress = minCrashAddress;
+            return this;
+        }
+
+        public Config checkMinAddress(boolean checkMinAddress) {
+            this.checkMinAddress = checkMinAddress;
+            return this;
+        }
+
+        public Config setSignals(String... signals) {
+            this.signals = Arrays.asList(signals);
+            return this;
+        }
+
+        public Config appendSignals(String... signals) {
+            Collections.addAll(this.signals, signals);
+            return this;
+        }
+
+        public Config setProcessPatterns(String... processPatternStrings) {
+            Pattern[] processPatterns = new Pattern[processPatternStrings.length];
+            for (int i = 0; i < processPatternStrings.length; i++) {
+                processPatterns[i] = Pattern.compile(processPatternStrings[i]);
+            }
+            return setProcessPatterns(processPatterns);
+        }
+
+        public Config setProcessPatterns(Pattern... processPatterns) {
+            this.processPatterns = Arrays.asList(processPatterns);
+            return this;
+        }
+
+        public List<Pattern> getProcessPatterns() {
+            return Collections.unmodifiableList(processPatterns);
+        }
+
+        public Config appendProcessPatterns(Pattern... processPatterns) {
+            Collections.addAll(this.processPatterns, processPatterns);
+            return this;
+        }
+    }
 }
diff --git a/common/util/tests/src/com/android/compatibility/common/util/CrashUtilsTest.java b/common/util/tests/src/com/android/compatibility/common/util/CrashUtilsTest.java
index 6a2ab6e..0f6ca1e 100644
--- a/common/util/tests/src/com/android/compatibility/common/util/CrashUtilsTest.java
+++ b/common/util/tests/src/com/android/compatibility/common/util/CrashUtilsTest.java
@@ -86,43 +86,52 @@
 
     @Test
     public void testValidCrash() throws Exception {
-        assertTrue(CrashUtils.securityCrashDetected(mCrashes, true,
-                Pattern.compile("synthetic_process_0")));
+        assertTrue(CrashUtils.securityCrashDetected(mCrashes, new CrashUtils.Config()
+                .checkMinAddress(true)
+                .setProcessPatterns(Pattern.compile("synthetic_process_0"))));
     }
 
     @Test
     public void testMissingName() throws Exception {
-        assertFalse(CrashUtils.securityCrashDetected(mCrashes, true,
-                Pattern.compile("")));
+        assertFalse(CrashUtils.securityCrashDetected(mCrashes, new CrashUtils.Config()
+                .checkMinAddress(true)
+                .setProcessPatterns(Pattern.compile(""))));
     }
 
     @Test
     public void testSIGABRT() throws Exception {
-        assertFalse(CrashUtils.securityCrashDetected(mCrashes, true,
-                Pattern.compile("installd")));
+        assertFalse(CrashUtils.securityCrashDetected(mCrashes, new CrashUtils.Config()
+                .checkMinAddress(true)
+                .setProcessPatterns(Pattern.compile("installd"))));
     }
 
     @Test
     public void testFaultAddressBelowMin() throws Exception {
-        assertFalse(CrashUtils.securityCrashDetected(mCrashes, true,
-                Pattern.compile("synthetic_process_1")));
+        assertFalse(CrashUtils.securityCrashDetected(mCrashes, new CrashUtils.Config()
+                .checkMinAddress(true)
+                .setProcessPatterns(Pattern.compile("synthetic_process_1"))));
     }
 
     @Test
     public void testIgnoreMinAddressCheck() throws Exception {
-        assertTrue(CrashUtils.securityCrashDetected(mCrashes, false,
-                Pattern.compile("synthetic_process_1")));
+        assertTrue(CrashUtils.securityCrashDetected(mCrashes, new CrashUtils.Config()
+                .checkMinAddress(false)
+                .setProcessPatterns(Pattern.compile("synthetic_process_1"))));
     }
 
     @Test
     public void testBadAbortMessage() throws Exception {
-        assertFalse(CrashUtils.securityCrashDetected(mCrashes, true,
-                Pattern.compile("generic")));
+        assertFalse(CrashUtils.securityCrashDetected(mCrashes, new CrashUtils.Config()
+                .checkMinAddress(true)
+                .setProcessPatterns(Pattern.compile("generic"))));
     }
 
     @Test
     public void testGoodAndBadCrashes() throws Exception {
-        assertTrue(CrashUtils.securityCrashDetected(mCrashes, true,
-                Pattern.compile("synthetic_process_0"), Pattern.compile("generic")));
+        assertTrue(CrashUtils.securityCrashDetected(mCrashes, new CrashUtils.Config()
+                .checkMinAddress(true)
+                .setProcessPatterns(
+                        Pattern.compile("synthetic_process_0"),
+                        Pattern.compile("generic"))));
     }
 }