diff --git a/src/ophyd_async/core/_signal_backend.py b/src/ophyd_async/core/_signal_backend.py
index a0ad517b7c..03a0e87327 100644
--- a/src/ophyd_async/core/_signal_backend.py
+++ b/src/ophyd_async/core/_signal_backend.py
@@ -1,5 +1,6 @@
 from abc import abstractmethod
 from collections.abc import Sequence
+from enum import IntEnum
 from typing import Generic, TypedDict, TypeVar, get_origin
 
 import numpy as np
@@ -30,6 +31,7 @@
     | Array1D[np.float32]
     | Array1D[np.float64]
     | np.ndarray
+    | IntEnum
     | StrictEnum
     | Sequence[str]
     | Sequence[StrictEnum]
diff --git a/src/ophyd_async/testing/_assert.py b/src/ophyd_async/testing/_assert.py
index fcb266862e..6fc7cd92e9 100644
--- a/src/ophyd_async/testing/_assert.py
+++ b/src/ophyd_async/testing/_assert.py
@@ -1,5 +1,6 @@
 import asyncio
 import time
+from collections.abc import Callable
 from contextlib import AbstractContextManager
 from typing import Any
 
@@ -60,11 +61,19 @@ async def assert_reading(
 
     """
     actual_reading = await readable.read()
+    _assert_readings_approx_equal(expected_reading, actual_reading)
+
+
+def _assert_readings_approx_equal(expected, actual):
     approx_expected_reading = {
-        k: dict(v, value=approx_value(expected_reading[k]["value"]))
-        for k, v in expected_reading.items()
+        k: dict(
+            v,
+            value=approx_value(expected[k]["value"]),
+            timestamp=approx_value(expected[k]["timestamp"]),
+        )
+        for k, v in expected.items()
     }
-    assert actual_reading == approx_expected_reading
+    assert actual == approx_expected_reading
 
 
 async def assert_configuration(
@@ -88,11 +97,7 @@ async def assert_configuration(
 
     """
     actual_configuration = await configurable.read_configuration()
-    approx_expected_configuration = {
-        k: dict(v, value=approx_value(configuration[k]["value"]))
-        for k, v in configuration.items()
-    }
-    assert actual_configuration == approx_expected_configuration
+    _assert_readings_approx_equal(configuration, actual_configuration)
 
 
 async def assert_describe_signal(signal: SignalR, /, **metadata):
@@ -144,29 +149,27 @@ def __eq__(self, value):
 
 
 class MonitorQueue(AbstractContextManager):
-    def __init__(self, signal: SignalR):
+    def __init__(
+        self, signal: SignalR, timestamp_provider: Callable[[], float] | None = None
+    ):
         self.signal = signal
         self.updates: asyncio.Queue[dict[str, Reading]] = asyncio.Queue()
-        self.signal.subscribe(self.updates.put_nowait)
+        self._timestamp_provider = timestamp_provider or time.time
 
     async def assert_updates(self, expected_value):
         # Get an update, value and reading
-        expected_type = type(expected_value)
-        expected_value = approx_value(expected_value)
         update = await self.updates.get()
-        value = await self.signal.get_value()
-        reading = await self.signal.read()
-        # Check they match what we expected
-        assert value == expected_value
-        assert type(value) is expected_type
-        expected_reading = {
+        # reading = await self.signal.read()
+        await assert_value(self.signal, expected_value)
+        expected_reading: dict[str, Reading] = {
             self.signal.name: {
                 "value": expected_value,
-                "timestamp": pytest.approx(time.time(), rel=0.1),
+                "timestamp": self._timestamp_provider(),  # type: ignore
                 "alarm_severity": 0,
             }
         }
-        assert reading == update == expected_reading
+        await assert_reading(self.signal, expected_reading)
+        _assert_readings_approx_equal(expected_reading, update)
 
     def __enter__(self):
         self.signal.subscribe(self.updates.put_nowait)
diff --git a/src/ophyd_async/testing/_one_of_everything.py b/src/ophyd_async/testing/_one_of_everything.py
index 0ae8385717..1f15e212f0 100644
--- a/src/ophyd_async/testing/_one_of_everything.py
+++ b/src/ophyd_async/testing/_one_of_everything.py
@@ -1,4 +1,5 @@
 from collections.abc import Sequence
+from dataclasses import dataclass
 from typing import Any
 
 import numpy as np
@@ -7,6 +8,7 @@
     Array1D,
     Device,
     DTypeScalar_co,
+    SignalDatatype,
     SignalRW,
     StandardReadable,
     StrictEnum,
@@ -32,19 +34,14 @@ class ExampleTable(Table):
     enum: Sequence[ExampleEnum]
 
 
-def int_array_signal(
-    dtype: type[DTypeScalar_co], name: str = ""
-) -> SignalRW[Array1D[DTypeScalar_co]]:
+def int_array_value(dtype: type[DTypeScalar_co]) -> Array1D[DTypeScalar_co]:
     iinfo = np.iinfo(dtype)  # type: ignore
-    value = np.array([iinfo.min, iinfo.max, 0, 1, 2, 3, 4], dtype=dtype)
-    return soft_signal_rw(Array1D[dtype], value, name)
+    return np.array([iinfo.min, iinfo.max, 0, 1, 2, 3, 4], dtype=dtype)
 
 
-def float_array_signal(
-    dtype: type[DTypeScalar_co], name: str = ""
-) -> SignalRW[Array1D[DTypeScalar_co]]:
+def float_array_value(dtype: type[DTypeScalar_co]) -> Array1D[DTypeScalar_co]:
     finfo = np.finfo(dtype)  # type: ignore
-    value = np.array(
+    return np.array(
         [
             finfo.min,
             finfo.max,
@@ -57,7 +54,55 @@ def float_array_signal(
         ],
         dtype=dtype,
     )
-    return soft_signal_rw(Array1D[dtype], value, name)
+
+
+@dataclass
+class EverythingSignal:
+    name: str
+    dtype: type[SignalDatatype]
+    initial_value: Any = None
+
+
+def get_every_signal_data():
+    # list containing necessary info to construct a signal of each type for multiple
+    # transports e.g. soft/epics/tango
+    return [
+        EverythingSignal("int", int, 1),
+        EverythingSignal("float", float, 1.234),
+        EverythingSignal("str", str, "test_string"),
+        EverythingSignal("bool", bool, True),
+        EverythingSignal("enum", ExampleEnum, ExampleEnum.B),
+        EverythingSignal("int8a", Array1D[np.int8], int_array_value(np.int8)),
+        EverythingSignal("uint8a", Array1D[np.uint8], int_array_value(np.uint8)),
+        EverythingSignal("int16a", Array1D[np.int16], int_array_value(np.int16)),
+        EverythingSignal("uint16a", Array1D[np.uint16], int_array_value(np.uint16)),
+        EverythingSignal("int32a", Array1D[np.int32], int_array_value(np.int32)),
+        EverythingSignal("uint32a", Array1D[np.uint32], int_array_value(np.uint32)),
+        EverythingSignal("int64a", Array1D[np.int64], int_array_value(np.int64)),
+        EverythingSignal("uint64a", Array1D[np.uint64], int_array_value(np.uint64)),
+        EverythingSignal(
+            "float32a", Array1D[np.float32], float_array_value(np.float32)
+        ),
+        EverythingSignal(
+            "float64a", Array1D[np.float64], float_array_value(np.float64)
+        ),
+        EverythingSignal("stra", Sequence[str], ["one", "two", "three"]),
+        EverythingSignal(
+            "enuma", Sequence[ExampleEnum], [ExampleEnum.A, ExampleEnum.C]
+        ),
+        EverythingSignal(
+            "table",
+            ExampleTable,
+            ExampleTable(
+                bool=np.array([False, False, True, True], np.bool_),
+                int=np.array([1, 8, -9, 32], np.int32),
+                float=np.array([1.8, 8.2, -6, 32.9887], np.float64),
+                str=["Hello", "World", "Foo", "Bar"],
+                enum=[ExampleEnum.A, ExampleEnum.B, ExampleEnum.A, ExampleEnum.C],
+            ),
+        ),
+        EverythingSignal("ndarray", np.ndarray, np.array(([1, 2, 3], [4, 5, 6]))),
+    ]
 
 
 class OneOfEverythingDevice(StandardReadable):
@@ -65,40 +110,8 @@ class OneOfEverythingDevice(StandardReadable):
     def __init__(self, name=""):
         # add all signals to configuration
         with self.add_children_as_readables(Format.CONFIG_SIGNAL):
-            self.int = soft_signal_rw(int, 1)
-            self.float = soft_signal_rw(float, 1.234)
-            self.str = soft_signal_rw(str, "test_string")
-            self.bool = soft_signal_rw(bool, True)
-            self.enum = soft_signal_rw(ExampleEnum, ExampleEnum.B)
-            self.int8a = int_array_signal(np.int8)
-            self.uint8a = int_array_signal(np.uint8)
-            self.int16a = int_array_signal(np.int16)
-            self.uint16a = int_array_signal(np.uint16)
-            self.int32a = int_array_signal(np.int32)
-            self.uint32a = int_array_signal(np.uint32)
-            self.int64a = int_array_signal(np.int64)
-            self.uint64a = int_array_signal(np.uint64)
-            self.float32a = float_array_signal(np.float32)
-            self.float64a = float_array_signal(np.float64)
-            self.stra = soft_signal_rw(
-                Sequence[str],
-                ["one", "two", "three"],
-            )
-            self.enuma = soft_signal_rw(
-                Sequence[ExampleEnum],
-                [ExampleEnum.A, ExampleEnum.C],
-            )
-            self.table = soft_signal_rw(
-                ExampleTable,
-                ExampleTable(
-                    bool=np.array([False, False, True, True], np.bool_),
-                    int=np.array([1, 8, -9, 32], np.int32),
-                    float=np.array([1.8, 8.2, -6, 32.9887], np.float64),
-                    str=["Hello", "World", "Foo", "Bar"],
-                    enum=[ExampleEnum.A, ExampleEnum.B, ExampleEnum.A, ExampleEnum.C],
-                ),
-            )
-            self.ndarray = soft_signal_rw(np.ndarray, np.array(([1, 2, 3], [4, 5, 6])))
+            for data in get_every_signal_data():
+                setattr(self, data.name, soft_signal_rw(data.dtype, data.initial_value))
         super().__init__(name)
 
 
diff --git a/tests/core/test_soft_signal_backend.py b/tests/core/test_soft_signal_backend.py
index 399631db54..38274e1ee7 100644
--- a/tests/core/test_soft_signal_backend.py
+++ b/tests/core/test_soft_signal_backend.py
@@ -10,12 +10,12 @@
 
 from ophyd_async.core import (
     Array1D,
-    SignalBackend,
     SoftSignalBackend,
     StrictEnum,
     T,
     soft_signal_rw,
 )
+from ophyd_async.testing import MonitorQueue
 
 
 class MyEnum(StrictEnum):
@@ -44,30 +44,6 @@ def waveform_d(value):
     return {"dtype": "array", "shape": [len(value)]}
 
 
-class MonitorQueue:
-    def __init__(self, backend: SignalBackend):
-        self.backend = backend
-        self.updates: asyncio.Queue[Reading] = asyncio.Queue()
-        backend.set_callback(self.updates.put_nowait)
-
-    async def assert_updates(self, expected_value):
-        expected_reading = {
-            "value": expected_value,
-            "timestamp": pytest.approx(time.monotonic(), rel=0.1),
-            "alarm_severity": 0,
-        }
-        reading = await self.updates.get()
-
-        backend_value = await self.backend.get_value()
-        backend_reading = await self.backend.get_reading()
-
-        assert reading["value"] == expected_value == backend_value
-        assert reading == expected_reading == backend_reading
-
-    def close(self):
-        self.backend.set_callback(None)
-
-
 # Can be removed once numpy >=2 is pinned.
 default_int_type = (
     "<i4" if os.name == "nt" and np.version.version.startswith("1.") else "<i8"
@@ -81,16 +57,16 @@ def close(self):
         (float, 0.0, 43.5, number_d, "<f8"),
         (str, "", "goodbye", string_d, "|S40"),
         (MyEnum, MyEnum.A, MyEnum.C, enum_d, "|S40"),
-        (Array1D[np.int8], [], [-8, 3, 44], waveform_d, "|i1"),
-        (Array1D[np.uint8], [], [218], waveform_d, "|u1"),
-        (Array1D[np.int16], [], [-855], waveform_d, "<i2"),
-        (Array1D[np.uint16], [], [5666], waveform_d, "<u2"),
-        (Array1D[np.int32], [], [-2], waveform_d, "<i4"),
-        (Array1D[np.uint32], [], [1022233], waveform_d, "<u4"),
-        (Array1D[np.int64], [], [-3], waveform_d, "<i8"),
-        (Array1D[np.uint64], [], [995444], waveform_d, "<u8"),
-        (Array1D[np.float32], [], [1.0], waveform_d, "<f4"),
-        (Array1D[np.float64], [], [0.2], waveform_d, "<f8"),
+        (Array1D[np.int8], np.array([]), np.array([-8, 3, 44]), waveform_d, "|i1"),
+        (Array1D[np.uint8], np.array([]), np.array([218]), waveform_d, "|u1"),
+        (Array1D[np.int16], np.array([]), np.array([-855]), waveform_d, "<i2"),
+        (Array1D[np.uint16], np.array([]), np.array([5666]), waveform_d, "<u2"),
+        (Array1D[np.int32], np.array([]), np.array([-2]), waveform_d, "<i4"),
+        (Array1D[np.uint32], np.array([]), np.array([1022233]), waveform_d, "<u4"),
+        (Array1D[np.int64], np.array([]), np.array([-3]), waveform_d, "<i8"),
+        (Array1D[np.uint64], np.array([]), np.array([995444]), waveform_d, "<u8"),
+        (Array1D[np.float32], np.array([]), np.array([1.0]), waveform_d, "<f4"),
+        (Array1D[np.float64], np.array([]), np.array([0.2]), waveform_d, "<f8"),
         (Sequence[str], [], ["nine", "ten"], waveform_d, "|S40"),
     ],
 )
@@ -101,26 +77,21 @@ async def test_soft_signal_backend_get_put_monitor(
     descriptor: Callable[[Any], dict],
     dtype_numpy: str,
 ):
-    backend = SoftSignalBackend(datatype=datatype)
-
-    await backend.connect(1)
-    q = MonitorQueue(backend)
-    try:
+    signal = soft_signal_rw(datatype, initial_value)
+    await signal.connect()
+    backend = signal._connector.backend
+    with MonitorQueue(signal, timestamp_provider=time.monotonic) as q:
         # Check descriptor
         source = "soft://test"
         # Add expected dtype_numpy to descriptor
         assert dict(
             source=source, **descriptor(initial_value), dtype_numpy=dtype_numpy
         ) == await backend.get_datakey(source)
-        # Check initial value
-        await q.assert_updates(
-            pytest.approx(initial_value) if initial_value != "" else initial_value
-        )
+        await q.assert_updates(initial_value)
+
         # Put to new value and check that
-        await backend.put(put_value, True)
-        await q.assert_updates(pytest.approx(put_value))
-    finally:
-        q.close()
+        await backend.put(put_value, wait=True)
+        await q.assert_updates(put_value)
 
 
 async def test_soft_signal_backend_enum_value_equivalence():
diff --git a/tests/tango/test_tango_one_of_everything.py b/tests/tango/test_tango_one_of_everything.py
new file mode 100644
index 0000000000..8bc7ba1dbf
--- /dev/null
+++ b/tests/tango/test_tango_one_of_everything.py
@@ -0,0 +1,180 @@
+from collections.abc import Sequence
+from enum import IntEnum
+
+import numpy as np
+import pytest
+
+from ophyd_async.tango.core import TangoReadable
+from ophyd_async.testing import (
+    ExampleEnum,
+    assert_value,
+)
+from ophyd_async.testing._one_of_everything import (
+    EverythingSignal,
+    get_every_signal_data,
+)
+from tango import AttrDataFormat, AttrWriteType
+from tango.server import Device, attribute
+from tango.test_context import MultiDeviceTestContext
+
+dtypes = {
+    "int": "DevShort",
+    "float": "DevDouble",
+    "str": "DevString",
+    "bool": "DevBoolean",
+    "enum": "DevEnum",
+    "int8a": "DevShort",
+    "uint8a": "DevUChar",
+    "int16a": "DevShort",
+    "uint16a": "DevUShort",
+    "int32a": "DevLong",
+    "uint32a": "DevULong",
+    "int64a": "DevLong64",
+    "uint64a": "DevULong64",
+    "float32a": "DevFloat",
+    "float64a": "DevDouble",
+    "stra": "DevString",
+    "enuma": "DevEnum",
+    # TODO fix ndarray: have to explicitly provide dtype when defining initial value
+    # "ndarray": "DevLong",
+    "intenum": "DevEnum",
+    "intenuma": "DevEnum",
+}
+
+
+class ExampleIntEnum(IntEnum):
+    # we can't use StrictEnums...
+    ZERO = 0
+    ONE = 1
+    TWO = 2
+
+
+class EverythingTangoDevice(Device):
+    attr_values = {}
+
+    def initialize_dynamic_attributes(self):
+        for data in get_every_signal_data() + [
+            EverythingSignal("intenum", ExampleIntEnum, ExampleIntEnum.ONE),
+            EverythingSignal(
+                "intenuma",
+                Sequence[ExampleIntEnum],
+                [ExampleIntEnum.ONE, ExampleIntEnum.TWO],
+            ),
+        ]:
+            if data.name.endswith("a"):  # array
+                d_format = AttrDataFormat.SPECTRUM
+            else:
+                d_format = AttrDataFormat.SCALAR
+            # TODO: we should have IMAGE types too...
+
+            if data.name not in dtypes:
+                print("skipping", data.name, "for now")
+                continue
+            self.attr_values[data.name] = data.initial_value
+            attr = attribute(
+                name=data.name,
+                dtype=dtypes[data.name],
+                dformat=d_format,
+                access=AttrWriteType.READ_WRITE,
+                fget=self.read,
+                fset=self.write,
+                max_dim_x=100,
+                max_dim_y=2,
+                enum_labels=[member.name for member in ExampleEnum],
+            )
+            self.add_attribute(attr)
+            self.set_change_event(data.name, True, False)
+
+    def read(self, attr):
+        value = self.attr_values[attr.get_name()]
+        attr.set_value(value)  # fails with enums...
+
+    def write(self, attr):
+        new_value = attr.get_write_value()
+        self.attr_values[attr.get_name()] = new_value
+        self.push_change_event(attr.get_name(), new_value)
+
+
+@pytest.fixture(scope="module")  # module level scope doesn't work properly...
+def everything_tango_device():
+    with MultiDeviceTestContext(
+        [
+            {
+                "class": EverythingTangoDevice,
+                "devices": [{"name": "everything/device/1"}],
+            }
+        ],
+        process=True,
+    ) as context:
+        yield context.get_device_access("everything/device/1")
+
+
+_array_vals = {
+    "int8a": np.array([-128, 127, 0, 1, 2, 3, 4], dtype=np.int8),
+    "uint8a": np.array([0, 255, 0, 1, 2, 3, 4], dtype=np.uint8),
+    "int16a": np.array([-32768, 32767, 0, 1, 2, 3, 4], dtype=np.int16),
+    "uint16a": np.array([0, 65535, 0, 1, 2, 3, 4], dtype=np.uint16),
+    "int32a": np.array([-2147483648, 2147483647, 0, 1, 2, 3, 4], dtype=np.int32),
+    "uint32a": np.array([0, 4294967295, 0, 1, 2, 3, 4], dtype=np.uint32),
+    "int64a": np.array(
+        [-9223372036854775808, 9223372036854775807, 0, 1, 2, 3, 4],
+        dtype=np.int64,
+    ),
+    "uint64a": np.array([0, 18446744073709551615, 0, 1, 2, 3, 4], dtype=np.uint64),
+    "float32a": np.array(
+        [
+            -3.4028235e38,
+            3.4028235e38,
+            1.1754944e-38,
+            1.4012985e-45,
+            0.0000000e00,
+            1.2340000e00,
+            2.3400000e05,
+            3.4499999e-06,
+        ],
+        dtype=np.float32,
+    ),
+    "float64a": np.array(
+        [
+            -1.79769313e308,
+            1.79769313e308,
+            2.22507386e-308,
+            4.94065646e-324,
+            0.00000000e000,
+            1.23400000e000,
+            2.34000000e005,
+            3.45000000e-006,
+        ],
+        dtype=np.float64,
+    ),
+}
+
+
+async def test_assert_value_everything_tango(everything_tango_device):
+    one_of_everything_device = TangoReadable(everything_tango_device)
+    await one_of_everything_device.connect()
+    await assert_value(one_of_everything_device.int, 1)
+    await assert_value(one_of_everything_device.float, 1.234)
+    await assert_value(one_of_everything_device.str, "test_string")
+    await assert_value(one_of_everything_device.bool, True)
+    await assert_value(one_of_everything_device.int8a, _array_vals["int8a"])
+    await assert_value(one_of_everything_device.uint8a, _array_vals["uint8a"])
+    await assert_value(one_of_everything_device.int16a, _array_vals["int16a"])
+    await assert_value(one_of_everything_device.uint16a, _array_vals["uint16a"])
+    await assert_value(one_of_everything_device.int32a, _array_vals["int32a"])
+    await assert_value(one_of_everything_device.uint32a, _array_vals["uint32a"])
+    await assert_value(one_of_everything_device.int64a, _array_vals["int64a"])
+    await assert_value(one_of_everything_device.uint64a, _array_vals["uint64a"])
+    await assert_value(one_of_everything_device.float32a, _array_vals["float32a"])
+    await assert_value(one_of_everything_device.float64a, _array_vals["float64a"])
+    await assert_value(one_of_everything_device.stra, ["one", "two", "three"])
+    await assert_value(one_of_everything_device.intenum, ExampleIntEnum.ONE)
+    await assert_value(
+        one_of_everything_device.intenuma, [ExampleIntEnum.ONE, ExampleIntEnum.TWO]
+    )
+
+
+#    await assert_value(
+#        one_of_everything_device.ndarray, np.array(([1, 2, 3], [4, 5, 6]),
+#        dtype=np.int32)
+#    )
diff --git a/tests/tango/test_tango_signals.py b/tests/tango/test_tango_signals.py
index 0ec269527e..5e6d14d012 100644
--- a/tests/tango/test_tango_signals.py
+++ b/tests/tango/test_tango_signals.py
@@ -9,10 +9,9 @@
 import numpy as np
 import numpy.typing as npt
 import pytest
-from bluesky.protocols import Reading
 from test_base_device import TestDevice
 
-from ophyd_async.core import SignalBackend, SignalR, SignalRW, SignalW, SignalX, T
+from ophyd_async.core import SignalR, SignalRW, SignalW, SignalX, T
 from ophyd_async.tango.core import (
     TangoSignalBackend,
     tango_signal_r,
@@ -20,6 +19,7 @@
     tango_signal_w,
     tango_signal_x,
 )
+from ophyd_async.testing import MonitorQueue
 from tango import AttrDataFormat, AttrWriteType, DevState
 from tango.asyncio import DeviceProxy
 from tango.asyncio_executor import set_global_executor
@@ -79,39 +79,52 @@ class AttributeData(Generic[T]):
     # pytango test utils currently fail to handle bool pytest.approx
     if type_name == "boolean":
         continue
-    ATTRIBUTES_SET.extend(
-        [
-            AttributeData(
-                f"{type_name}_scalar_attr",
-                tango_type_name,
-                AttrDataFormat.SCALAR,
-                py_type,
-                choice(values),
-                choice(values),
-            ),
-            AttributeData(
-                f"{type_name}_spectrum_attr",
-                tango_type_name,
-                AttrDataFormat.SPECTRUM,
-                npt.NDArray[py_type],
-                [choice(values), choice(values), choice(values)],
-                [choice(values), choice(values), choice(values)],
-            ),
-            AttributeData(
-                f"{type_name}_image_attr",
-                tango_type_name,
-                AttrDataFormat.IMAGE,
-                npt.NDArray[py_type],
+    ATTRIBUTES_SET.append(
+        AttributeData(
+            f"{type_name}_scalar_attr",
+            tango_type_name,
+            AttrDataFormat.SCALAR,
+            py_type,
+            choice(values),
+            choice(values),
+        )
+    )
+    ATTRIBUTES_SET.append(
+        AttributeData(
+            f"{type_name}_spectrum_attr",
+            tango_type_name,
+            AttrDataFormat.SPECTRUM,
+            npt.NDArray[py_type],
+            [choice(values), choice(values), choice(values)],
+            [choice(values), choice(values), choice(values)],
+        )
+    )
+
+    if type_name in ["state", "enum"]:
+        # TODO: state image and enum images don't currently work with assert_value etc
+        continue
+
+    ATTRIBUTES_SET.append(
+        AttributeData(
+            f"{type_name}_image_attr",
+            tango_type_name,
+            AttrDataFormat.IMAGE,
+            npt.NDArray[py_type],
+            np.array(
                 [
                     [choice(values), choice(values), choice(values)],
                     [choice(values), choice(values), choice(values)],
                 ],
+                dtype=py_type,
+            ),
+            np.array(
                 [
                     [choice(values), choice(values), choice(values)],
                     [choice(values), choice(values), choice(values)],
                 ],
+                dtype=py_type,
             ),
-        ]
+        ),
     )
 
     if tango_type_name == "DevUChar":
@@ -277,33 +290,6 @@ async def prepare_device(echo_device: str, pv: str, put_value: T) -> None:
     setattr(proxy, pv, put_value)
 
 
-# --------------------------------------------------------------------
-class MonitorQueue:
-    def __init__(self, backend: SignalBackend):
-        self.updates: asyncio.Queue[Reading] = asyncio.Queue()
-        self.backend = backend
-        self.subscription = backend.set_callback(self.updates.put_nowait)
-
-    async def assert_updates(self, expected_value):
-        expected_reading = {
-            "timestamp": pytest.approx(time.time(), rel=0.1),
-            "alarm_severity": 0,
-        }
-        update_reading = dict(await asyncio.wait_for(self.updates.get(), timeout=5))
-        update_value = update_reading.pop("value")
-        assert_close(update_value, expected_value)
-        backend_reading = dict(
-            await asyncio.wait_for(self.backend.get_reading(), timeout=5)
-        )
-        backend_reading.pop("value")
-        backend_value = await asyncio.wait_for(self.backend.get_value(), timeout=5)
-        assert_close(backend_value, expected_value)
-        assert update_reading == expected_reading == backend_reading
-
-    def close(self):
-        self.backend.set_callback(None)
-
-
 # --------------------------------------------------------------------
 async def assert_monitor_then_put(
     echo_device: str,
@@ -315,10 +301,11 @@ async def assert_monitor_then_put(
 ):
     await prepare_device(echo_device, pv, initial_value)
     source = echo_device + "/" + pv
-    backend = await make_backend(datatype, source, allow_events=True)
+    signal = tango_signal_rw(datatype, source)
+    backend = signal._connector.backend
+    await signal.connect()
     # Make a monitor queue that will monitor for updates
-    q = MonitorQueue(backend)
-    try:
+    with MonitorQueue(signal) as q:
         assert dict(source=source, **descriptor) == await backend.get_datakey("")
         # Check initial value
         await q.assert_updates(initial_value)
@@ -326,8 +313,6 @@ async def assert_monitor_then_put(
         await backend.put(put_value, wait=True)
         assert_close(put_value, await backend.get_setpoint())
         await q.assert_updates(put_value)
-    finally:
-        q.close()
 
 
 # --------------------------------------------------------------------