Functional/integration testing

index 31e49ba96..a48c1af9d 100644
@@ -6,6 +6,7 @@
 
 CONFIG_VIRTIO=y
 CONFIG_VIRTIO_PCI=y
+CONFIG_VIRTIO_CONSOLE=y
 
 CONFIG_NET=y
 CONFIG_INET=y

index 64715e2e7..d030787a4 100644
@@ -45,6 +45,7 @@ option (like the Bluetooth subsystem) can be enabled on top of this.
 
 	CONFIG_VIRTIO=y
 	CONFIG_VIRTIO_PCI=y
+	CONFIG_VIRTIO_CONSOLE=y
 
 	CONFIG_NET=y
 	CONFIG_INET=y

index 4ee306405..015e7cc1a 100644
@@ -1,6 +1,7 @@
 CONFIG_PCI=y
 CONFIG_VIRTIO=y
 CONFIG_VIRTIO_PCI=y
+CONFIG_VIRTIO_CONSOLE=y
 
 CONFIG_NET=y
 CONFIG_INET=y

index f6de2e685..6e30a535f 100644
@@ -321,6 +321,8 @@ tools_btgatt_server_SOURCES = tools/btgatt-server.c src/uuid-helper.c
 tools_btgatt_server_LDADD = src/libshared-mainloop.la \
 						lib/libbluetooth-internal.la
 
+tools_test_runner_LDADD = $(OPENPTY_LIBS)
+
 tools_rctest_LDADD = lib/libbluetooth-internal.la
 
 tools_l2test_LDADD = lib/libbluetooth-internal.la

index 52de7d665..a87e9211c 100644
@@ -251,6 +251,14 @@ AC_ARG_ENABLE(tools, AS_HELP_STRING([--disable-tools],
 		[disable Bluetooth tools]), [enable_tools=${enableval}])
 AM_CONDITIONAL(TOOLS, test "${enable_tools}" != "no")
 
+if (test "${enable_tools}" = "yes"); then
+	AC_CHECK_FUNCS([openpty], [openpty_libs=],
+	  [AC_CHECK_LIB([util], [openpty], [openpty_libs=-lutil],
+	    [AC_CHECK_LIB([bsd], [openpty], [openpty_libs=-lbsd],
+                [AC_MSG_ERROR([openpty not found])])])])
+	AC_SUBST(OPENPTY_LIBS, [${openpty_libs}])
+fi
+
 AC_ARG_ENABLE(monitor, AS_HELP_STRING([--disable-monitor],
 		[disable Bluetooth monitor]), [enable_monitor=${enableval}])
 AM_CONDITIONAL(MONITOR, test "${enable_monitor}" != "no")

index a48c1af9d..bb3cb221f 100644
@@ -8,6 +8,14 @@ CONFIG_VIRTIO=y
 CONFIG_VIRTIO_PCI=y
 CONFIG_VIRTIO_CONSOLE=y
 
+CONFIG_HYPERVISOR_GUEST=y
+CONFIG_PARAVIRT=y
+CONFIG_KVM_GUEST=y
+
+CONFIG_PTP_1588_CLOCK=y
+CONFIG_PTP_1588_CLOCK_KVM=y
+CONFIG_PTP_1588_CLOCK_VMCLOCK=y
+
 CONFIG_NET=y
 CONFIG_INET=y
 

index d030787a4..60f18683c 100644
@@ -122,6 +122,22 @@ options may be useful:
 	CONFIG_DEBUG_MUTEXES=y
 	CONFIG_KASAN=y
 
+Other
+-----
+
+For tests requiring accurate time inside the VM, possible with KVM:
+
+.. code-block::
+
+	CONFIG_HYPERVISOR_GUEST=y
+	CONFIG_PARAVIRT=y
+	CONFIG_KVM_GUEST=y
+
+	CONFIG_PTP_1588_CLOCK=y
+	CONFIG_PTP_1588_CLOCK_KVM=y
+	CONFIG_PTP_1588_CLOCK_VMCLOCK=y
+
+
 EXAMPLES
 ========
 

index 015e7cc1a..0cf5e2723 100644
@@ -3,6 +3,14 @@ CONFIG_VIRTIO=y
 CONFIG_VIRTIO_PCI=y
 CONFIG_VIRTIO_CONSOLE=y
 
+CONFIG_HYPERVISOR_GUEST=y
+CONFIG_PARAVIRT=y
+CONFIG_KVM_GUEST=y
+
+CONFIG_PTP_1588_CLOCK=y
+CONFIG_PTP_1588_CLOCK_KVM=y
+CONFIG_PTP_1588_CLOCK_VMCLOCK=y
+
 CONFIG_NET=y
 CONFIG_INET=y
 

