Skip to content
Compilation Tests

test #578

Sign in to view logs

test

test #578

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

6 fail, 22 pass in 2h 35m 19s

108 files  108 suites   2h 35m 19s ⏱️
 28 tests  22 ✅ 0 💤  6 ❌
200 runs  177 ✅ 0 💤 23 ❌

Results for commit 22bd4f6.

Annotations

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 2s]
./artifacts/tests-results-wokwi-esp32h2-performance/performance/ramspeed/esp32h2/ramspeed.xml [took 4m 2s]
./artifacts/tests-results-wokwi-esp32p4-performance/performance/ramspeed/esp32p4/ramspeed.xml [took 4m 16s]
./artifacts/tests-results-wokwi-esp32s2-performance/performance/ramspeed/esp32s2/ramspeed.xml [took 3m 57s]
./artifacts/tests-results-wokwi-esp32s3-performance/performance/ramspeed/esp32s3/ramspeed.xml [took 3m 38s]
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_03-33-00-580634/test_ramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fcc3cbfec30>
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_03-33-00-580634/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 0x7fcc3c838da0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fcc3c9fa540>\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 0x7fcc3c9fa540>
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 0x7fcc3c9fa540>
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 0x7fcc3cbfec30>
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 0x7fcc3cbfec30>
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_03-33-00-580634/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_03-33-00-580634/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.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 "Runs: (\d+)"
Bytes in current buffer (color code eliminated): Wokwi CLI v0.14.5 (e69493bb8261) Connected to Wokwi Simulation API 1.0.0-20241210-g6ce7df28 Starting simulation... ESP-ROM:esp32s3-20210327 Build:Mar 27 2021 rst:0x1... (total 579 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-19_03-16-09-783394/test_psramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f9099134da0>
pattern = 'Runs: (\\d+)', expect_all = False, not_matching = (), args = ()
kwargs = {'timeout': 60}, patterns = ['Runs: (\\d+)'], res = []
debug_str = 'Not found "Runs: (\\d+)"\nBytes in current buffer (color code eliminated): Wokwi CLI v0.14.5 (e69493bb8261) Connected...al 579 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_03-16-09-783394/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 0x7f909878f140>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f909878ed50>\nsearcher: searcher_re:\n    0: re.compile(b'Runs: (\\\\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 0x7f909878ed50>
E           searcher: searcher_re:
E               0: re.compile(b'Runs: (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7f909878ed50>
E           searcher: searcher_re:
E               0: re.compile(b'Runs: (\\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 0x7f9099134da0>
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)

tests/performance/psramspeed/test_psramspeed.py:14: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f9099134da0>
pattern = 'Runs: (\\d+)', expect_all = False, not_matching = (), args = ()
kwargs = {'timeout': 60}, patterns = ['Runs: (\\d+)'], res = []
debug_str = 'Not found "Runs: (\\d+)"\nBytes in current buffer (color code eliminated): Wokwi CLI v0.14.5 (e69493bb8261) Connected...al 579 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_03-16-09-783394/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 "Runs: (\d+)"
E               Bytes in current buffer (color code eliminated): Wokwi CLI v0.14.5 (e69493bb8261) Connected to Wokwi Simulation API 1.0.0-20241210-g6ce7df28 Starting simulation... ESP-ROM:esp32s3-20210327 Build:Mar 27 2021 rst:0x1... (total 579 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_03-16-09-783394/test_psramspeed/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 1824 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-19_03-05-14-105648/test_coremark/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fb9153e2b40>
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 1824 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_03-05-14-105648/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 0x7fb91541f3e0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fb9154728a0>\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 0x7fb9154728a0>
E           searcher: searcher_re:
E               0: re.compile(b'CoreMark 1.0 : (\\d+)\\.(\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fb9154728a0>
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 0x7fb9153e2b40>
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 0x7fb9153e2b40>
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 1824 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_03-05-14-105648/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 1824 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_03-05-14-105648/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.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 1s]
./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 10s]
./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_03-09-30-825699/test_fibonacci/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f7875133a70>
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_03-09-30-825699/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 0x7f7874ff4d70>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f78751beb70>\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 0x7f78751beb70>
E           searcher: searcher_re:
E               0: re.compile(b'Fibonacci\\(N\\): (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7f78751beb70>
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 0x7f7875133a70>
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 0x7f7875133a70>
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_03-09-30-825699/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_03-09-30-825699/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_double.test_linpack_double

See this annotation in the file changed.

@github-actions github-actions / Test Results

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

./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 4115 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-19_03-17-33-284133/test_linpack_double/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f58e86adf40>
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...15 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_03-17-33-284133/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 0x7f58e7bafdd0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f58e7bae540>\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 0x7f58e7bae540>
E           searcher: searcher_re:
E               0: re.compile(b'Runs completed: (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7f58e7bae540>
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 0x7f58e86adf40>
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 0x7f58e86adf40>
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...15 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_03-17-33-284133/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 4115 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_03-17-33-284133/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.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 0s]
./artifacts/tests-results-wokwi-esp32c6-performance/performance/superpi/esp32c6/superpi.xml [took 5m 1s]
./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_03-36-44-377857/test_superpi/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fbe9b673e60>
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_03-36-44-377857/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 0x7fbe9b4a4200>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fbe9b672630>\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 0x7fbe9b672630>
E           searcher: searcher_re:
E               0: re.compile(b'Time: (\\d+)\\.(\\d+) s')
E           <pytest_embedded.log.PexpectProcess object at 0x7fbe9b672630>
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 0x7fbe9b673e60>
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 0x7fbe9b673e60>
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_03-36-44-377857/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_03-36-44-377857/test_superpi/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