Match the lab driver's contract for the BLE connect test.

Read tools/lab/ble.py and device.py properly this time. Two things the
first version got wrong, both of which would have failed on the bench
rather than here:

The driver runs the test by name - "-e class
de.rwth_aachen.phyphox.BleCompatConnectTest" - so the class is renamed to
that. And AndroidDevice.prepare already sets debug.phyphox.remote, with
cleanup clearing it, while the driver goes on talking to the phone after
the test returns; setting and clearing it inside the test would have
pulled the remote API out from under the host's assertions. So the
connect test no longer touches the switch, and the seam check that does
moves to its own class, where its teardown cannot race the driver.

prepare grants the sensor permissions but not BLUETOOTH_CONNECT and
BLUETOOTH_SCAN, and autoConfirm deliberately does not answer system
permission dialogs - verified here that the flow stops on one. The test
grants them itself so it stands alone either way.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Staacks

…e/rwth_aachen/phyphox/BleCompatTest.java …aachen/phyphox/BleCompatConnectTest.javaapp/src/androidTest/java/de/rwth_aachen/phyphox/BleCompatTest.java renamed to app/src/androidTest/java/de/rwth_aachen/phyphox/BleCompatConnectTest.java app/src/androidTest/java/de/rwth_aachen/phyphox/BleCompatTest.java renamed to app/src/androidTest/java/de/rwth_aachen/phyphox/BleCompatConnectTest.java

@@ -8,6 +8,7 @@
 
 import android.content.Context;
 import android.content.Intent;
+import android.os.Build;
 
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.platform.app.InstrumentationRegistry;
@@ -31,24 +32,25 @@
 //drift; this keeps them in one file and still exercises the real scan UI, which is part of what
 //the suite protects.
 //
-//So this test ends where the host takes over: the experiment the device offers is loaded, not
-//started, and serving the remote API. It asserts nothing about the data.
+//So this test ends where the host takes over: the experiment the device offers is loaded and
+//NOT started. It asserts nothing about the data.
 //
-//The device name comes from the driver, which flashes the library examples UNMODIFIED and knows
-//what they advertise as:
+//The class name is the driver's, not a choice - tools/lab/ble.py runs exactly
 //
-//    adb shell am instrument -e class de.rwth_aachen.phyphox.BleCompatTest \
-//        -e bleDevice phyphox-arduino ... 
+//    am instrument -e class de.rwth_aachen.phyphox.BleCompatConnectTest \
+//        -e bleDevice <name> ...
 //
-//Without that parameter there is no board to talk to and that test skips itself, which is what
-//happens in CI - the row needs hardware and runs in the lab. The seam check below needs none and
-//runs everywhere, because a suite that cannot reach the phone is worth catching before the board
-//is even involved.
+//and the driver flashes the library examples UNMODIFIED, so the name is whatever they advertise
+//as. Without that parameter there is no board to talk to and this skips itself, which is what
+//happens in CI - the row needs hardware and runs in the lab.
+//
+//Nothing here touches debug.phyphox.remote. The driver owns it (AndroidDevice.prepare sets it,
+//cleanup clears it) and goes on to talk to the phone after this test returns, so clearing it
+//here would pull the API out from under the host's assertions.
 @RunWith(AndroidJUnit4.class)