new file mode 100644
index 000000000..bb3d1ae46
@@ -0,0 +1,769 @@
+===============
+test-functional
+===============
+
+**test-functional** [*OPTIONS*]
+
+DESCRIPTION
+===========
+
+**test-functional(1)** is used for functional testing of BlueZ and
+kernel using multiple virtual machine environments, connected by real
+or virtual controllers.
+
+OPTIONS
+=======
+
+The `test-functional` script simply runs `Pytest
+<https://pytest.org>`__ which can take the following options:
+https://docs.pytest.org/en/stable/reference/reference.html#command-line-flags
+
+The following additional options apply:
+
+:--kernel=<image>: Kernel image (or built Linux source tree root) to
+	use.  See **test-runner(1)** and `tester.config` for required
+	kernel config.
+
+	If not provided, value from `FUNCTIONAL_TESTING_KERNEL`
+	environment variable is used. If none, no image is used.
+
+:--usb=hci0,hci1: USB controllers to use in tests that require use of
+	real controllers.
+
+	If not provided, value from `FUNCTIONAL_TESTING_CONTROLLERS`
+	environment variable is used. If none, all USB controllers
+	with suitable permissions are considered.
+
+:--force-usb: Force tests to use USB controllers instead of `btvirt`.
+
+:--vm-timeout=<seconds>: Specify timeout for communication with VM hosts.
+
+:--log-filter=[+-]<pattern>,[+-]<pattern>,...: Allow/deny lists
+	for filtering logging output. The pattern is a shell glob matching
+	to the logger names.
+
+:--build-dir=<path>: Path to build directory where to search for BlueZ
+        executables.
+
+:--list: Output brief lists of existing tests.
+
+Tests that require kernel image or USB controllers are skipped if none
+are available. Normally, tests use `btvirt`.
+
+VM instances share a directory ``/run/shared`` with host machine,
+located on host usually in ``/tmp/bluez-func-test-*/shared-*``.  Core
+dumps etc. are copied out from it before test instance is shut down.
+
+
+REQUIREMENTS
+============
+
+General
+-------
+
+The following are needed:
+
+- QEmu (x86_64)
+- ``dbus-daemon`` available
+
+Recommended:
+
+- KVM-enabled x86_64 host system
+- Preferably built BlueZ source tree
+- ``chronyd`` available
+- ``util-linux`` tools available
+- ``agetty`` available
+
+Python
+------
+
+The following Python packages are required:
+
+.. code-block::
+
+   pytest
+   pexpect
+   dbus-python
+
+To install them via pip::
+
+	python3 -m pip install -r test/functional/requirements.txt
+
+On Fedora / RHEL::
+
+	sudo dnf install python3-pytest python3-pexpect python3-dbus
+
+
+Kernel
+------
+
+The **test-functional(1)** tool requires a kernel image with similar
+config as **test-runner(1)**.  Simplest setup is
+
+.. code-block::
+
+	cp ../bluez/doc/tester.config .config
+	make olddefconfig
+	make -j8
+
+To get log timestamps right, the kernel should have the following
+configuration enabled:
+
+.. code-block::
+
+	CONFIG_HYPERVISOR_GUEST=y
+	CONFIG_PARAVIRT=y
+	CONFIG_KVM_GUEST=y
+
+	CONFIG_PTP_1588_CLOCK=y
+	CONFIG_PTP_1588_CLOCK_KVM=y
+	CONFIG_PTP_1588_CLOCK_VMCLOCK=y
+
+USB
+---
+
+Some tests may require a hardware controller instead of the virtual `btvirt` one.
+
+
+EXAMPLES
+========
+
+Run all tests
+-------------
+
+.. code-block::
+
+	$ test/test-functional --kernel=/pathto/bzImage
+
+	$ export FUNCTIONAL_TESTING_KERNEL=/pathto/bzImage
+	$ test/test-functional
+
+Show output during run
+----------------------
+
+.. code-block::
+
+	$ test/test-functional --log-cli-level=0
+
+Show only specific loggers:
+
+.. code-block::
+
+	$ test/test-functional --log-cli-level=0 --log-filter=rpc,host
+
+	$ test/test-functional --log-cli-level=0 --log-filter=*.bluetoothctl
+
+Filter out loggers:
+
+.. code-block::
+
+	$ test/test-functional --log-cli-level=0 --log-filter=-host
+
+	$ test/test-functional --log-cli-level=0 --log-filter=host,-host.*.1
+
+Run selected tests
+------------------
+
+.. code-block::
+
+	$ test/test-functional test/functional/test_cli_simple.py::test_bluetoothctl_script_show
+
+	$ test/test-functional -k test_bluetoothctl_script_show
+
+	$ test/test-functional -k 'test_btmgmt or test_bluetoothctl'
+
+Don't run tests with a given marker:
+
+.. code-block::
+
+	$ test/test-functional -m "not pipewire"
+
+Don't run known-failing tests:
+
+.. code-block::
+
+	$ test/test-functional -m "not xfail"
+
+Note that otherwise known-failing tests would be run, but with
+failures suppressed.
+
+Run previously failed and stop on failure
+-----------------------------------------
+
+.. code-block::
+
+	$ test/test-functional -x --ff
+
+List all tests
+--------------
+
+.. code-block::
+
+	$ test/test-functional --list
+
+Show errors from know-failing test
+----------------------------------
+
+.. code-block::
+
+	$ test/test-functional --runxfail -k test_btmgmt_info
+
+Redirect USB devices
+--------------------
+
+.. code-block::
+
+	$ test/test-functional --usb=hci0,hci1
+
+	$ export FUNCTIONAL_TESTING_CONTROLLERS=hci0,hci1
+	$ test/test-functional -vv
+
+This does not require running as root. Changing device permissions is
+sufficient. In verbose mode (``-vv``) some instructions are printed.
+
+Run all tests using the USB controllers:
+
+.. code-block::
+
+	$ test/test-functional --usb=hci0,hci1 --force-usb
+
+Run tests in parallel
+---------------------
+
+pytest-xdist is required for parallel execution. To run:
+
+.. code-block::
+
+	$ test/test-functional -n auto
+
+To reduce VM setup/teardowns:
+
+.. code-block::
+
+	$ test/test-functional -n auto --dist loadgroup
+
+Logging in to a test VM instance
+--------------------------------
+
+While test is running:
+
+.. code-block::
+
+	$ test/test-functional-attach
+
+For this to be useful, usually, you need to pause the test
+e.g. by running with ``--trace`` option.
+
+To do it manually, when starting the tester will log a line like::
+
+	TTY: socat /tmp/bluez-func-test-q658swgi/bluez-func-test-tty-0 STDIO,rawer
+
+with the location of the socket where the serial is connected to.
+
+WRITING TESTS
+=============
+
+The functional tests are written in files (test modules) names
+`test/functional/test_*.py`.  They are written using standard Pytest
+style.  See https://docs.pytest.org/en/stable/getting-started.html
+
+Example: Virtual machines
+-------------------------
+
+.. code-block:: python
+
+   from pytest_bluez import host_config, Bluetoothd, Bluetoothctl
+
+   @host_config(
+       [Bluetoothd(), Bluetoothctl()],
+       [Bluetoothd(), Bluetoothctl()],
+   )
+   def test_bluetoothctl_pair(hosts):
+       host0, host1 = hosts
+
+       host0.bluetoothctl.send("scan on\n")
+       host0.bluetoothctl.expect(f"Controller {host0.bdaddr.upper()} Discovering: yes")
+
+       host1.bluetoothctl.send("pairable on\n")
+       host1.bluetoothctl.expect("Changing pairable on succeeded")
+       host1.bluetoothctl.send("discoverable on\n")
+       host1.bluetoothctl.expect(f"Controller {host1.bdaddr.upper()} Discoverable: yes")
+
+       host0.bluetoothctl.expect(f"Device {host1.bdaddr.upper()}")
+       host0.bluetoothctl.send(f"pair {host1.bdaddr}\n")
+
+       idx, m = host0.bluetoothctl.expect(r"Confirm passkey (\d+).*:")
+       key = m[0].decode("utf-8")
+
+       host1.bluetoothctl.expect(f"Confirm passkey {key}")
+
+       host0.bluetoothctl.send("yes\n")
+       host1.bluetoothctl.send("yes\n")
+
+       host0.bluetoothctl.expect("Pairing successful")
+
+The test declares a VM setup with two Qemu instances, where both hosts
+run bluetoothd and start a bluetoothctl process.  The Qemu instances
+have `btvirt` virtual BT controllers and can see each other.
+
+The test itself runs on the parent host.
+
+The `host0/1.bluetoothctl.*` commands invoke RPC calls to one of the
+the two VM instances. In this case, they are controlling the
+`bluetoothctl` process using `pexpect` library to deal with its
+command line.
+
+When the test body finishes executing, the test passes. Or, it fails
+if any ``assert`` statement fails or an error is raised. For example,
+above ``RemoteError`` due to bluetoothctl not proceeding as expected
+in pairing is possible.
+
+The host configuration (bluetoothd + bluetoothctl above) is torn down
+between test (SIGTERM/SIGKILL sent etc.).
+
+By default the VM instance itself continues running, and may be used
+for other tests that share the same VM setup.
+
+Generally, the framework automatically orders the tests so that the VM
+setup does not need to be restarted unless needed.
+
+
+Example host plugin
+-------------------
+
+The `host.bluetoothctl` implementation used above is as follows:
+
+.. code-block:: python
+
+   from pytest_bluez import HostPlugin, Bluetoothd
+
+   class Bluetoothctl(Pexpect):
+       # Declare unique plugin name
+       name = "bluetoothctl"
+
+       # Declare plugin dependencies to be loaded first
+       depends = [Bluetoothd()]
+
+       # These run on parent host side:
+
+       def __init__(self, subdir, name):
+           self.exe = utils.find_exe(subdir, name)
+
+       def presetup(self):
+           pass
+
+       # These run on VM side at setup/teardown:
+
+       def setup(self, impl):
+           self.log = logging.getLogger(self.name)
+           self.log_stream = utils.LogStream(self.name)
+           self.ctl = pexpect.spawn(self.exe, logfile=self.log_stream.stream)
+
+       def teardown(self):
+           self.ctl.terminate()
+
+       # These define custom RPC methods that can be called
+
+       def expect(self, *a, **kw):
+           ret = self.ctl.expect(*a, **kw)
+           self.log.debug("match found")
+           return ret, self.ctl.match.groups()
+
+       def send(self, *a, **kw):
+           return self.ctl.send(*a, **kw)
+
+
+
+Host plugins are for injecting code to run on the VM side test hosts.
+The host plugins have scope of one test.  The VM side test framework
+sends SIGTERM and SIGKILL to all processes in the test process group
+to reset the state between each test.
+
+The plugins are declared by inheriting from `HostPlugin`. Their
+`__init__()` is supposed to only store declarative configuration on
+`self` and runs on parent side early in the test discovery phase.  The
+`presetup` runs on parent side in test setup phase, before VM
+environment is started. The plugin can for example do
+`pytest.skip(reason="something")` to skip the test.
+
+The `setup()` and `teardown()` methods run on VM-side at host
+environment start and end.  All other methods can be invoked via RPC
+by the parent tester, and any values returned by them are passed via
+RPC back to the parent.
+
+To load a plugin to a VM host, pass it to `host_config()` in the
+declaration of a given test.
+
+Test fixtures
+=============
+
+The following test fixtures are used to deal with spawning VM hosts:
+
+hosts
+-----
+
+.. code-block::
+
+    Session-scope fixture that expands to a list of VM host proxies
+    (`HostProxy`), with configuration as specified in `host_config`. The
+    VM instances used may be reused by other tests.  The userspace test
+    runner is torn down between tests.
+
+    Example:
+
+        def test_something(hosts):
+            host0 = hosts[0]
+            host1 = hosts[1]
+
+hosts_once
+----------
+
+.. code-block::
+
+   def test_something(hosts_once):
+       host0 = hosts_once[0]
+       host1 = hosts_once[1]
+
+Function-scope fixture. Same as `hosts`, but spawn separate VM
+instances for this test only.
+
+Others
+------
+
+The following fixtures are defined, but mainly for use as dependencies
+to `hosts`: `kernel` (selected kernel image), `usb_indices` (selected
+USB controllers), `host_setup` (current host plugin configurations),
+`vm_setup` (VM host configuration), `vm` (VM instances without
+userspace setup), `vm_once` (same but with function scope).
+
+Utilities
+=========
+
+In addition to standard Pytest features, the following items are
+available in the `pytest_bluez` module.
+
+host_config
+-----------
+
+.. code-block::
+
+    @host_config(*host_setup, hw=False, reuse=False)
+
+    Declare host configuration.
+
+    Args:
+        *host_setup: each argument is a list of plugins to be loaded on a host.
+            The number of arguments specifies the number of hosts.
+        hw (bool): whether to require hardware BT controller
+        reuse (bool): whether to define a setup where the test host processes
+            are not required to be torn down between tests. This is only useful
+            for tests that do not perturb e.g. bluetoothd state too much.
+
+    Returns:
+        callable: decorator setting pytest attributes
+
+    Example:
+
+        @host_config([Bluetoothd()], [Bluetoothd()])
+        def test_something(hosts):
+            host0, host1 = hosts
+
+    Example:
+
+        # Allow not restarting Bluetoothd between tests sharing this configuration
+        base_config = host_config([Bluetoothd()], reuse=True)
+
+        @base_config
+        def test_one(hosts):
+            host0, = hosts
+
+        @base_config
+        def test_two(hosts):
+            # Note: uses same Bluetoothd() instance as above
+            host0, = hosts
+
+parametrized_host_config
+------------------------
+
+.. code-block::
+
+    Declare parametrized host configurations.
+
+    See https://docs.pytest.org/en/stable/how-to/parametrize.html for the
+    concept.
+
+    Args:
+        param_host_setups (list): list of host setups
+        hw (bool): whether to require hardware BT controller
+        reuse (bool): whether to define a setup where the test host processes
+            are not required to be torn down between tests. This is only useful
+            for tests that do not perturb e.g. bluetoothd state too much.
+
+    Returns:
+        callable: decorator setting pytest attributes
+
+HostProxy
+---------
+
+.. code-block::
+
+   class HostProxy:
+       """
+       Parent-side proxy for VM host: load plugins, RPC calls to plugins
+       """
+
+       def load(self, plugin: HostPlugin):
+           """
+           Load given plugin to the VM host synchronously.
+           """
+
+       def start_load(self, plugin: HostPlugin):
+           """
+           Initiate loading the given plugin to the VM host.  Use
+           `wait_load` to wait for completion and make loaded plugins
+           usable.
+
+           """
+
+       def wait_load(self):
+           """
+           Wait for plugin loads to complete, and make plugins available.
+           """
+
+       def close(self)
+           """
+           Shutdown this VM host tester instance.
+           """
+
+       def __getattr__(self, name):
+           """
+   	Get a proxy attribute for one of the loaded plugins
+   	"""
+
+Parent host-side representation of one VM host with loadable plugins.
+
+Plugins are usually loaded based on `host_setup`, but can also be
+loaded during the test itself.
+
+Loaded plugins appear as attributes on the host proxy.
+
+find_exe
+--------
+
+.. code-block::
+
+   from pytest_bluez import find_exe
+   bluetoothctl = find_exe("client", "bluetoothctl")
+
+Find absolute path to the given executable, either within BlueZ build
+directory or on host.
+
+
+mainloop_invoke
+-------------
+
+.. code-block::
+
+    Blocking invoke of `func` in GLib main loop.
+
+    Note:
+
+        GLib main loop is only available for VM host plugins, not in tester.
+
+    Example:
+
+        value = mainloop_invoke(lambda: 123)
+        assert value == 123
+
+    Warning:
+        dbus-python **MUST** be used only from the GLib main loop,
+        as the library has concurrency bugs. All functions using it
+        **MUST** either run from GLib main loop eg. via mainloop_wrap
+
+mainloop_wrap
+-------------
+
+.. code-block::
+
+    Wrap function to run in GLib main loop thread
+
+    Note:
+
+        GLib main loop is only available for VM host plugins, not in tester.
+
+    Example:
+
+        @mainloop_wrap
+        def func():
+            bus = dbus.SystemBus()
+
+mainloop_wrap
+-------------
+
+.. code-block::
+
+    Wrap function to assert it runs from GLib main loop
+
+    Note:
+
+        GLib main loop is only available for VM host plugins, not in tester.
+
+    Example:
+
+        @mainloop_assert
+        def func():
+            bus = dbus.SystemBus()
+
+LogStream
+---------
+
+.. code-block::
+
+   from pytest_bluez import LogStream
+
+   log_stream = LogStream("bluetoothctl")
+   subprocess.run(["bluetoothctl", "show"], stdout=log_stream.stream)
+
+Utility to redirect a stream to logging with accurate kernel-provided
+timestamps.
+
+RemoteError
+-----------
+
+.. code-block::
+
+   from pytest_bluez import RemoteError
+
+   try:
+       host.call(foo)
+   except RemoteError as exc:
+       print(exc.traceback)
+       original_exception = exc.exc
+
+Exception raised on the VM side, passed through RPC. Properties:
+`traceback` is a traceback string and `exc` is the original exception
+instance raised on the remote side.
+
+Host plugins
+============
+
+The following host plugins are available:
+
+HostPlugin
+----------
+
+Base class for host plugins. See also example above.
+
+.. code-block::
+
+   class HostPlugin:
+       """
+       Plugin to insert code to VM host side.
+
+       Attributes:
+           name (str): unique name for the plugin
+           depends (tuple[HostPlugin]): plugins to be loaded before this one
+           value (object): object to appear as HostProxy attribute on parent side.
+               If None, the plugin is represented by a proxy object that does RPC
+               calls. Otherwise, must be a serializable value.
+
+       """
+
+       name = None
+       depends = ()
+       value = None
+
+       def __init__(self):
+           """
+           Configure plugin (runs on parent host side).  This is
+           called at test discovery time, so should mainly store static
+           data.
+
+           """
+           pass
+
+       def presetup(self):
+           """
+           Parent host-side setup, before VM environment is started.  May
+           use pytest.skip() to skip tests in case plugin cannot be set up.
+
+           """
+           pass
+
+       def setup(self, impl):
+           """
+           VM-side setup
+
+           Args:
+               impl (Implementation): plugin host object
+           """
+           pass
+
+       def teardown(self):
+           """VM-side teardown"""
+           pass
+
+Bdaddr
+------
+
+Host plugin providing ``host.bdaddr``.
+Loaded by default.
+
+Bluetoothctl
+------------
+
+.. code-block::
+
+   class Bluetoothctl(HostPlugin)
+       def expect(self, *a, **kw)
+       def send(self, *a, **kw)
+
+Host plugin for starting and controlling `bluetoothctl` with pexpect.
+
+Bluetoothd
+----------
+
+Host plugin starting Bluetoothd.
+
+Call
+----
+
+.. code-block::
+
+   class Call(HostPlugin):
+       def __call__(self, func, *args, **kwargs)
+
+Host plugin providing ``host.call(func, *args, **kw)`` which invokes
+the given function on VM host side.  Loaded by default.
+
+DbusSession
+-----------
+
+Host plugin providing session DBus, at address
+`impl["dbus-session"].address`.
+
+DbusSystem
+----------
+
+Host plugin providing system DBus, at address
+`impl["dbus-system"].address`.
+
+Pexpect
+-------
+
+.. code-block::
+
+   class Pexpect(HostPlugin)
+       def spawn(self, cmd)
+           """Returns: spawn_id"""
+       def close(self, spawn_id)
+       def expect(self, spawn_id, *a, **kw)
+       def send(self, spawn_id, *a, **kw)
+
+Host plugin for starting and controlling processes with pexpect.
+
+Rcvbuf
+------
+
+Host plugin setting pipe buffer size defaults.
+Loaded by default.

