Introduce instrumentation params proxying

* Previously, the orchestrator would pass instrumentation params as bundle params (eg: `--no-hidden-api-checks`) would be used to execute the orchestrator itself and not to execute the APK under test which made it impossible to run the APK under test with special instrumentation params.
* Introduce a new flag that allows user to specify which instrumentation params they wish to proxy to the APK under test, the new flag would accept a comma delimited string that would simply remove trailing & leading spaces then pass the strings as-is to the instrumentation. This is implemented this way to minimize touching flags passed from the user as much as possible.

PiperOrigin-RevId: 610486983

Author: copybara-androidxtest

runner/android_test_orchestrator/CHANGELOG.md

@@ -8,10 +8,14 @@
 
 **New Features**
 
+* Introduce Instrumentation Params Proxying which allows the user to proxy
+  instrumentation arguments to the APK under test (eg: --no-hidden-api-checks).
+
 **Breaking Changes**
 
 **API Changes**
 
 **Breaking API Changes**
 
 **Known Issues**
+

runner/android_test_orchestrator/java/androidx/test/orchestrator/AndroidTestOrchestrator.java

@@ -118,6 +118,11 @@
  *
  * <p>Pass {@code -e orchestratorDebug} flag if you need to debug orchestrator itself. Note, to
  * debug test code you still need to pass {@code -e debug}.