-public class BleCompatTest {
+public class BleCompatConnectTest {
 
     private static final String PACKAGE = "de.rwth_aachen.phyphox";
-    private static final int PORT = 8080;
 
     private UiDevice device() {
         return UiDevice.getInstance(getInstrumentation());
@@ -61,56 +63,23 @@ private UiObject2 waitForId(String id, long timeout) {
     @Before
     public void quietFirstRunDialogs() {
         FixtureExperiment.suppressHints();
+        //The scan asks for these at runtime and autoConfirm deliberately does not answer system
+        //permission dialogs, so an ungranted phone stops on one with no board in sight. The
+        //driver grants the sensor permissions it knows about but not these, and granting them
+        //here keeps the test standalone either way.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
+            grant("android.permission.BLUETOOTH_CONNECT", "android.permission.BLUETOOTH_SCAN");
+        grant("android.permission.ACCESS_FINE_LOCATION", "android.permission.ACCESS_COARSE_LOCATION");
     }
 
-    //The precondition the whole suite rests on, and the one half of it that needs no board: an
-    //experiment with a Bluetooth block serves the remote API when the switch is set, so the host
-    //can reach it. The switch is applied where every experiment finishes loading
-    //(Experiment.onExperimentLoaded), which is the same place a transferred one arrives at, so
-    //this covers the delivered case too as far as it can be covered without hardware.
-    @Test
-    public void aBluetoothExperimentServesTheRemoteApiWhenTheSwitchIsSet() throws Exception {
-        shell("setprop debug.phyphox.remote 1");
-        shell("setprop debug.phyphox.remotePort " + PORT);
-        try {
-            FixtureExperiment.launchAssetWithoutWaiting("bluetooth/Heart Rate.phyphox");
-            //It stops at "please pick a device" without one, which is exactly the state the host
-            //finds a transferred experiment in before it starts it - and the API has to answer
-            //there, not only once something is connected.
-            long deadline = System.currentTimeMillis() + 30000;
-            boolean answered = false;
-            while (!answered && System.currentTimeMillis() < deadline) {
-                answered = remoteApiAnswers();
-                if (!answered)
-                    Thread.sleep(500);
-            }
-            assertTrue("the remote API did not come up for a Bluetooth experiment although "
-                    + "debug.phyphox.remote is set - the host cannot reach a device-delivered "
-                    + "experiment either", answered);
-        } finally {
-            shell("setprop debug.phyphox.remote '\"\"'");
-            shell("setprop debug.phyphox.remotePort '\"\"'");
-            FixtureExperiment.close(FixtureExperiment.activity());
-        }
-    }
-
-    private void shell(String command) throws Exception {
-        device().executeShellCommand(command);
-    }
-
-    private boolean remoteApiAnswers() {
-        try {
-            java.net.HttpURLConnection connection = (java.net.HttpURLConnection)
-                    new java.net.URL("http://127.0.0.1:" + PORT + "/config").openConnection();
-            connection.setConnectTimeout(2000);
-            connection.setReadTimeout(2000);
-            try (java.io.InputStream in = connection.getInputStream()) {
-                return in.read() > 0;
-            } finally {
-                connection.disconnect();
+    private void grant(String... permissions) {
+        for (String permission : permissions) {
+            try {
+                getInstrumentation().getUiAutomation().grantRuntimePermission(PACKAGE, permission);
+            } catch (Exception e) {
+                //Not declared on this API level, or already granted - either way not this test's
+                //problem; the scan below fails with a message if it actually mattered.
             }
-        } catch (Exception e) {
-            return false;
         }
     }
 

app/src/androidTest/java/de/rwth_aachen/phyphox/BluetoothRemoteSeamTest.java

@@ -0,0 +1,88 @@
+package de.rwth_aachen.phyphox;
+
+import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
+import static org.junit.Assert.assertTrue;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.uiautomator.UiDevice;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+//The precondition the BLE compatibility suite rests on, and the half of it that needs no board.
+//
+//That suite drives the phone from the host over the remote API (phyphox-docs/tools/lab/ble.py):
+//an instrumented test picks the device out of the scan, and everything after that is asserted
+//from outside. Which only works if an experiment that arrives from a Bluetooth device serves the
+//remote API when debug.phyphox.remote is set.
+//
+//It does, and not by a special case: the switch is applied in Experiment.onExperimentLoaded,
+//where EVERY experiment finishes loading, and every Bluetooth route ends up there through
+//ExperimentListActivity - BluetoothExperimentLoader's success callback and the zip handler both
+//just start the Experiment activity. So a delivered experiment gets it exactly as a launched one
+//does, and there was nothing to extend.
+//
+//But that is a seam nobody would think to preserve while refactoring, and if it breaks the whole
+//lab suite reports a phone it cannot reach rather than a bug it found. Hence this test: it is
+//cheap, it needs no hardware, and it fails with a message naming that consequence.
+//
+//Separate class from BleCompatConnectTest on purpose. That class is what the driver runs by name
+//while it owns the switch itself, and this one sets and clears the switch around its own run -
+//in the same class the clearing would race the driver's assertions.
+@RunWith(AndroidJUnit4.class)
+public class BluetoothRemoteSeamTest {
+
+    private static final int PORT = 8080;
+
+    @Before
+    public void quietFirstRunDialogs() {
+        FixtureExperiment.suppressHints();
+    }
+
+    @Test
+    public void aBluetoothExperimentServesTheRemoteApiWhenTheSwitchIsSet() throws Exception {
+        shell("setprop debug.phyphox.remote 1");
+        shell("setprop debug.phyphox.remotePort " + PORT);
+        try {
+            FixtureExperiment.launchAssetWithoutWaiting("bluetooth/Heart Rate.phyphox");
+            //It stops at "please pick a device" without one, which is exactly the state the host
+            //finds a transferred experiment in before it starts it - and the API has to answer
+            //there, not only once something is connected.
+            long deadline = System.currentTimeMillis() + 30000;
+            boolean answered = false;
+            while (!answered && System.currentTimeMillis() < deadline) {
+                answered = remoteApiAnswers();
+                if (!answered)
+                    Thread.sleep(500);
+            }
+            assertTrue("the remote API did not come up for a Bluetooth experiment although "
+                    + "debug.phyphox.remote is set - the host cannot reach a device-delivered "
+                    + "experiment either", answered);
+        } finally {
+            shell("setprop debug.phyphox.remote '\"\"'");
+            shell("setprop debug.phyphox.remotePort '\"\"'");
+            FixtureExperiment.close(FixtureExperiment.activity());
+        }
+    }
+
+    private void shell(String command) throws Exception {
+        UiDevice.getInstance(getInstrumentation()).executeShellCommand(command);
+    }
+
+    private boolean remoteApiAnswers() {
+        try {
+            java.net.HttpURLConnection connection = (java.net.HttpURLConnection)
+                    new java.net.URL("http://127.0.0.1:" + PORT + "/config").openConnection();
+            connection.setConnectTimeout(2000);
+            connection.setReadTimeout(2000);
+            try (java.io.InputStream in = connection.getInputStream()) {
+                return in.read() > 0;
+            } finally {
+                connection.disconnect();
+            }
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}