IssueTracker

When I run Macrobenchmark via the `connectedCheck` target with info logs on, I can see the arg being set:

```
INFO: Configuring Android Instrumentation driver: android_instrumentation_runtime {
  instrumentation_info {
...
    args_map {
      key: "androidx.benchmark.suppressErrors"
      value: "DEBUGGABLE"
    }
  }
}
```

Attempted to pass the flag via the `-e` option to the `instrument` command of ADB, but no change to error output:

```
$ adb shell am instrument -w com.ring.benchmark/androidx.test.runner.AndroidJUnitRunner -e androidx.benchmark.suppressErrors DEBUGGABLE
...
ERROR: Benchmark Target is Debuggable
```

Thank you for the fast response.  Yes, I see the suppressed messages like:

```
java.lang.AssertionError: ERRORS (not suppressed): DEBUGGABLE
WARNINGS (suppressed):

ERROR: Benchmark Target is Debuggable
    Target package com.ringapp.debug is running with debuggable=true in its manifest,
    which drastically reduces runtime performance in order to support debugging
    features. Run benchmarks with debuggable=false. Debuggable affects execution
    speed in ways that mean benchmark improvements might not carry over to a
    real user's experience (or even regress release performance).

While you can suppress these errors (turning them into warnings)
PLEASE NOTE THAT EACH SUPPRESSED ERROR COMPROMISES ACCURACY

// Sample suppression, in a benchmark module's build.gradle:
android {
    defaultConfig {
        testInstrumentationRunnerArguments["androidx.benchmark.suppressErrors"] = "DEBUGGABLE"
    }
}
        at androidx.benchmark.ConfigurationErrorKt.checkAndGetSuppressionState(ConfigurationError.kt:102)
        at androidx.benchmark.macro.MacrobenchmarkKt.checkErrors(Macrobenchmark.kt:190)
        at androidx.benchmark.macro.MacrobenchmarkKt.macrobenchmark(Macrobenchmark.kt:229)
        at androidx.benchmark.macro.MacrobenchmarkKt.macrobenchmarkWithStartupMode(Macrobenchmark.kt:401)
        at androidx.benchmark.macro.junit4.MacrobenchmarkRule.measureRepeated(MacrobenchmarkRule.kt:108)
        at com.ring.benchmark.AbstractStartupBenchmark.startup(StartupBenchmark.kt:61)
        at com.ring.benchmark.AbstractStartupBenchmark.startupPartialCompilation(StartupBenchmark.kt:51)


```

If I set the EMULATOR flag in addition, and run w/ an emulator attached instead of a physical device:

```
testInstrumentationRunnerArguments["androidx.benchmark.suppressErrors"] = "EMULATOR,DEBUGGABLE"
```

I get:

```
java.lang.AssertionError: ERRORS (not suppressed): EMULATOR DEBUGGABLE
WARNINGS (suppressed):

ERROR: Running on Emulator
    Benchmark is running on an emulator, which is not representative of
    real user devices. Use a physical device to benchmark. Emulator
    benchmark improvements might not carry over to a real user's
    experience (or even regress real device performance).

ERROR: Benchmark Target is Debuggable
    Target package com.ringapp.debug is running with debuggable=true in its manifest,
    which drastically reduces runtime performance in order to support debugging
    features. Run benchmarks with debuggable=false. Debuggable affects execution
    speed in ways that mean benchmark improvements might not carry over to a
    real user's experience (or even regress release performance).
```

This leads me to conclude that the gradle declaration is having no effect for some reason.  I am guessing that this is not due to Macrobenchmark itself but something in my rather large app build configuration.  How can I further debug thigs?  For example, I assume that the `testInstrumentationRunnerArguments` declaration causes some state change in the resulting benchmark apk.  How can I verify this?  I tried unzipping the benchmark apk and seems like a string match in dex files but otherwise no obvious way to see where the issue might be.