index bb3d1ae46..0135b05d2 100644
@@ -81,9 +81,10 @@ The following Python packages are required:
 
 .. code-block::
 
-   pytest
-   pexpect
-   dbus-python
+	pytest>=8
+	pexpect
+	dbus-python
+	PyGObject>=3.40
 
 To install them via pip::
 

new file mode 100644
index 000000000..fe1c85178
@@ -0,0 +1,2 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later

new file mode 100644
index 000000000..b796e03bb
@@ -0,0 +1,4 @@
+pytest>=8
+pexpect
+dbus-python
+PyGObject>=3.40

152 lines not on this page · raw message

new file mode 100644
index 000000000..d51d32c6a
@@ -0,0 +1,30 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""
+Tests for btmgmt using VM instances
+"""
+import sys
+import pytest
+import subprocess
+import tempfile
+
+from pytest_bluez import host_config, find_exe, run
+
+pytestmark = [pytest.mark.vm]
+
+btmgmt = find_exe("tools", "btmgmt")
+
+
+@host_config([])
+def test_btmgmt_info(hosts):
+    (host,) = hosts
+
+    result = host.call(
+        run,
+        [btmgmt, "--index", "0", "info"],
+        stdout=subprocess.PIPE,
+        stdin=subprocess.DEVNULL,
+        encoding="utf-8",
+    )
+    assert result.returncode == 0
+    assert f"addr {host.bdaddr.upper()}" in result.stdout

new file mode 100644
index 000000000..899871fa2
@@ -0,0 +1,13 @@
+[pytest]
+log_format = %(asctime)s %(levelname)-6s %(name)-20s:  %(message)s
+log_date_format = %Y-%m-%d %H:%M:%S.%f
+log_level = 0
+log_file = test-functional.log
+markers =
+    vm: tests requiring VM image
+
+addopts =
+    -p pytest_bluez
+
+# Default timeout
+vm_timeout = 30

new file mode 100644
index 000000000..cb4dca71c
@@ -0,0 +1,10 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+from .rpc import RemoteError
+
+from .env import *
+from .utils import *
+from .host_plugins import *
+
+from .plugin import *

754 lines not on this page · raw message

480 lines not on this page · raw message

547 lines not on this page · raw message

387 lines not on this page · raw message

new file mode 100644
index 000000000..b533f73d1
@@ -0,0 +1,20 @@
+#!/usr/bin/python3 -P
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+import sys
+from pathlib import Path
+from importlib.machinery import PathFinder
+
+
+class SelfImport(PathFinder):
+    def find_spec(self, fullname, path=None, target=None):
+        if fullname == "pytest_bluez":
+            path = [str(Path(__file__).parent / "..")]
+        return super().find_spec(fullname, path, target)
+
+
+sys.meta_path.insert(0, SelfImport())
+
+import pytest_bluez.env
+
+sys.exit(pytest_bluez.env._main_runner())

new file mode 100644
index 000000000..fe1c85178
@@ -0,0 +1,2 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later

59 lines not on this page · raw message

new file mode 100644
index 000000000..6d56c42ec
@@ -0,0 +1,16 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+import os
+import pytest
+import subprocess
+import threading
+
+from .. import utils
+
+
+def test_log_stream(caplog):
+    with utils.LogStream(__name__) as log_stream:
+        log_stream.stream.write(b"hello")
+
+    (record,) = (r for r in caplog.records if r.name == __name__)
+    assert "hello" in record.message

511 lines not on this page · raw message

new file mode 100755
index 000000000..a739a9554

Lines of this file are not shown. View the raw message.

52 lines not on this page · raw message

new file mode 100644
index 000000000..4feb7d599
@@ -0,0 +1,536 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""
+Tests for Pipewire audio
+
+To use uninstalled version of Pipewire, run the tests in Pipewire
+devenv::
+
+    meson devenv -C ../pipewire/builddir -w . test/test-functional -m pipewire -v
+"""
+import sys
+import os
+import re
+import pytest
+import subprocess
+import tempfile
+import time
+import logging
+import json
+import dbus
+import threading
+from pathlib import Path
+
+import pytest
+
+from pytest_bluez import (
+    HostPlugin,
+    host_config,
+    find_exe,
+    Bluetoothd,
+    Bluetoothctl,
+    DbusSession,
+    LogStream,
+    wait_until,
+    mainloop_wrap,
+)
+
+pytestmark = [pytest.mark.vm, pytest.mark.pipewire]
+
+log = logging.getLogger(__name__)
+
+
+class Pipewire(HostPlugin):
+    """
+    Launch Pipewire in VM instance
+    """
+
+    name = "pipewire"
+    depends = [DbusSession(), Bluetoothd()]
+
+    def __init__(
+        self,
+        uuids=(
+            "0000110a-0000-1000-8000-00805f9b34fb",
+            "0000110b-0000-1000-8000-00805f9b34fb",
+        ),
+        roles="a2dp_sink a2dp_source",
+        config=None,
+    ):
+        self.uuids = tuple(uuids)
+        self.roles = str(roles)
+        self.config = config
+
+        # For running Pipewire from build directory
+        self.devenv = {}
+        if os.environ.get("PW_UNINSTALLED"):
+            devenv_keys = [
+                "WIREPLUMBER_MODULE_DIR",
+                "WIREPLUMBER_CONFIG_DIR",
+                "WIREPLUMBER_DATA_DIR",
+                "PIPEWIRE_CONFIG_DIR",
+                "PIPEWIRE_MODULE_DIR",
+                "SPA_PLUGIN_DIR",
+                "SPA_DATA_DIR",
+                "ACP_PATHS_DIR",
+                "ACP_PROFILES_DIR",
+                "GST_PLUGIN_PATH",
+                "ALSA_PLUGIN_DIR",
+                "LD_LIBRARY_PATH",
+                "PW_UNINSTALLED",
+                "PW_BUILDDIR",
+            ]
+            for key in devenv_keys:
+                value = os.environ.get(key)
+                if value is not None:
+                    self.devenv[key] = value
+
+    def presetup(self, config):
+        try:
+            self.exe_pw = find_exe("", "pipewire")
+            self.exe_wp = find_exe("", "wireplumber")
+            self.exe_dump = find_exe("", "pw-dump")
+
+            # check version
+            res = subprocess.run(
+                [self.exe_wp, "--version"], stdout=subprocess.PIPE, encoding="utf-8"
+            )
+            m = re.search("libwireplumber ([0-9.]+)", res.stdout)
+            if m:
+                version = tuple(int(x) for x in m.group(1).split("."))
+                if version < (0, 5, 8):
+                    raise ValueError("wireplumber too old")
+            else:
+                raise ValueError("wireplumber version unknown")
+        except (FileNotFoundError, ValueError) as exc:
+            pytest.skip(reason=f"Pipewire: {exc}")
+
+    @mainloop_wrap
+    def setup(self, impl):
+        self.play = None
+        self.record = None
+        self.log = logging.getLogger(self.name)
+
+        self.tmpdir = tempfile.TemporaryDirectory(prefix="pipewire-", dir="/run")
+        conf_dir = Path(self.tmpdir.name) / "config"
+        runtime_dir = Path(self.tmpdir.name) / "runtime"
+        state_dir = Path(self.tmpdir.name) / "state"
+
+        dropin_dir = conf_dir / "wireplumber" / "wireplumber.conf.d"
+        wp_conf = dropin_dir / "01-config.conf"
+        wp_extra_conf = dropin_dir / "02-extra-config.conf"
+
+        conf_dir.mkdir()
+        runtime_dir.mkdir()
+        dropin_dir.mkdir(parents=True)
+        state_dir.mkdir()
+
+        environ = dict(os.environ)
+        environ.update(self.devenv)
+
+        environ["XDG_CONFIG_HOME"] = str(conf_dir)
+        environ["XDG_STATE_HOME"] = str(runtime_dir)
+        environ["XDG_RUNTIME_HOME"] = str(runtime_dir)
+        environ["PIPEWIRE_RUNTIME_DIR"] = str(runtime_dir)
+        environ["XDG_STATE_HOME"] = str(state_dir)
+        environ["PIPEWIRE_DEBUG"] = "2"
+        environ["WIREPLUMBER_DEBUG"] = (
+            "spa.bluez5.iso:3,spa.bluez5*:4,s-monitors:4,m-lua-scripting:4,s-linking:4,s-device:4"
+        )
+
+        # Handle devenv
+        if "WIREPLUMBER_CONFIG_DIR" in environ:
+            environ["WIREPLUMBER_CONFIG_DIR"] = (
+                environ["WIREPLUMBER_CONFIG_DIR"] + ":" + str(conf_dir / "wireplumber")
+            )
+
+        with open(wp_conf, "w") as f:
+            text = f"""
+            monitor.bluez.properties = {{
+               bluez5.roles = [ {self.roles} ]
+               bluez5.decode-buffer.latency = 4096
+            }}
+            """
+            f.write(text)
+
+        if self.config is not None:
+            with open(wp_extra_conf, "w") as f:
+                f.write(self.config)
+
+        log.info(f"Starting pipewire: {self.exe_pw}")
+
+        self.logger = LogStream("pipewire")
+        self.pw = subprocess.Popen(
+            self.exe_pw,
+            env=environ,
+            stdout=self.logger.stream,
+            stderr=subprocess.STDOUT,
+        )
+
+        log.info(f"Starting pipewire: {self.exe_wp}")
+
+        self.wp = subprocess.Popen(
+            self.exe_wp,
+            env=environ,
+            stdout=self.logger.stream,
+            stderr=subprocess.STDOUT,
+        )
+
+        # Wait for Pipewire's bluetooth services
+        log.info("Wait for Pipewire...")
+        bus = dbus.SystemBus()
+        bus.set_exit_on_disconnect(False)
+        adapter = dbus.Interface(
+            bus.get_object("org.bluez", "/org/bluez/hci0"),
+            "org.freedesktop.DBus.Properties",
+        )
+
+        def cond():
+            uuids = [str(uuid) for uuid in adapter.Get("org.bluez.Adapter1", "UUIDs")]
+            return all(uuid in uuids for uuid in self.uuids)
+
+        wait_until(cond)
+
+        os.environ["PIPEWIRE_RUNTIME_DIR"] = str(runtime_dir)
+
+        # Wait for wireplumber session services
+        def cond():
+            try:
+                data = json.loads(self.pw_dump())
+            except:
+                return False
+            for item in data:
+                if item.get("type", None) != "PipeWire:Interface:Client":
+                    continue
+                if item["info"]["props"]["application.name"] != "WirePlumber":
+                    continue
+                if "api.bluez" in item["info"]["props"].get("session.services", ""):
+                    return True
+            return False
+
+        wait_until(cond)
+
+        log.info("Pipewire ready")
+
+    def pw_dump(self):
+        ret = subprocess.run(["pw-dump"], stdout=subprocess.PIPE, encoding="utf-8")
+        return ret.stdout
+
+    def pw_play(self):
+        self.play = subprocess.Popen(
+            [
+                "pw-play",
+                "--raw",
+                "--rate",
+                "4000",
+                "--channels",
+                "1",
+                "--format",
+                "s8",
+                "-",
+            ],
+            stdin=subprocess.PIPE,
+        )
+        self.play_thread = threading.Thread(
+            target=self._play_thread, args=(self.play.stdin,)
+        )
+        self.play_thread.start()
+
+    def _play_thread(self, stream):
+        block = bytes([j % 256 for j in range(4096)])
+        while True:
+            try:
+                stream.write(block)
+            except:
+                self.log.info("pw_play ended")
+                break
+
+    def pw_record(self):
+        self.record = subprocess.Popen(
+            [
+                "pw-record",
+                "-P",
+                "media.class=Audio/Sink",
+                "--raw",
+                "--format",
+                "s8",
+                "--rate",
+                "4000",
+                "--channels",
+                "1",
+                "-",
+            ],
+            stdout=subprocess.PIPE,
+        )
+        self.record_thread = threading.Thread(
+            target=self._record_thread, args=(self.record.stdout,)
+        )
+        self.record_thread.start()
+        self.record_signal = threading.Event()
+
+    def _record_thread(self, stream):
+        while True:
+            try:
+                block = stream.read(256)
+                if not block:
+                    break
+            except:
+                self.log.info("pw_record failed")
+                break
+
+            # If we get anything nonzero, some signal is getting
+            # through.  Can't check exactness due to encoding and
+            # possibly heavy underruns in VM environment.
+            if any(list(block)):
+                self.log.info("pw_record signal found")
+                self.record_success = True
+                self.record_signal.set()
+                return
+            else:
+                self.log.debug("pw_record: waiting for signal")
+
+        self.log.error("pw_record: no signal found")
+        self.record_success = False
+        self.record_signal.set()
+
+    def pw_record_wait_signal(self, timeout=160):
+        res = self.record_signal.wait(timeout=timeout)
+        return res and self.record_success
+
+    def teardown(self):
+        log.info("Stop pipewire")
+        self.pw.terminate()
+        self.wp.terminate()
+        if self.play is not None:
+            try:
+                self.play.stdin.close()
+            except BrokenPipeError:
+                pass
+            self.play.terminate()
+            self.play_thread.join()
+        if self.record is not None:
+            try:
+                self.record.stdout.close()
+            except BrokenPipeError:
+                pass
+            self.record.terminate()
+            self.record_thread.join()
+        self.tmpdir.cleanup()
+
+
[email protected]
+def paired_hosts(hosts, host_setup):
+    from .test_bluetoothctl_vm import (
+        test_bluetoothctl_pair_bredr,
+        test_bluetoothctl_pair_le,
+    )
+
+    le = any(
+        "ControllerMode = le" in (p.conf or "")
+        for plugins in host_setup["setup"]
+        for p in plugins
+        if isinstance(p, Bluetoothd)
+    )
+
+    if le:
+        test_bluetoothctl_pair_le(hosts)
+    else:
+        test_bluetoothctl_pair_bredr(hosts)
+
+    return hosts
+
+
+a2dp_host = [Bluetoothctl(), Pipewire(roles="a2dp_sink a2dp_source")]
+
+
+@host_config(a2dp_host, a2dp_host)
+def test_pipewire_a2dp(paired_hosts):
+    host0, host1 = paired_hosts
+
+    # Connect
+    host1.bluetoothctl.send(f"trust {host0.bdaddr}\n")
+    host0.bluetoothctl.send(f"connect {host1.bdaddr}\n")
+
+    # Wait for pipewire devices to appear
+    check_pipewire_devices_exist(host0, "a2dp-sink")
+
+    # Test streaming
+    host1.pipewire.pw_record()
+    host0.pipewire.pw_play()
+
+    assert host1.pipewire.pw_record_wait_signal()
+
+
+bap_ucast_host = [
+    Bluetoothd(conf="[General]\nControllerMode = le\n", args=["-E", "-K"]),
+    Bluetoothctl(),
+    Pipewire(
+        roles="bap_sink bap_source", uuids=("00001850-0000-1000-8000-00805f9b34fb",)
+    ),
+]
+
+
+@host_config(bap_ucast_host, bap_ucast_host)
+def test_pipewire_bap_ucast(paired_hosts):
+    host0, host1 = paired_hosts
+
+    # Connect
+    host1.bluetoothctl.send(f"trust {host0.bdaddr}\n")
+
+    host0.bluetoothctl.send(f"scan off\n")
+    host0.bluetoothctl.send(f"connect {host1.bdaddr}\n")
+
+    # Wait for pipewire devices to appear
+    check_pipewire_devices_exist(host0, "bap-sink")
+
+    # Test streaming
+    host1.pipewire.pw_record()
+    host0.pipewire.pw_play()
+
+    assert host1.pipewire.pw_record_wait_signal()
+
+
+bcast_src_config = """
+monitor.bluez.properties = {
+  bluez5.bcast_source.config = [
+    {
+      "broadcast_code": "Test",
+      "encryption": false,
+      "bis": [ { "qos_preset": "16_2_1" } ]
+    }
+  ]
+}
+"""
+
+bap_bcast_src_host = [
+    Bluetoothd(conf="[General]\nControllerMode = le\n", args=["-E", "-K"]),
+    Bluetoothctl(),
+    Pipewire(
+        roles="bap_bcast_source",
+        uuids=("00001850-0000-1000-8000-00805f9b34fb",),
+        config=bcast_src_config,
+    ),
+]
+
+bap_bcast_snk_host = [
+    Bluetoothd(conf="[General]\nControllerMode = le\n", args=["-E", "-K"]),
+    Bluetoothctl(),
+    Pipewire(roles="bap_bcast_sink", uuids=("00001850-0000-1000-8000-00805f9b34fb",)),
+]
+
+
+@host_config(bap_bcast_src_host, bap_bcast_snk_host)
+def test_pipewire_bap_bcast(hosts):
+    host0, host1 = hosts
+
+    # Start broadcasting
+    check_pipewire_devices_exist(host0, "bap-sink")
+    host0.pipewire.pw_play()
+
+    # Connect
+    host1.bluetoothctl.send(f"scan on\n")
+
+    host0.bluetoothctl.send(f"advertise on\n")
+
+    host1.pipewire.pw_record()
+
+    idx, m = host1.bluetoothctl.expect(f"Transport (/org/bluez/hci0/.+)")
+    transport = m[0].decode("utf-8")
+
+    # BUG!: issuing transport select immediately causes failure
+    # BUG!: as it tries to enter broadcasting state while config(1)
+    # BUG!: is not finished and BROADCASTING state gets cancelled via
+    # BUG!:    transport.c:bap_state_changed()
+    # BUG!:    -> transport_update_playing(transport, FALSE)
+    # BUG!:    -> transport_set_state(transport, TRANSPORT_STATE_IDLE)
+
+    # TODO: fix the bug and go to transport.select without waiting here
+    check_pipewire_devices_exist(host1, "device")
+
+    host1.bluetoothctl.send(f"transport.select {transport}\n")
+
+    check_pipewire_devices_exist(host1, "bap-source")
+
+    # Test streaming
+    assert host1.pipewire.pw_record_wait_signal()
+
+
+hfp_hf_host = [
+    Bluetoothctl(),
+    Pipewire(
+        roles="hfp_hf",
+        uuids=("0000111e-0000-1000-8000-00805f9b34fb",),
+    ),
+]
+
+hfp_ag_host = [
+    Bluetoothctl(),
+    Pipewire(
+        roles="hfp_ag",
+        uuids=("0000111f-0000-1000-8000-00805f9b34fb",),
+    ),
+]
+
+
+@host_config(hfp_ag_host, hfp_hf_host)
+def test_pipewire_hfp(paired_hosts):
+    host0, host1 = paired_hosts
+
+    # Connect
+    host1.bluetoothctl.send(f"trust {host0.bdaddr}\n")
+
+    host0.bluetoothctl.send(f"scan off\n")
+    host0.bluetoothctl.send(f"connect {host1.bdaddr}\n")
+
+    # Wait for pipewire devices to appear
+    check_pipewire_devices_exist(host0, "hfp")
+
+    # Test streaming
+    host1.pipewire.pw_record()
+    host0.pipewire.pw_play()
+
+    assert host1.pipewire.pw_record_wait_signal()
+
+
+def check_pipewire_devices_exist(host, profile="a2dp-sink"):
+    factories = {
+        "a2dp-sink": ("api.bluez5.a2dp.sink",),
+        "a2dp-source": ("api.bluez5.a2dp.source",),
+        "hfp": ("api.bluez5.sco.sink", "api.bluez5.sco.source"),
+        "bap-sink": ("api.bluez5.media.sink",),
+        "bap-source": ("api.bluez5.media.source",),
+        "bap-duplex": ("api.bluez5.media.sink", "api.bluez5.media.source"),
+        "device": ("bluez5",),
+    }[profile]
+
+    text = ""
+
+    def cond():
+        nonlocal text
+
+        text = host.pipewire.pw_dump()
+        try:
+            data = json.loads(text)
+        except:
+            return False
+
+        seen = set()
+        for item in data:
+            if item.get("type", None) == "PipeWire:Interface:Node":
+                props = item["info"]["props"]
+                seen.add(props.get("factory.name", None))
+                continue
+            if item.get("type", None) == "PipeWire:Interface:Device":
+                props = item["info"]["props"]
+                seen.add(props.get("device.api", None))
+                continue
+
+        if not set(factories).difference(seen):
+            return True
+
+        return False
+
+    try:
+        wait_until(cond)
+    except TimeoutError:
+        assert False, f"pipewire devices not seen within timeout:\n{text}"