+ *
+ * <p>Pass {@code -e orchestratorInstrumentationArgs "params"} to pass {@code params} to the
+ * instrumentation invocation directly instead of adding them to the bundle, {@code params} are
+ * expected to be comma delimited parameters (eg: {@code -e orchestratorInstrumentationArgs
+ * "--no-hidden-api-checks, --no-isolated-storage"})
  */
 public final class AndroidTestOrchestrator extends android.app.Instrumentation
     implements RunFinishedListener {
@@ -452,17 +457,16 @@ private Bundle createResultBundle() {
   @Override
   public void finish(int resultCode, Bundle results) {
 
-      try {
-        super.finish(resultCode, results);
-      } catch (SecurityException e) {
-        Log.e(TAG, "Security exception thrown on shutdown", e);
-        // On API Level 18 a security exception can be occasionally thrown when calling finish
-        // with a result bundle taken from a remote message.  Recreating the result bundle and
-        // retrying finish has a high probability of suppressing the flake.
-        results = createResultBundle();
-        super.finish(resultCode, results);
-      }
-
+    try {
+      super.finish(resultCode, results);
+    } catch (SecurityException e) {
+      Log.e(TAG, "Security exception thrown on shutdown", e);
+      // On API Level 18 a security exception can be occasionally thrown when calling finish
+      // with a result bundle taken from a remote message.  Recreating the result bundle and
+      // retrying finish has a high probability of suppressing the flake.
+      results = createResultBundle();
+      super.finish(resultCode, results);
+    }
   }
 
   @Override

runner/android_test_orchestrator/java/androidx/test/orchestrator/OrchestratorConstants.java

@@ -30,6 +30,11 @@ final class OrchestratorConstants {
   static final String AJUR_COVERAGE = "coverage";
   static final String AJUR_COVERAGE_FILE = "coverageFile";
 
+  // Holds a comma separated listed of args that will be passed to the instrumentation invocation
+  // directly.
+  static final String ORCHESTRATOR_FORWARDED_INSTRUMENTATION_ARGS =
+      "orchestratorInstrumentationArgs";
+
   private OrchestratorConstants() {
     // Do not initialize
   }

runner/android_test_orchestrator/java/androidx/test/orchestrator/TestRunnable.java

@@ -18,6 +18,7 @@
 import static androidx.test.orchestrator.OrchestratorConstants.AJUR_CLASS_ARGUMENT;
 import static androidx.test.orchestrator.OrchestratorConstants.AJUR_LIST_TESTS_ARGUMENT;
 import static androidx.test.orchestrator.OrchestratorConstants.ISOLATED_ARGUMENT;
+import static androidx.test.orchestrator.OrchestratorConstants.ORCHESTRATOR_FORWARDED_INSTRUMENTATION_ARGS;
 import static androidx.test.orchestrator.OrchestratorConstants.TARGET_INSTRUMENTATION_ARGUMENT;
 
 import android.content.Context;
@@ -184,19 +185,36 @@ private Bundle getTargetInstrumentationArguments() {
     return targetArgs;
   }
 
+  /**
+   * Instrumentation params are delimited by comma, each param is stripped from leading and trailing
+   * whitespace.
+   */
+  private List<String> getInstrumentationParamsAndRemoveBundleArgs(Bundle arguments) {
+    List<String> cleanedParams = new ArrayList<>();
+    String forwardedArgs = arguments.getString(ORCHESTRATOR_FORWARDED_INSTRUMENTATION_ARGS);
+    if (forwardedArgs != null) {
+      for (String param : forwardedArgs.split(",")) {
+        cleanedParams.add(param.strip());
+      }
+      arguments.remove(ORCHESTRATOR_FORWARDED_INSTRUMENTATION_ARGS);
+    }
+    return cleanedParams;
+  }
+
   private List<String> buildShellParams(Bundle arguments) throws IOException, ClientNotConnected {
     List<String> params = new ArrayList<>();
     params.add("instrument");
     params.add("-w");
     params.add("-r");
 
+    params.addAll(getInstrumentationParamsAndRemoveBundleArgs(arguments));
+
     for (String key : arguments.keySet()) {
       params.add("-e");
       params.add(key);
       params.add(arguments.getString(key));
     }
     params.add(getTargetInstrumentation());
-
     return params;
   }
 

runner/android_test_orchestrator/javatests/androidx/test/orchestrator/TestRunnableTest.java

@@ -168,6 +168,50 @@ public void testRun_buildsParams_givenNullClassNameAndMethodForTestCollection()
         "-e class com.google.android.example.MyClass");
   }
 
+  @Test
+  public void testRun_buildsParams_givenInstrumentationParamsAreHandledCorrectlyWhenTrue() {
+    arguments.putString(
+        "orchestratorInstrumentationArgs", "--no-hidden-api-checks, --no-isolated-storage");
+    FakeListener listener = new FakeListener();
+    FakeTestRunnable runnable =
+        new FakeTestRunnable(context, "secret", arguments, outputStream, listener, null, true);
+    runnable.run();
+    assertContainsRunnerArgs(runnable.params, "-no-hidden-api-checks --no-isolated-storage");
+  }
+
+  @Test
+  public void testRun_buildsParams_givenInstrumentationParamsAreHandledCorrectlyWithSpace() {
+    arguments.putString(
+        "orchestratorInstrumentationArgs",
+        "--no-hidden-api-checks, --no-isolated-storage, --abi x86_64");
+    FakeListener listener = new FakeListener();
+    FakeTestRunnable runnable =
+        new FakeTestRunnable(context, "secret", arguments, outputStream, listener, null, true);
+    runnable.run();
+    assertContainsRunnerArgs(
+        runnable.params, "-no-hidden-api-checks --no-isolated-storage --abi x86_64");
+  }
+
+  @Test
+  public void testRun_buildsParams_givenInstrumentationParamsAreHandledCorrectlySingleParam() {
+    arguments.putString("orchestratorInstrumentationArgs", "--no-hidden-api-checks");
+    FakeListener listener = new FakeListener();
+    FakeTestRunnable runnable =
+        new FakeTestRunnable(context, "secret", arguments, outputStream, listener, null, true);
+    runnable.run();
+    assertContainsRunnerArgs(runnable.params, "--no-hidden-api-checks");
+  }
+
+  @Test
+  public void testRun_buildsParams_givenInstrumentationParamsAreHandledCorrectlyMultipleParam() {
+    arguments.putString("orchestratorInstrumentationArgs", "--A,--B,--C,--key value");
+    FakeListener listener = new FakeListener();
+    FakeTestRunnable runnable =
+        new FakeTestRunnable(context, "secret", arguments, outputStream, listener, null, true);
+    runnable.run();
+    assertContainsRunnerArgs(runnable.params, "--A --B --C --key value");
+  }
+
   private static void assertContainsRunnerArgs(List<String> params, String... containsArgs) {
     String cmdArgs = Joiner.on(" ").join(params);
     assertThat(cmdArgs, startsWith("instrument -w -r"));