Multiple improvements

- Sysprops allowlist now fully moved to the text file.
- Always enable the test timeout w/ improved stack traces
- Add a method to "run on main thread"
- Always enable the uncaught exception handler.
- Tolerate assertion failures on the main looper. (rather than letting
it crash the thread)

- Also some other minor changes needed in my main work.

Flag: EXEMPT host test change only
Bug: 292141694
Test: $ANDROID_BUILD_TOP/frameworks/base/ravenwood/scripts/run-ravenwood-tests.sh
Change-Id: I47b060021ce46b6e9fbe4aca63835745311a4b06

1 files changed, 68 insertions, 0 deletions

diff --git a/ravenwood/runtime-common-src/com/android/ravenwood/common/RavenwoodCommonUtils.java b/ravenwood/runtime-common-src/com/android/ravenwood/common/RavenwoodCommonUtils.java
index a967a3fff0d7..893b354d4645 100644
--- a/ravenwood/runtime-common-src/com/android/ravenwood/common/RavenwoodCommonUtils.java
+++ b/ravenwood/runtime-common-src/com/android/ravenwood/common/RavenwoodCommonUtils.java
@@ -26,10 +26,12 @@ import java.io.FileInputStream;
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
+import java.util.Objects;
 import java.util.function.Supplier;
 
 public class RavenwoodCommonUtils {
@@ -329,4 +331,70 @@ public class RavenwoodCommonUtils {
     public static <T> T withDefault(@Nullable T value, @Nullable T def) {
         return value != null ? value : def;
     }
+
+    /**
+     * Utility for calling a method with reflections. Used to call a method by name.
+     * Note, this intentionally does _not_ support non-public methods, as we generally
+     * shouldn't violate java visibility in ravenwood.
+     *
+     * @param <TTHIS> class owning the method.
+     */
+    public static class ReflectedMethod<TTHIS> {
+        private final Class<TTHIS> mThisClass;
+        private final Method mMethod;
+
+        private ReflectedMethod(Class<TTHIS> thisClass, Method method) {
+            mThisClass = thisClass;
+            mMethod = method;
+        }
+
+        /** Factory method. */
+        @SuppressWarnings("unchecked")
+        public static <TTHIS> ReflectedMethod<TTHIS> reflectMethod(
+                @NonNull Class<TTHIS> clazz, @NonNull String methodName,
+                @NonNull Class<?>... argTypes) {
+            try {
+                return new ReflectedMethod(clazz, clazz.getMethod(methodName, argTypes));
+            } catch (NoSuchMethodException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        /** Factory method. */
+        @SuppressWarnings("unchecked")
+        public static <TTHIS> ReflectedMethod<TTHIS> reflectMethod(
+                @NonNull String className, @NonNull String methodName,
+                @NonNull Class<?>... argTypes) {
+            try {
+                return reflectMethod((Class<TTHIS>) Class.forName(className), methodName, argTypes);
+            } catch (ClassNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        /** Call the instance method */
+        @SuppressWarnings("unchecked")
+        public <RET> RET call(@NonNull TTHIS thisObject, @NonNull Object... args) {
+            try {
+                return (RET) mMethod.invoke(Objects.requireNonNull(thisObject), args);
+            } catch (InvocationTargetException | IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        /** Call the static method */
+        @SuppressWarnings("unchecked")
+        public <RET> RET callStatic(@NonNull Object... args) {
+            try {
+                return (RET) mMethod.invoke(null, args);
+            } catch (InvocationTargetException | IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    /** Handy method to create an array */
+    public static <T> T[] arr(@NonNull T... objects) {
+        return objects;
+    }
 }