index 899871fa2..e77d7e4ee 100644
@@ -4,6 +4,7 @@ log_date_format = %Y-%m-%d %H:%M:%S.%f
 log_level = 0
 log_file = test-functional.log
 markers =
+    pipewire: tests requiring Pipewire
     vm: tests requiring VM image
 
 addopts =

index 0135b05d2..6254f01c1 100644
@@ -34,6 +34,9 @@ The following additional options apply:
 	environment variable is used. If none, all USB controllers
 	with suitable permissions are considered.
 
+:--btmon: Launch btmon on all hosts to log events, and dump traffic to
+	test-functional-\*.btsnoop
+
 :--force-usb: Force tests to use USB controllers instead of `btvirt`.
 
 :--vm-timeout=<seconds>: Specify timeout for communication with VM hosts.

@@ -726,6 +729,12 @@ Bluetoothd
 
 Host plugin starting Bluetoothd.
 
+Btmon
+-----
+
+Host plugin providing btmon running in the background.
+Usually should be loaded via `--btmon`.
+
 Call
 ----
 

index cb4dca71c..9e967d472 100644
@@ -6,5 +6,6 @@ from .rpc import RemoteError
 from .env import *
 from .utils import *
 from .host_plugins import *
+from .btmon import *
 
 from .plugin import *

