tests: bluetooth: classic: sdp: add unregister_sdp shell command and test

Add a shell command to unregister SDP service records by index, and
a pytest test case that verifies the full lifecycle:
1. Register a record and verify it is discoverable
2. Disconnect SDP, unregister, reconnect and verify it is gone
3. Re-register and verify it is discoverable again

Initialize the error status variable before calling shell_strtoul():
unlike strtoul(), shell_strtoul() does not clear the output error code
on the success path, so an uninitialized 'err' left a stale stack value
that made the 'Invalid index' guard trip and silently skipped the
actual unregister call.

Also enable CONFIG_ZTEST_SHELL (so the native_sim image stays in the
shell instead of exiting after an empty ztest run) and route the shell
UART to stdin/stdout via CONFIG_UART_NATIVE_PTY_0_ON_STDINOUT, so the
pytest twister harness can drive the shell over the process pipes.

Signed-off-by: Kai Cheng <chengkai@xiaomi.com>

Author: chengkai15

tests/bluetooth/classic/sdp_s/prj.conf

@@ -3,6 +3,7 @@ CONFIG_BT_CLASSIC=y
 CONFIG_BT_SHELL=y
 CONFIG_LOG=y
 CONFIG_ZTEST=y
+CONFIG_ZTEST_SHELL=y
 
 CONFIG_BT_RFCOMM=y
 

tests/bluetooth/classic/sdp_s/pytest/test_sdp.py

@@ -432,13 +432,89 @@ async def sdp_discover_with_range(hci_port, shell, address) -> None:
                                 assert len(search_result) == 0
 
 
+async def sdp_unregister(hci_port, shell, address) -> None:
+    logger.info('<<< connect...')
+    async with await open_transport_or_link(hci_port) as hci_transport:
+        device = Device.with_hci(
+            'Bumble',
+            Address('F0:F1:F2:F3:F4:F5'),
+            hci_transport.source,
+            hci_transport.sink,
+        )
+
+        with open("bumble_hci_sdp_s_unregister.log", "wb") as snoop_file:
+            device.host.snooper = BtSnooper(snoop_file)
+            device.classic_enabled = True
+            device.le_enabled = False
+            await device_power_on(device)
+
+            target_address = address.split(" ")[0]
+            logger.info(f'=== Connecting to {target_address}...')
+            try:
+                connection = await device.connect(target_address, transport=BT_BR_EDR_TRANSPORT)
+                logger.info(f'=== Connected to {connection.peer_address}!')
+            except CommandTimeoutError as e:
+                logger.info('!!! Connection timed out')
+                raise e
+
+            # Register record 0
+            shell.exec_command("sdp_server register_sdp 0")
+
+            # Connect SDP and verify record is visible
+            sdp_client = SDP_Client(connection)
+            await sdp_client.connect()
+
+            logger.info("<<< 1 Verify record 0 is visible after register")
+            service_record_handles = await sdp_client.search_services([SDP_PUBLIC_BROWSE_ROOT])
+            logger.info(f'SERVICES: {service_record_handles}')
+            assert len(service_record_handles) == 1
+
+            # Disconnect SDP L2CAP channel so unregister can succeed
+            await sdp_client.disconnect()
+
+            # Unregister record 0
+            shell.exec_command("sdp_server unregister_sdp 0")
+
+            # Reconnect SDP and verify record is gone
+            await sdp_client.connect()
+
+            logger.info("<<< 2 Verify record 0 is gone after unregister")
+            service_record_handles = await sdp_client.search_services([SDP_PUBLIC_BROWSE_ROOT])
+            logger.info(f'SERVICES: {service_record_handles}')
+            assert len(service_record_handles) == 0
+
+            # Disconnect SDP again
+            await sdp_client.disconnect()
+
+            # Re-register record 0
+            shell.exec_command("sdp_server register_sdp 0")
+
+            # Reconnect SDP and verify record is back
+            await sdp_client.connect()
+
+            logger.info("<<< 3 Verify record 0 is visible after re-register")
+            service_record_handles = await sdp_client.search_services([SDP_PUBLIC_BROWSE_ROOT])
+            logger.info(f'SERVICES: {service_record_handles}')
+            assert len(service_record_handles) == 1
+
+            # Unregister to clean up for other tests
+            await sdp_client.disconnect()
+            shell.exec_command("sdp_server unregister_sdp 0")
+
+
 class TestSdpServer:
     def test_discovery_device(self, sdp_server_dut):
         """Test case to discover IUT"""
         logger.info(f'test_discovery_device {sdp_server_dut}')
         hci, iut_address = sdp_server_dut
         asyncio.run(start_discovery(hci, iut_address))
 
+    def test_sdp_unregister(self, shell: Shell, dut: DeviceAdapter, sdp_server_dut):
+        """Test case to unregister and re-register SDP records"""
+        logger.info(f'test_sdp_unregister {sdp_server_dut}')
+        hci, iut_address = sdp_server_dut
+        asyncio.run(sdp_unregister(hci, shell, iut_address))
+
     def test_sdp_discover(self, shell: Shell, dut: DeviceAdapter, sdp_server_dut):
         """Test case to request SDP records"""
         logger.info(f'test_sdp_discover {sdp_server_dut}')

tests/bluetooth/classic/sdp_s/src/sdp_server.c

@@ -268,6 +268,31 @@ static int cmd_register_sdp_all(const struct shell *sh, size_t argc, char *argv[
 	return 0;
 }
 
+static int cmd_unregister_sdp(const struct shell *sh, size_t argc, char *argv[])
+{
+	int err = 0;
+	unsigned long index;
+
+	index = shell_strtoul(argv[1], 16, &err);
+	if (err || index >= MAX_SDP_RECORD_COUNT) {
+		shell_error(sh, "Invalid index %s", argv[1]);
+		return -EINVAL;
+	}
+
+	if (!sdp_rec_reg[index]) {
+		shell_error(sh, "The SDP record %lu is not registered", index);
+		return -ENOEXEC;
+	}
+
+	err = bt_sdp_unregister_service(&spp_rec[index]);
+	if (err != 0) {
+		shell_error(sh, "Unregister SDP record failed (err %d)", err);
+	} else {
+		sdp_rec_reg[index] = false;
+	}
+	return err;
+}
+
 static int cmd_register_sdp_large(const struct shell *sh, size_t argc, char *argv[])
 {
 	int err;
@@ -372,6 +397,7 @@ SHELL_STATIC_SUBCMD_SET_CREATE(sdp_server_cmds,
 	SHELL_CMD_ARG(register_sdp_large, NULL, "", cmd_register_sdp_large, 1, 0),
 	SHELL_CMD_ARG(register_sdp_large_valid, NULL, "", cmd_register_sdp_large_valid, 1, 0),
 	SHELL_CMD_ARG(register_sdp_uuid128, NULL, "", cmd_register_sdp_uuid128, 1, 0),
+	SHELL_CMD_ARG(unregister_sdp, NULL, "<SDP Record Index>", cmd_unregister_sdp, 2, 0),
 	SHELL_SUBCMD_SET_END
 );
 

tests/bluetooth/classic/sdp_s/tests.yaml

@@ -11,6 +11,8 @@ tests:
     harness_config:
       pytest_dut_scope: session
       fixture: usb_hci
+    extra_args:
+      - CONFIG_UART_NATIVE_PTY_0_ON_STDINOUT=y
     timeout: 900
   bluetooth.classic.sdp.server.no_blobs:
     platform_allow: