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.

A few things ~

1. Switching the param orderering as you did such that `e` comes before `w` fixes the issue for me.
2. I see the same problem with your sample app locally.  I only updated the Android SDK location, built and installed both apks on my device.  When I run adb I get the original error.  You do not get the error.  This to me means there may still be a general issue, or some issue I have that is different than your setup.  Basically, I cannot blame my gradle build anymore because your sample app does the same thing.

```
$ adb shell am instrument -w com.example.macrobenchmark/androidx.test.runner.AndroidJUnitRunner

com.example.macrobenchmark.ExampleStartupBenchmark:
Error in startup(com.example.macrobenchmark.ExampleStartupBenchmark):
java.lang.AssertionError: ERRORS (not suppressed): DEBUGGABLE
WARNINGS (suppressed):

ERROR: Benchmark Target is Debuggable
$ cat macrobenchmark/build.gradle | grep DEB
        testInstrumentationRunnerArguments["androidx.benchmark.suppressErrors"] = "DEBUGGABLE"
```


3. Regarding the test suggestions, I would run the `getString()` from some unit test I create and run on the device?  Not sure how/where to run that code.
4. The only place I can find that touches `testInstrumentationRunnerArguments` is:

```
testInstrumentationRunnerArguments clearPackageData: 'true'
```

But I tried commenting that out to no effect.  I do not see anything else in our build that accesses or mutates this value.  But, like I said, your sample app is also showing the issue for me.  Did you test on a physical device running Android 15 by chance?