pexpect.exceptions.TIMEOUT: Not found "((System|Mock) (memcpy|memset)\(\): Rate = (\d+) KB/s Time: (\d+) ms|^Error)"
Bytes in current buffer (color code eliminated): 
Please check the full log here: /tmp/pytest-embedded/2024-12-18_19-31-23-109994/test_ramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fb68c6a27e0>
pattern = '((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)'
expect_all = False, not_matching = (), args = (), kwargs = {'timeout': 90}
patterns = ['((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)']
res = []
debug_str = 'Not found "((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)"\nBytes in current buffer...e eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_19-31-23-109994/test_ramspeed/dut.log'

    @functools.wraps(func)
    def wrapper(
        self, pattern, *args, expect_all: bool = False, not_matching: List[Union[str, re.Pattern]] = (), **kwargs
    ) -> Union[Union[Match, AnyStr], List[Union[Match, AnyStr]]]:
        patterns = to_list(pattern)
        res = []
        while patterns:
            try:
>               index = func(self, pattern, *args, **kwargs)

/opt/hostedtoolcache/Python/3.12.8/x64/lib/python3.12/site-packages/pytest_embedded/dut.py:76: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.12.8/x64/lib/python3.12/site-packages/pytest_embedded/dut.py:131: in expect
    return self.pexpect_proc.expect(pattern, **kwargs)
/opt/hostedtoolcache/Python/3.12.8/x64/lib/python3.12/site-packages/pexpect/spawnbase.py:354: in expect
    return self.expect_list(compiled_pattern_list,
/opt/hostedtoolcache/Python/3.12.8/x64/lib/python3.12/site-packages/pexpect/spawnbase.py:383: in expect_list
    return exp.expect_loop(timeout)
/opt/hostedtoolcache/Python/3.12.8/x64/lib/python3.12/site-packages/pexpect/expect.py:181: in expect_loop
    return self.timeout(e)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pexpect.expect.Expecter object at 0x7fb68c2dcce0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fb68c49e4e0>\nsearcher: searcher_re:\n    0: re.compile(b'((System|Mock) (memcpy|memset)\\\\(\\\\): Rate = (\\\\d+) KB/s Time: (\\\\d+) ms|^Error)')")

    def timeout(self, err=None):
        spawn = self.spawn
    
        spawn.before = spawn._before.getvalue()
        spawn.after = TIMEOUT
        index = self.searcher.timeout_index
        if index >= 0:
            spawn.match = TIMEOUT
            spawn.match_index = index
            return index
        else:
            spawn.match = None
            spawn.match_index = None
            msg = str(spawn)
            msg += '\nsearcher: %s' % self.searcher
            if err is not None:
                msg = str(err) + '\n' + msg
    
            exc = TIMEOUT(msg)
            exc.__cause__ = None    # in Python 3.x we can use "raise exc from None"
>           raise exc
E           pexpect.exceptions.TIMEOUT: <pytest_embedded.log.PexpectProcess object at 0x7fb68c49e4e0>
E           searcher: searcher_re:
E               0: re.compile(b'((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fb68c49e4e0>
E           searcher: searcher_re:
E               0: re.compile(b'((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)')

/opt/hostedtoolcache/Python/3.12.8/x64/lib/python3.12/site-packages/pexpect/expect.py:144: TIMEOUT

The above exception was the direct cause of the following exception:

dut = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fb68c6a27e0>
request = <FixtureRequest for <Function test_ramspeed>>

    def test_ramspeed(dut, request):
        LOGGER = logging.getLogger(__name__)
    
        runs_results = []
    
        # Match "Runs: %d"
        res = dut.expect(r"Runs: (\d+)", timeout=60)
        runs = int(res.group(0).decode("utf-8").split(" ")[1])
        LOGGER.info("Number of runs: {}".format(runs))
        assert runs > 0, "Invalid number of runs"
    
        # Match "Copies: %d"
        res = dut.expect(r"Copies: (\d+)", timeout=60)
        copies = int(res.group(0).decode("utf-8").split(" ")[1])
        LOGGER.info("Number of copies in each test: {}".format(copies))
        assert copies > 0, "Invalid number of copies"
    
        # Match "Max test size: %lu"
        res = dut.expect(r"Max test size: (\d+)", timeout=60)
        max_test_size = int(res.group(0).decode("utf-8").split(" ")[3])
        LOGGER.info("Max test size: {}".format(max_test_size))
        assert max_test_size > 0, "Invalid max test size"
    
        for i in range(runs):
            # Match "Run %d"
            res = dut.expect(r"Run (\d+)", timeout=120)
            run = int(res.group(0).decode("utf-8").split(" ")[1])
            LOGGER.info("Run {}".format(run))
            assert run == i, "Invalid run number"
    
            for j in range(2):
                while True:
                    # Match "Memcpy/Memtest %d Bytes test"
                    res = dut.expect(r"(Memcpy|Memset) (\d+) Bytes test", timeout=60)
                    current_test = res.group(0).decode("utf-8").split(" ")[0].lower()
                    current_test_size = int(res.group(0).decode("utf-8").split(" ")[1])
                    LOGGER.info("Current {} test size: {}".format(current_test, current_test_size))
                    assert current_test_size > 0, "Invalid test size"
    
                    for k in range(2):
                        # Match "System/Mock memcpy/memtest(): Rate = %d KB/s Time: %d ms" or "Error: %s"
>                       res = dut.expect(
                            r"((System|Mock) (memcpy|memset)\(\): Rate = (\d+) KB/s Time: (\d+) ms|^Error)", timeout=90
                        )

tests/performance/ramspeed/test_ramspeed.py:49: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fb68c6a27e0>
pattern = '((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)'
expect_all = False, not_matching = (), args = (), kwargs = {'timeout': 90}
patterns = ['((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)']
res = []
debug_str = 'Not found "((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)"\nBytes in current buffer...e eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_19-31-23-109994/test_ramspeed/dut.log'

    @functools.wraps(func)
    def wrapper(
        self, pattern, *args, expect_all: bool = False, not_matching: List[Union[str, re.Pattern]] = (), **kwargs
    ) -> Union[Union[Match, AnyStr], List[Union[Match, AnyStr]]]:
        patterns = to_list(pattern)
        res = []
        while patterns:
            try:
                index = func(self, pattern, *args, **kwargs)
            except (pexpect.EOF, pexpect.TIMEOUT) as e:
                debug_str = (
                    f'Not found "{pattern!s}"\n'
                    f'Bytes in current buffer (color code eliminated): {self.pexpect_proc.buffer_debug_str}\n'
                    f'Please check the full log here: {self.logfile}'
                )
>               raise e.__class__(debug_str) from e
E               pexpect.exceptions.TIMEOUT: Not found "((System|Mock) (memcpy|memset)\(\): Rate = (\d+) KB/s Time: (\d+) ms|^Error)"
E               Bytes in current buffer (color code eliminated): 
E               Please check the full log here: /tmp/pytest-embedded/2024-12-18_19-31-23-109994/test_ramspeed/dut.log

/opt/hostedtoolcache/Python/3.12.8/x64/lib/python3.12/site-packages/pytest_embedded/dut.py:83: TIMEOUT