116 lines not on this page · raw message

index a47f097cc..786493ffb 100644
@@ -10,6 +10,7 @@ from pathlib import Path
 import pytest
 
 from . import utils, env
+from .btmon import Btmon
 
 
 __all__ = [

@@ -109,6 +110,11 @@ def pytest_addoption(parser):
     parser.addini(
         "vm_timeout", "Default timeout for communication with VM etc.", default="30"
     )
+    group.addoption(
+        "--btmon",
+        action="store_true",
+        help="Launch btmon on all hosts to log events, and dump traffic to test-functional-*.btsnoop",
+    )
 
     # host_plugins.Rcvbuf:
     parser.addini(

@@ -447,6 +453,9 @@ def _hosts_impl(request, vm, setup, name, reuse):
 
         h.set_instance_name(f"{name}.{idx}")
 
+        if request.session.config.option.btmon:
+            plugins = (Btmon(),) + plugins
+
         for p in plugins:
             h.start_load(p)
 

@@ -465,18 +474,24 @@ def _close_hosts(request, vm, name):
     if name is None:
         return
 
-    success = True
     try:
-        vm.close_hosts()
-    except:
-        success = False
-        raise
+        if request.session.config.option.btmon and name is not None:
+            for h in vm.hosts:
+                if hasattr(h, "btmon"):
+                    h.btmon._call_noreply("teardown")
     finally:
-        _copy_host_files(vm)
+        success = True
+        try:
+            vm.close_hosts()
+        except:
+            success = False
+            raise
+        finally:
+            _copy_host_files(vm)
 
-        # Stop VM if tester is not responding
-        if not success:
-            vm.stop()
+            # Stop VM if tester is not responding
+            if not success:
+                vm.stop()
 
 
 def _copy_host_files(vm):

index dee6aa6d0..1c080b6ce 100644
@@ -786,6 +786,15 @@ endif
 TESTS = $(unit_tests)
 AM_TESTS_ENVIRONMENT = MALLOC_CHECK_=3 MALLOC_PERTURB_=69
 
+check-functional: all
+	$(srcdir)/test/test-functional -v --kernel="$(FUNCTIONAL_TESTING_KERNEL)" \
+		--bluez-build-dir="$(top_builddir)" --bluez-src-dir="$(srcdir)" \
+		$(srcdir)/test
+
+if FUNCTIONAL_TESTING
+check: check-functional
+endif
+
 if DBUS_RUN_SESSION
 AM_TESTS_ENVIRONMENT += dbus-run-session --
 endif

index a87e9211c..410696078 100644
@@ -413,6 +413,28 @@ if (test "${enable_testing}" = "yes"); then
 		#include <linux/net_tstamp.h>]])
 fi
 
+AC_ARG_ENABLE(functional-testing, AS_HELP_STRING([--enable-functional-testing],
+			[enable functional testing tools]),
+			[enable_functional_testing=yes; functional_testing_kernel=${enableval}],
+                        [enable_functional_testing=no])
+AM_CONDITIONAL(FUNCTIONAL_TESTING, test "${enable_functional_testing}" = "yes")
+AC_ARG_VAR(FUNCTIONAL_TESTING_KERNEL, [vmlinux image to use for functional testing])
+FUNCTIONAL_TESTING_KERNEL=${functional_testing_kernel}
+
+if (test "${enable_functional_testing}" = "yes"); then
+  if (test "${enable_client}" = "no" || \
+      test "${enable_tools}" != "yes" || \
+      test "${enable_testing}" != "yes"); then
+    AC_MSG_ERROR([--enable-functional-testing requires --enable-client --enable-tools --enable-testing])
+  fi
+  AC_MSG_CHECKING([pytest and dependencies])
+  python3 -m pip install --dry-run --no-index -r "${srcdir}/test/functional/requirements.txt" >/dev/null
+  if (test "$?" != "0"); then
+    AC_MSG_ERROR([pytest or dependencies missing])
+  fi
+  AC_MSG_RESULT([ok])
+fi
+
 AC_ARG_ENABLE(experimental, AS_HELP_STRING([--enable-experimental],
 			[enable experimental tools]),
 					[enable_experimental=${enableval}])

index 6254f01c1..f5b7aa7c8 100644
@@ -271,6 +271,9 @@ The functional tests are written in files (test modules) names
 `test/functional/test_*.py`.  They are written using standard Pytest
 style.  See https://docs.pytest.org/en/stable/getting-started.html
 
+Use `Black <https://black.readthedocs.io/en/stable/>`__ to autoformat
+Python test code.
+
 Example: Virtual machines
 -------------------------
 

new file mode 100644
index 000000000..561b04703
@@ -0,0 +1,23 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""
+Tests for the test suite itself
+"""
+import sys
+import subprocess
+import warnings
+from pathlib import Path
+
+import pytest
+
+
+def test_formatting():
+    pytest.importorskip("black")
+
+    result = subprocess.run(
+        [sys.executable, "-mblack", "--check", "--diff", "-q", Path(__file__).parent],
+        stdout=subprocess.PIPE,
+        encoding="utf-8",
+    )
+    if result.returncode != 0:
+        warnings.warn(f"Formatting incorrect:\n{result.stdout}")

index f5b7aa7c8..311a5a4c1 100644
@@ -11,6 +11,15 @@ DESCRIPTION
 kernel using multiple virtual machine environments, connected by real
 or virtual controllers.
 
+EXAMPLE
+=======
+
+.. code-block::
+
+   $ ./configure --enable-functional-testing --enable-testing --enable-tools
+   $ make -j8
+   $ test/test-functional --kernel-build -v
+
 OPTIONS
 =======
 

@@ -50,6 +59,12 @@ The following additional options apply:
 
 :--list: Output brief lists of existing tests.
 
+:--kernel-build=no/use/auto/force: Build a suitable kernel image from source.
+
+:--kernel-upstream=<GIT_URL>: URL for Git clone of kernel sources.
+
+:--kernel-branch=<GIT_BRANCH>: Git branch to build from.
+
 Tests that require kernel image or USB controllers are skipped if none
 are available. Normally, tests use `btvirt`.
 

@@ -102,7 +117,11 @@ Kernel
 ------
 
 The **test-functional(1)** tool requires a kernel image with similar
-config as **test-runner(1)**.  Simplest setup is
+config as **test-runner(1)**.  If given `--kernel-build` option, a
+suitable image is built from sources downloaded under
+`test/.pytest_cache`.
+
+Simplest setup is
 
 .. code-block::
 

index e77d7e4ee..b99225df2 100644
@@ -12,3 +12,7 @@ addopts =
 
 # Default timeout
 vm_timeout = 30
+
+# Default sources for kernel-build when requested
+kernel_upstream = https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/
+kernel_branch = master

43 lines not on this page · raw message

83 lines not on this page · raw message

index 311a5a4c1..ec8dd536a 100644
@@ -729,6 +729,143 @@ Base class for host plugins. See also example above.
            """VM-side teardown"""
            pass
 
+Agent
+-----
+
+DBus org.bluez.Agent1 test implementation.
+
+.. code-block::
+
+    class Agent(env.HostPlugin):
+        """
+        Host plugin providing org.bluez.Agent1 test implementation.
+
+        Asynchronous events are handled via expect().
+
+        Example:
+
+            host.agent.device_method(host1.bdaddr, "Pair")
+            event = host.agent.expect("org.bluez.Agent1.RequestConfirmation")
+            assert event.passkey == 1234
+            host.agent.reply()
+        """
+
+        depends = [Bluetoothd()]
+        name = "agent"
+
+        def __init__(self, capability="KeyboardDisplay", path="/agent"):
+
+        def has_device(self, address):
+            """
+            Return True if device with given address exists
+            """
+
+        def device_method(self, address, method, *a, **kw):
+            """
+            Call given org.bluez.Device1 DBus method
+
+            Args:
+                address (str): bdaddr of target device
+                method (str): name of DBus method, without interface prefix
+                *a, **kw: argument passed to the DBus method call
+
+            Events:
+                AgentEvent(kind="org.bluez.Device1.{method}:reply")
+            """
+
+        def adapter_method(self, method, *a, **kw):
+            """
+            Call given org.bluez.Adapter1 DBus method
+
+            Args:
+                method (str): name of DBus method, without interface prefix
+                *a, **kw: argument passed to the DBus method call
+
+            Events:
+                AgentEvent(kind="org.bluez.Adapter1.{method}")
+            """
+
+        def adapter_set(self, key, value):
+            """
+            Set given org.bluez.Adapter1 property
+            """
+
+        def adapter_get(self, key):
+            """
+            Get given org.bluez.Adapter1 property
+            """
+
+        def get_event(self, block=True):
+            """
+            Get most recent pending AgentEvent, blocking optional
+            """
+
+        def expect(self, kinds):
+            """
+            Get most recent pending AgentEvent and assert its kind
+
+            Returns:
+                event (AgentEvent)
+            """
+
+        def reply(self, *value):
+            """
+            Provide DBus reply to the most recent pending AgentEvent
+
+            Arguments:
+                *value: DBus reply return values
+            """
+
+        def reply_error(self, err=None):
+            """
+            Provide DBus error reply to the most recent pending AgentEvent
+
+            Arguments:
+                err (dbus.DBusException): DBus error. Default: org.bluez.Error.Rejected
+            """
+
+.. code-block::
+
+    class Event:
+        """
+        Asynchronous event
+
+        Properties:
+            kind (str): event kind
+            info (dict): event properties (also available as attributes)
+        """
+
+.. code-block::
+
+   class EventPluginMixin:
+       """
+       Simple expect() / reply() pattern for handing async events in
+       host plugins.
+       """
+
+.. code-block::
+
+   def dbus_service_event_method(
+       interface, name, args=(), in_signature="", out_signature="", sync=True
+   ):
+       """
+       dbus.service.method that pushes Event instances to self.events
+
+       Example:
+
+           class AgentObject(dbus.service.Object):
+               @utils.mainloop_assert
+               def __init__(self, bus, path, events):
+                   self.events = events
+                   super().__init__(bus, path)
+
+               AuthorizeService = dbus_service_event_method(
+                   "org.bluez.Agent1",
+                   "AuthorizeService", ("device", "uuid"), "os", sync=False
+               )
+
+       """
+
 Bdaddr
 ------
 

46 lines not on this page · raw message

index 9e967d472..cb0629d45 100644
@@ -7,5 +7,6 @@ from .env import *
 from .utils import *
 from .host_plugins import *
 from .btmon import *
+from .agent import *
 
 from .plugin import *

371 lines not on this page · raw message

index c4605d8ee..f7fff18fe 100644
@@ -562,8 +562,8 @@ class Environment:
             if not success:
                 raise RuntimeError("Error closing hosts")
 
-    def _add_log(self, *a, **kw):
-        f = utils.LogStream(*a, **kw)
+    def _add_log(self, *a, cls=utils.LogStream, **kw):
+        f = cls(*a, **kw)
         self.log_streams.append(f)
         return f.stream
 

@@ -713,7 +713,7 @@ class Environment:
 
             host_names.append(f"host.{ENV_INDEX}.{idx}")
 
-            logger = self._add_log(host_names[-1])
+            logger = self._add_log(host_names[-1], cls=_HostLogStream)
             self.jobs.append(Popen(cmd, stdout=logger, stderr=logger, stdin=DEVNULL))
 
             # Start log reader

@@ -752,3 +752,22 @@ class Environment:
 
     def __exit__(self, type, value, tb):
         self.stop()
+
+
+class _HostLogStream(utils.LogStream):
+    """
+    Log streams that parses kernel BUG:/WARNING:
+    """
+
+    def __init__(self, name):
+        super().__init__(name)
+        self._warn_re = re.compile(
+            rb"^(BUG:|WARNING:|general protection fault|Kernel panic)"
+        )
+
+    def _do_log(self, line, anc):
+        super()._do_log(line, anc)
+
+        if self._warn_re.match(line):
+            fmt_line = line.decode("utf-8", errors="surrogateescape")
+            warnings.warn(fmt_line)

new file mode 100644
index 000000000..6b9275520
@@ -0,0 +1,285 @@
+# -*- coding: utf-8; mode: python; eval: (blacken-mode); -*-
+# SPDX-License-Identifier: LGPL-2.1-or-later
+"""
+Tests for Obex
+"""
+import sys
+import os
+import re
+import pytest
+import subprocess
+import tempfile
+import time
+import logging
+import json
+import dbus
+import threading
+from pathlib import Path
+
+import pytest
+
+from pytest_bluez import (
+    HostPlugin,
+    Agent,
+    host_config,
+    find_exe,
+    Bluetoothd,
+    Bluetoothctl,
+    Obexd,
+    LogStream,
+    wait_until,
+    mainloop_wrap,
+    mainloop_assert,
+    Event,
+    EventPluginMixin,
+    dbus_service_event_method,
+    Pexpect,
+    utils,
+)
+
+pytestmark = [pytest.mark.vm]
+
+log = logging.getLogger(__name__)
+
+
+BUS_NAME = "org.bluez.obex"
+PATH = "/org/bluez/obex"
+AGENT_MANAGER_INTERFACE = "org.bluez.obex.AgentManager1"
+AGENT_INTERFACE = "org.bluez.obex.Agent1"
+CLIENT_INTERFACE = "org.bluez.obex.Client1"
+SESSION_INTERFACE = "org.bluez.obex.Session1"
+FILE_TRANSFER_INTERFACE = "org.bluez.obex.FileTransfer1"
+TRANSFER_INTERFACE = "org.bluez.obex.Transfer1"
+
+FTP_UUID = "00001106-0000-1000-8000-00805f9b34fb"
+
+
+class ObexAgent(HostPlugin, EventPluginMixin):
+    depends = [Bluetoothd()]
+    name = "obex_agent"
+
+    def __init__(self, path="/obexagent"):
+        self.path = path
+
+    @mainloop_wrap
+    def setup(self, impl):
+        EventPluginMixin.setup(self, impl)
+
+        self.bus = dbus.SessionBus()
+        self.bus.set_exit_on_disconnect(False)
+
+        self.agent = ObexAgentObject(self.bus, self.path, self.events)
+
+        bluez = self.bus.get_object(BUS_NAME, PATH)
+        self.manager = dbus.Interface(bluez, AGENT_MANAGER_INTERFACE)
+        self.manager.RegisterAgent(self.path)
+
+        log.info("Obex agent registered")
+
+    def cleanup(self):
+        path = Path("/run/obex")
+        for f in path.iterdir():
+            f.unlink()
+
+
+def agent_method(*a, **kw):
+    return dbus_service_event_method(AGENT_INTERFACE, *a, **kw)
+
+
+class ObexAgentObject(dbus.service.Object):
+    @mainloop_assert
+    def __init__(self, bus, path, events):
+        self.events = events
+        super().__init__(bus, path)
+
+    AuthorizePush = agent_method("AuthorizePush", ("path",), "o", "s", sync=False)
+    Cancel = agent_method("Cancel")
+
+
+def write_obex_file(name, content):
+    with open(f"/run/obex/{name}", "w") as f:
+        f.write(content)
+
+
+def read_file(name):
+    with open(name, "r") as f:
+        return f.read()
+
+
+#
+# Direct Obex Python client API tests
+#
+
+
+class ObexClient(HostPlugin, EventPluginMixin):
+    name = "obex"
+
+    @mainloop_wrap
+    def setup(self, impl):
+        EventPluginMixin.setup(self, impl)
+
+        self.transferred = 0
+        self.transfer_path = None
+        self.transfer_size = 0
+
+        self.bus = dbus.SessionBus()
+        self.log = logging.getLogger(self.name)
+        self.client = dbus.Interface(
+            self.bus.get_object(BUS_NAME, PATH), CLIENT_INTERFACE
+        )
+
+        self.bus.add_signal_receiver(
+            self.properties_changed,
+            dbus_interface="org.freedesktop.DBus.Properties",
+            signal_name="PropertiesChanged",
+            path_keyword="path",
+        )
+
+    @mainloop_wrap
+    def connect(self, bdaddr):
+        def reply(path):
+            obj = self.bus.get_object(BUS_NAME, path)
+            self.session = dbus.Interface(obj, SESSION_INTERFACE)
+            self.ftp = dbus.Interface(obj, FILE_TRANSFER_INTERFACE)
+
+        self._object_method(
+            self.client, "CreateSession", bdaddr, {"Target": "ftp"}, reply_handler=reply
+        )
+
+    @mainloop_assert
+    def properties_changed(self, interface, properties, invalidated, path):
+        if path != self.transfer_path:
+            return
+
+        if "Status" in properties and (
+            properties["Status"] == "complete" or properties["Status"] == "error"
+        ):
+            self.events.put(
+                Event(
+                    f"{FILE_TRANSFER_INTERFACE}:{properties['Status']}",
+                    properties=properties,
+                )
+            )
+            self.log.debug(f"Transfer {properties['Status']}")
+
+        if "Transferred" not in properties:
+            return
+
+        value = properties["Transferred"]
+        speed = (value - self.transferred) / 1000
+        self.log.debug(
+            f"Transfer progress {value}/{self.transfer_size} at {speed} kBps"
+        )
+        self.transferred = value
+
+    @mainloop_wrap
+    def ftp_list_folder(self):
+        return self.ftp.ListFolder()
+
+    @mainloop_wrap
+    def ftp_get_file(self, dst, src):
+        path, properties = self.ftp.GetFile(dst, src)
+        self.transfer_path = path
+        self.transfer_size = properties["Size"]
+        return properties["Filename"]
+
+
[email protected]
+def paired_hosts(hosts):
+    from .test_agent import test_agent_pair_bredr
+
+    if hosts[0].agent.has_device(hosts[1].bdaddr):
+        return hosts
+
+    test_agent_pair_bredr(hosts, True)
+    return hosts
+
+
+obex_host_config = host_config(
+    [Agent(), Obexd(), ObexClient(), Pexpect()],
+    [Agent(), Obexd(), ObexAgent()],
+    reuse=True,
+)
+
+
[email protected]
+def obex_hosts(paired_hosts):
+    host0, host1 = paired_hosts
+
+    if hasattr(host0, "session"):
+        return paired_hosts
+
+    host0.obex.connect(host1.bdaddr)
+
+    service = host1.agent.expect("org.bluez.Agent1.AuthorizeService")
+    assert service.uuid == FTP_UUID
+    host1.agent.reply()
+
+    host0.obex.expect("org.bluez.obex.Client1.CreateSession:reply")
+
+    yield paired_hosts
+
+    host1.obex_agent.cleanup()
+
+
+@obex_host_config
+def test_obex_ftp_list(obex_hosts):
+    host0, host1 = obex_hosts
+
+    host1.call(write_obex_file, "test", "1234")
+
+    (item,) = host0.obex.ftp_list_folder()
+    assert item["Type"] == "file"
+    assert item["Name"] == "test"
+    assert item["Size"] == 4
+
+
+@obex_host_config
+def test_obex_ftp_get(obex_hosts):
+    host0, host1 = obex_hosts
+
+    host1.call(write_obex_file, "test", "1234")
+
+    filename = host0.obex.ftp_get_file("", "test")
+    host0.obex.expect("org.bluez.obex.FileTransfer1:complete")
+    assert host0.call(read_file, filename) == "1234"
+
+
+#
+# obexctl tests
+#
+
+
[email protected]
+def obexctl(obex_hosts):
+    host0, host1 = obex_hosts
+
+    exe = find_exe("tools", "obexctl")
+    obexctl = host0.pexpect.spawn([exe])
+
+    host0.pexpect.expect(obexctl, "Client /org/bluez/obex")
+
+    host0.pexpect.send(obexctl, f"connect {host1.bdaddr} {FTP_UUID}\n")
+
+    service = host1.agent.expect("org.bluez.Agent1.AuthorizeService")
+    assert service.uuid == FTP_UUID
+    host1.agent.reply()
+
+    host0.pexpect.expect(obexctl, "Connection successful")
+    host0.pexpect.send(obexctl, f"select /org/bluez/obex/client/session1\n")
+
+    yield obexctl
+
+    host0.pexpect.close(obexctl)
+
+
+@obex_host_config
+def test_obexctl_list(obex_hosts, obexctl):
+    host0, host1 = obex_hosts
+
+    host1.call(write_obex_file, "test", "1234")
+
+    host0.pexpect.send(obexctl, f"ls\n")
+    host0.pexpect.expect(obexctl, f"Type: file")
+    host0.pexpect.expect(obexctl, f"Name: test")
+    host0.pexpect.expect(obexctl, f"Size: 4")

79 lines not on this page · raw message