speed up test_comm.py and test_nxscope.py

Signed-off-by: raiden00pl <raiden00@railab.me>

Author: raiden00pl

src/nxslib/comm.py

@@ -44,15 +44,26 @@ class DCommChannelsData:
 class CommHandler:
     """A class implementing the Nxslib communication glue logic."""
 
-    def __init__(self, intf: "ICommInterface", parse: ICommParse):
+    def __init__(
+        self,
+        intf: "ICommInterface",
+        parse: ICommParse,
+        drop_timeout: float = 0.1,
+        stream_data_timeout: float = 1.0,
+    ):
         """Initialize communication glue logic.
 
         :param intf: instance of a communication interface
         :param parse: instance of a parser class
+        :param drop_timeout: timeout used in _drop_all_frames queue drains
+        :param stream_data_timeout: timeout used in stream_data() frame wait
         """
         # started flag
         self._started = False
 
+        self._drop_timeout = drop_timeout
+        self._stream_data_timeout = stream_data_timeout
+
         self._thrd = ThreadCommon(self._recv_thread, name="recv")
 
         self._intf = intf
@@ -198,12 +209,12 @@ def _read_frame(self) -> DParseFrame | None:
     def _drop_all_frames(self) -> None:
         cntr = 4
         while cntr > 0:
-            ret = self._get_frame(timeout=0.1)
+            ret = self._get_frame(timeout=self._drop_timeout)
             if not ret:  # pragma: no cover
                 cntr -= 1
         cntr = 4
         while cntr > 0:
-            ret = self._get_stream_frame(timeout=0.1)
+            ret = self._get_stream_frame(timeout=self._drop_timeout)
             if not ret:  # pragma: no cover
                 cntr -= 1
 
@@ -466,7 +477,7 @@ def stream_data(self) -> DParseStream | None:
         assert self.dev
 
         # separate queue for stream frames
-        frame = self._get_stream_frame()
+        frame = self._get_stream_frame(timeout=self._stream_data_timeout)
         if not frame:
             return None
 

src/nxslib/intf/dummy.py

@@ -292,6 +292,7 @@ def __init__(
         rxpadding: int = 16,
         stream_sleep: float = 0.001,
         stream_snum: int = 100,
+        thread_timeout: float = 1.0,
     ) -> None:
         """Intitialize a dummy NxScope interface.
 
@@ -301,6 +302,7 @@ def __init__(
         :param rxpadding: rxpadding - doesn't matter here
         :param stream_sleep: samples thread parameter
         :param stream_snum: samples thread parameter
+        :param thread_timeout: timeout for blocking thread operations
         """
         super().__init__()
         self._thrd_stream = ThreadCommon(
@@ -318,6 +320,7 @@ def __init__(
         self._dummydev_lock = Lock()
         self._stream_sleep = stream_sleep
         self._stream_snum = stream_snum
+        self._thread_timeout = thread_timeout
         self._qwrite: queue.Queue[bytes] = queue.Queue()
         self._qread: queue.Queue[bytes] = queue.Queue()
 
@@ -428,7 +431,7 @@ def _stream_data_get(self, snum: int) -> list[DParseStreamData]:
 
     def _thread_stream(self) -> None:
         assert self._parse
-        if self._stream_started.wait(timeout=1.0):
+        if self._stream_started.wait(timeout=self._thread_timeout):
             samples = self._stream_data_get(self._stream_snum)
             frame = self._parse.frame_stream_encode(samples)
             if frame is not None:  # pragma: no cover
@@ -442,7 +445,7 @@ def _thread_recv(self) -> None:
         try:
             # NOTE: timeout must be not zero otherwise we have
             #       deadlock when thread stop is requested
-            data = self._qwrite.get(block=True, timeout=1.0)
+            data = self._qwrite.get(block=True, timeout=self._thread_timeout)
         except queue.Empty:
             pass
 
@@ -498,7 +501,7 @@ def _read(self) -> bytes:
         """Interface specific read method."""
         data = b""
         try:
-            data = self._qread.get(block=True, timeout=1)
+            data = self._qread.get(block=True, timeout=self._thread_timeout)
         except queue.Empty:
             pass
 

src/nxslib/nxscope.py

@@ -152,16 +152,25 @@ def __init__(
         intf: "ICommInterface",
         parse: "ICommParse",
         enable_bitrate_tracking: bool = False,
+        drop_timeout: float = 0.1,
+        stream_data_timeout: float = 1.0,
     ) -> None:
         """Initialize the Nxslib handler.
 
         :param intf: Communication interface
         :param parse: Protocol parser
         :param enable_bitrate_tracking: Enable bitrate tracking
             (default: False)
+        :param drop_timeout: timeout used in _drop_all_frames queue drains
+        :param stream_data_timeout: timeout used in stream_data() frame wait
         """
         self._connected: bool = False
-        self._comm = CommHandler(intf, parse)
+        self._comm = CommHandler(
+            intf,
+            parse,
+            drop_timeout=drop_timeout,
+            stream_data_timeout=stream_data_timeout,
+        )
 
         self._thrd = ThreadCommon(self._stream_thread, name="stream")
 

tests/test_comm.py

@@ -8,18 +8,18 @@
 
 
 def test_nxslib_init():
-    i = DummyDev()
+    i = DummyDev(thread_timeout=0.05)
     p = Parser()
 
-    comm = CommHandler(i, p)
+    comm = CommHandler(i, p, drop_timeout=0.01, stream_data_timeout=0.05)
     assert isinstance(comm, CommHandler)
 
 
 @pytest.fixture
 def comm():
-    i = DummyDev()
+    i = DummyDev(thread_timeout=0.05)
     p = Parser()
-    return CommHandler(i, p)
+    return CommHandler(i, p, drop_timeout=0.01, stream_data_timeout=0.05)
 
 
 def test_nxslib_connect(comm):
@@ -326,9 +326,9 @@ def test_nxslib_stream_ch8(comm):
 
 
 def test_nxslib_nodiv(comm):
-    i = DummyDev(flags=EDeviceFlags.ACK_SUPPORT.value)
+    i = DummyDev(flags=EDeviceFlags.ACK_SUPPORT.value, thread_timeout=0.05)
     p = Parser()
-    comm = CommHandler(i, p)
+    comm = CommHandler(i, p, drop_timeout=0.01, stream_data_timeout=0.05)
 
     # connect
     comm.connect()
@@ -348,9 +348,9 @@ def test_nxslib_nodiv(comm):
 
 
 def test_nxslib_noack(comm):
-    i = DummyDev(flags=EDeviceFlags.DIVIDER_SUPPORT.value)
+    i = DummyDev(flags=EDeviceFlags.DIVIDER_SUPPORT.value, thread_timeout=0.05)
     p = Parser()
-    comm = CommHandler(i, p)
+    comm = CommHandler(i, p, drop_timeout=0.01, stream_data_timeout=0.05)
 
     # connect
     comm.connect()
@@ -371,9 +371,9 @@ def test_nxslib_noack(comm):
 
 def test_comm_get_enabled_channels():
     """Test get_enabled_channels method."""
-    i = DummyDev()
+    i = DummyDev(thread_timeout=0.05)
     p = Parser()
-    comm = CommHandler(i, p)
+    comm = CommHandler(i, p, drop_timeout=0.01, stream_data_timeout=0.05)
 
     # connect
     comm.connect()