Skip to content
Pre-commit hooks

test #604

Sign in to view logs

test

test #604

GitHub Actions / Test Results failed Dec 19, 2024 in 0s

7 fail, 21 pass in 2h 35m 35s

108 files  108 suites   2h 35m 35s ⏱️
 28 tests  21 ✅ 0 💤  7 ❌
200 runs  174 ✅ 0 💤 26 ❌

Results for commit 42cde02.

Annotations

Check warning on line 0 in performance.fibonacci.test_fibonacci

See this annotation in the file changed.

@github-actions github-actions / Test Results

All 7 runs failed: test_fibonacci (performance.fibonacci.test_fibonacci) 

./artifacts/tests-results-wokwi-esp32-performance/performance/fibonacci/esp32/fibonacci.xml [took 5m 1s]
./artifacts/tests-results-wokwi-esp32c3-performance/performance/fibonacci/esp32c3/fibonacci.xml [took 5m 0s]
./artifacts/tests-results-wokwi-esp32c6-performance/performance/fibonacci/esp32c6/fibonacci.xml [took 5m 0s]
./artifacts/tests-results-wokwi-esp32h2-performance/performance/fibonacci/esp32h2/fibonacci.xml [took 5m 1s]
./artifacts/tests-results-wokwi-esp32p4-performance/performance/fibonacci/esp32p4/fibonacci.xml [took 5m 4s]
./artifacts/tests-results-wokwi-esp32s2-performance/performance/fibonacci/esp32s2/fibonacci.xml [took 14m 14s]
./artifacts/tests-results-wokwi-esp32s3-performance/performance/fibonacci/esp32s3/fibonacci.xml [took 5m 1s]
Raw output 
pexpect.exceptions.TIMEOUT: Not found "Fibonacci\(N\): (\d+)"
Bytes in current buffer (color code eliminated): 
Please check the full log here: /tmp/pytest-embedded/2024-12-19_17-00-19-890157/test_fibonacci/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f435b5660f0>
pattern = 'Fibonacci\\(N\\): (\\d+)', expect_all = False, not_matching = ()
args = (), kwargs = {'timeout': 300}, patterns = ['Fibonacci\\(N\\): (\\d+)']
res = []
debug_str = 'Not found "Fibonacci\\(N\\): (\\d+)"\nBytes in current buffer (color code eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-00-19-890157/test_fibonacci/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 0x7f435b3a8ce0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f435b4fdf10>\nsearcher: searcher_re:\n    0: re.compile(b'Fibonacci\\\\(N\\\\): (\\\\d+)')")

    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 0x7f435b4fdf10>
E           searcher: searcher_re:
E               0: re.compile(b'Fibonacci\\(N\\): (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7f435b4fdf10>
E           searcher: searcher_re:
E               0: re.compile(b'Fibonacci\\(N\\): (\\d+)')

/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 0x7f435b5660f0>
request = <FixtureRequest for <Function test_fibonacci>>

    def test_fibonacci(dut, request):
        LOGGER = logging.getLogger(__name__)
    
        # 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 "N: %d"
        res = dut.expect(r"N: (\d+)", timeout=300)
        fib_n = int(res.group(0).decode("utf-8").split(" ")[1])
        LOGGER.info("Calculating Fibonacci({})".format(fib_n))
        assert fib_n > 0, "Invalid Fibonacci number"
    
        # Calculate Fibonacci results
        expected_result = fib(fib_n)
        LOGGER.info("Expected Fibonacci result: {}".format(expected_result))
    
        list_time = []
    
        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"
    
            # Match "Fibonacci(N): %llu"
>           res = dut.expect(r"Fibonacci\(N\): (\d+)", timeout=300)

tests/performance/fibonacci/test_fibonacci.py:47: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f435b5660f0>
pattern = 'Fibonacci\\(N\\): (\\d+)', expect_all = False, not_matching = ()
args = (), kwargs = {'timeout': 300}, patterns = ['Fibonacci\\(N\\): (\\d+)']
res = []
debug_str = 'Not found "Fibonacci\\(N\\): (\\d+)"\nBytes in current buffer (color code eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-00-19-890157/test_fibonacci/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 "Fibonacci\(N\): (\d+)"
E               Bytes in current buffer (color code eliminated): 
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_17-00-19-890157/test_fibonacci/dut.log

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

Check warning on line 0 in performance.linpack_float.test_linpack_float

See this annotation in the file changed.

@github-actions github-actions / Test Results

1 out of 7 runs failed: test_linpack_float (performance.linpack_float.test_linpack_float) 

./artifacts/tests-results-wokwi-esp32s2-performance/performance/linpack_float/esp32s2/linpack_float.xml [took 9s]
Raw output 
AssertionError: Invalid number of runs completed
assert 1000 == 1
dut = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fcee51565d0>
request = <FixtureRequest for <Function test_linpack_float>>

    def test_linpack_float(dut, request):
        LOGGER = logging.getLogger(__name__)
    
        # 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 "Type: %s"
        res = dut.expect(r"Type: (\w+)", timeout=60)
        data_type = res.group(0).decode("utf-8").split(" ")[1]
        LOGGER.info("Data type: {}".format(data_type))
        assert data_type == "float", "Invalid data type"
    
        # Match "Runs completed: %d"
        res = dut.expect(r"Runs completed: (\d+)", timeout=120)
        runs_completed = int(res.group(0).decode("utf-8").split(" ")[2])
        LOGGER.info("Runs completed: {}".format(runs_completed))
>       assert runs_completed == runs, "Invalid number of runs completed"
E       AssertionError: Invalid number of runs completed
E       assert 1000 == 1

tests/performance/linpack_float/test_linpack_float.py:25: AssertionError

Check warning on line 0 in performance.ramspeed.test_ramspeed

See this annotation in the file changed.

@github-actions github-actions / Test Results

All 7 runs failed: test_ramspeed (performance.ramspeed.test_ramspeed) 

./artifacts/tests-results-wokwi-esp32-performance/performance/ramspeed/esp32/ramspeed.xml [took 3m 33s]
./artifacts/tests-results-wokwi-esp32c3-performance/performance/ramspeed/esp32c3/ramspeed.xml [took 3m 51s]
./artifacts/tests-results-wokwi-esp32c6-performance/performance/ramspeed/esp32c6/ramspeed.xml [took 4m 3s]
./artifacts/tests-results-wokwi-esp32h2-performance/performance/ramspeed/esp32h2/ramspeed.xml [took 4m 3s]
./artifacts/tests-results-wokwi-esp32p4-performance/performance/ramspeed/esp32p4/ramspeed.xml [took 4m 15s]
./artifacts/tests-results-wokwi-esp32s2-performance/performance/ramspeed/esp32s2/ramspeed.xml [took 3m 1s]
./artifacts/tests-results-wokwi-esp32s3-performance/performance/ramspeed/esp32s3/ramspeed.xml [took 3m 37s]
Raw output 
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-19_17-11-25-986339/test_ramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f84e5f3fad0>
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-19_17-11-25-986339/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 0x7f84e5da9820>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f84e5f8ee40>\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 0x7f84e5f8ee40>
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 0x7f84e5f8ee40>
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 0x7f84e5f3fad0>
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 0x7f84e5f3fad0>
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-19_17-11-25-986339/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-19_17-11-25-986339/test_ramspeed/dut.log

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

Check warning on line 0 in performance.superpi.test_superpi

See this annotation in the file changed.

@github-actions github-actions / Test Results

5 out of 7 runs failed: test_superpi (performance.superpi.test_superpi) 

./artifacts/tests-results-wokwi-esp32c3-performance/performance/superpi/esp32c3/superpi.xml [took 5m 1s]
./artifacts/tests-results-wokwi-esp32c6-performance/performance/superpi/esp32c6/superpi.xml [took 5m 0s]
./artifacts/tests-results-wokwi-esp32h2-performance/performance/superpi/esp32h2/superpi.xml [took 5m 1s]
./artifacts/tests-results-wokwi-esp32p4-performance/performance/superpi/esp32p4/superpi.xml [took 5m 4s]
./artifacts/tests-results-wokwi-esp32s3-performance/performance/superpi/esp32s3/superpi.xml [took 12m 16s]
Raw output 
pexpect.exceptions.TIMEOUT: Not found "Time: (\d+)\.(\d+) s"
Bytes in current buffer (color code eliminated): 
Please check the full log here: /tmp/pytest-embedded/2024-12-19_17-27-20-312748/test_superpi/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fc26b9b2270>
pattern = 'Time: (\\d+)\\.(\\d+) s', expect_all = False, not_matching = ()
args = (), kwargs = {'timeout': 300}, patterns = ['Time: (\\d+)\\.(\\d+) s']
res = []
debug_str = 'Not found "Time: (\\d+)\\.(\\d+) s"\nBytes in current buffer (color code eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-27-20-312748/test_superpi/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 0x7fc26a9fc530>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fc26abc6b70>\nsearcher: searcher_re:\n    0: re.compile(b'Time: (\\\\d+)\\\\.(\\\\d+) s')")

    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 0x7fc26abc6b70>
E           searcher: searcher_re:
E               0: re.compile(b'Time: (\\d+)\\.(\\d+) s')
E           <pytest_embedded.log.PexpectProcess object at 0x7fc26abc6b70>
E           searcher: searcher_re:
E               0: re.compile(b'Time: (\\d+)\\.(\\d+) s')

/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 0x7fc26b9b2270>
request = <FixtureRequest for <Function test_superpi>>

    def test_superpi(dut, request):
        LOGGER = logging.getLogger(__name__)
    
        # 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))
    
        # Match "Digits: %d"
        res = dut.expect(r"Digits: (\d+)", timeout=60)
        digits = int(res.group(0).decode("utf-8").split(" ")[1])
        LOGGER.info("Number of decimal digits: {}".format(digits))
    
        list_time = []
    
        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"
    
            # Match "Time: %lu.%03lu s"
>           res = dut.expect(r"Time: (\d+)\.(\d+) s", timeout=300)

tests/performance/superpi/test_superpi.py:29: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fc26b9b2270>
pattern = 'Time: (\\d+)\\.(\\d+) s', expect_all = False, not_matching = ()
args = (), kwargs = {'timeout': 300}, patterns = ['Time: (\\d+)\\.(\\d+) s']
res = []
debug_str = 'Not found "Time: (\\d+)\\.(\\d+) s"\nBytes in current buffer (color code eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-27-20-312748/test_superpi/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 "Time: (\d+)\.(\d+) s"
E               Bytes in current buffer (color code eliminated): 
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_17-27-20-312748/test_superpi/dut.log

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

Check warning on line 0 in performance.linpack_double.test_linpack_double

See this annotation in the file changed.

@github-actions github-actions / Test Results

3 out of 7 runs failed: test_linpack_double (performance.linpack_double.test_linpack_double) 

./artifacts/tests-results-wokwi-esp32-performance/performance/linpack_double/esp32/linpack_double.xml [took 18s]
./artifacts/tests-results-wokwi-esp32c3-performance/performance/linpack_double/esp32c3/linpack_double.xml [took 24s]
./artifacts/tests-results-wokwi-esp32p4-performance/performance/linpack_double/esp32p4/linpack_double.xml [took 2m 4s]
Raw output 
pexpect.exceptions.TIMEOUT: Not found "Runs completed: (\d+)"
Bytes in current buffer (color code eliminated): Run 0 Run 1 Run 2 Run 3 Run 4 Run 5 Run 6 Run 7 Run 8 Run 9 Run 10 Run 11 Run 12 Run 13 Run 14 Run 15 Run 16 Run 17 Run 18 Run 19 Run 20 Run 21 Run 22 Run 23 Run 24 Run 25 Run 26... (total 4107 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-19_17-10-32-466433/test_linpack_double/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fbe51b37320>
pattern = 'Runs completed: (\\d+)', expect_all = False, not_matching = ()
args = (), kwargs = {'timeout': 120}, patterns = ['Runs completed: (\\d+)']
res = []
debug_str = 'Not found "Runs completed: (\\d+)"\nBytes in current buffer (color code eliminated): Run 0 Run 1 Run 2 Run 3 Run 4 Ru...07 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-10-32-466433/test_linpack_double/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 0x7fbe51a2c1a0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fbe51b67d40>\nsearcher: searcher_re:\n    0: re.compile(b'Runs completed: (\\\\d+)')")

    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 0x7fbe51b67d40>
E           searcher: searcher_re:
E               0: re.compile(b'Runs completed: (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fbe51b67d40>
E           searcher: searcher_re:
E               0: re.compile(b'Runs completed: (\\d+)')

/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 0x7fbe51b37320>
request = <FixtureRequest for <Function test_linpack_double>>

    def test_linpack_double(dut, request):
        LOGGER = logging.getLogger(__name__)
    
        # 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 "Type: %s"
        res = dut.expect(r"Type: (\w+)", timeout=60)
        data_type = res.group(0).decode("utf-8").split(" ")[1]
        LOGGER.info("Data type: {}".format(data_type))
        assert data_type == "double", "Invalid data type"
    
        # Match "Runs completed: %d"
>       res = dut.expect(r"Runs completed: (\d+)", timeout=120)

tests/performance/linpack_double/test_linpack_double.py:22: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fbe51b37320>
pattern = 'Runs completed: (\\d+)', expect_all = False, not_matching = ()
args = (), kwargs = {'timeout': 120}, patterns = ['Runs completed: (\\d+)']
res = []
debug_str = 'Not found "Runs completed: (\\d+)"\nBytes in current buffer (color code eliminated): Run 0 Run 1 Run 2 Run 3 Run 4 Ru...07 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-10-32-466433/test_linpack_double/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 "Runs completed: (\d+)"
E               Bytes in current buffer (color code eliminated): Run 0 Run 1 Run 2 Run 3 Run 4 Run 5 Run 6 Run 7 Run 8 Run 9 Run 10 Run 11 Run 12 Run 13 Run 14 Run 15 Run 16 Run 17 Run 18 Run 19 Run 20 Run 21 Run 22 Run 23 Run 24 Run 25 Run 26... (total 4107 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_17-10-32-466433/test_linpack_double/dut.log

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

Check warning on line 0 in performance.coremark.test_coremark

See this annotation in the file changed.

@github-actions github-actions / Test Results

1 out of 7 runs failed: test_coremark (performance.coremark.test_coremark) 

./artifacts/tests-results-wokwi-esp32p4-performance/performance/coremark/esp32p4/coremark.xml [took 2m 4s]
Raw output 
pexpect.exceptions.TIMEOUT: Not found "CoreMark 1.0 : (\d+)\.(\d+)"
Bytes in current buffer (color code eliminated): 2K performance run parameters for coremark. CoreMark Size : 666 Total ticks : 1785 Total time (secs): 1.78 Iterations/Sec : 33.61 ERROR! Must execute for at least 10 secs for a... (total 1820 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-19_16-56-13-459366/test_coremark/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fae63a943e0>
pattern = 'CoreMark 1.0 : (\\d+)\\.(\\d+)', expect_all = False
not_matching = (), args = (), kwargs = {'timeout': 120}
patterns = ['CoreMark 1.0 : (\\d+)\\.(\\d+)'], res = []
debug_str = 'Not found "CoreMark 1.0 : (\\d+)\\.(\\d+)"\nBytes in current buffer (color code eliminated): 2K performance run param...tal 1820 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_16-56-13-459366/test_coremark/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 0x7fae638c8260>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fae63a96720>\nsearcher: searcher_re:\n    0: re.compile(b'CoreMark 1.0 : (\\\\d+)\\\\.(\\\\d+)')")

    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 0x7fae63a96720>
E           searcher: searcher_re:
E               0: re.compile(b'CoreMark 1.0 : (\\d+)\\.(\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fae63a96720>
E           searcher: searcher_re:
E               0: re.compile(b'CoreMark 1.0 : (\\d+)\\.(\\d+)')

/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 0x7fae63a943e0>
request = <FixtureRequest for <Function test_coremark>>

    def test_coremark(dut, request):
        LOGGER = logging.getLogger(__name__)
    
        # 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 "Cores: %d"
        res = dut.expect(r"Cores: (\d+)", timeout=60)
        cores = int(res.group(0).decode("utf-8").split(" ")[1])
        LOGGER.info("Number of cores: {}".format(cores))
        assert cores > 0, "Invalid number of cores"
    
        total_score = 0
    
        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"
    
            score = 0
            # Match "CoreMark 1.0 : %d"
>           res = dut.expect(r"CoreMark 1.0 : (\d+)\.(\d+)", timeout=120)

tests/performance/coremark/test_coremark.py:32: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fae63a943e0>
pattern = 'CoreMark 1.0 : (\\d+)\\.(\\d+)', expect_all = False
not_matching = (), args = (), kwargs = {'timeout': 120}
patterns = ['CoreMark 1.0 : (\\d+)\\.(\\d+)'], res = []
debug_str = 'Not found "CoreMark 1.0 : (\\d+)\\.(\\d+)"\nBytes in current buffer (color code eliminated): 2K performance run param...tal 1820 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_16-56-13-459366/test_coremark/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 "CoreMark 1.0 : (\d+)\.(\d+)"
E               Bytes in current buffer (color code eliminated): 2K performance run parameters for coremark. CoreMark Size : 666 Total ticks : 1785 Total time (secs): 1.78 Iterations/Sec : 33.61 ERROR! Must execute for at least 10 secs for a... (total 1820 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_16-56-13-459366/test_coremark/dut.log

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

Check warning on line 0 in performance.psramspeed.test_psramspeed

See this annotation in the file changed.

@github-actions github-actions / Test Results

2 out of 4 runs failed: test_psramspeed (performance.psramspeed.test_psramspeed) 

./artifacts/tests-results-wokwi-esp32p4-performance/performance/psramspeed/esp32p4/psramspeed.xml [took 3m 20s]
./artifacts/tests-results-wokwi-esp32s3-performance/performance/psramspeed/esp32s3/psramspeed.xml [took 1m 0s]
Raw output 
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-19_17-16-22-600903/test_psramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f8fefb03c20>
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...eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-16-22-600903/test_psramspeed/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 0x7f8feedc8830>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f8feef68fb0>\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 0x7f8feef68fb0>
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 0x7f8feef68fb0>
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 0x7f8fefb03c20>
request = <FixtureRequest for <Function test_psramspeed>>

    def test_psramspeed(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/psramspeed/test_psramspeed.py:49: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f8fefb03c20>
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...eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_17-16-22-600903/test_psramspeed/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-19_17-16-22-600903/test_psramspeed/dut.log

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

Check notice on line 0 in .github

See this annotation in the file changed.

@github-actions github-actions / Test Results

28 tests found 

There are 28 tests, see "Raw output" for the full list of tests.
Raw output 
auto_baudrate_test
basic_transmission_test
begin_when_running_test
change_baudrate_test
change_cpu_frequency_test
change_pins_test
disabled_uart_calls_test
enabled_uart_calls_test
end_when_stopped_test
performance.coremark.test_coremark ‑ test_coremark
performance.fibonacci.test_fibonacci ‑ test_fibonacci
performance.linpack_double.test_linpack_double ‑ test_linpack_double
performance.linpack_float.test_linpack_float ‑ test_linpack_float
performance.psramspeed.test_psramspeed ‑ test_psramspeed
performance.ramspeed.test_ramspeed ‑ test_ramspeed
performance.superpi.test_superpi ‑ test_superpi
periman_test
resize_buffers_test
test_fail
test_pass
timer_clock_select_test
timer_divider_test
timer_interrupt_test
timer_read_test
validation.democfg.test_democfg ‑ test_cfg
validation.hello_world.test_hello_world ‑ test_hello_world
validation.nvs.test_nvs ‑ test_nvs
validation.wifi.test_wifi ‑ test_wifi
View more details on GitHub Actions