Skip to content
Compilation Tests

test #578

Sign in to view logs

test

test #578

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

7 fail, 21 pass in 2h 33m 44s

108 files  108 suites   2h 33m 44s ⏱️
 28 tests  21 ✅ 0 💤  7 ❌
200 runs  175 ✅ 0 💤 25 ❌

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 34s]
./artifacts/tests-results-wokwi-esp32c3-performance/performance/ramspeed/esp32c3/ramspeed.xml [took 3m 52s]
./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 15s]
./artifacts/tests-results-wokwi-esp32s2-performance/performance/ramspeed/esp32s2/ramspeed.xml [took 3m 56s]
./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-18_20-06-02-653042/test_ramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f2b7bd56fc0>
pattern = '((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)'
expect_all = False, not_matching = (), args = (), kwargs = {'timeout': 90}
patterns = ['((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)']
res = []
debug_str = 'Not found "((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)"\nBytes in current buffer...e eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_20-06-02-653042/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 0x7f2b7b8d12e0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f2b7ba96900>\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 0x7f2b7ba96900>
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 0x7f2b7ba96900>
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 0x7f2b7bd56fc0>
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 0x7f2b7bd56fc0>
pattern = '((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)'
expect_all = False, not_matching = (), args = (), kwargs = {'timeout': 90}
patterns = ['((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)']
res = []
debug_str = 'Not found "((System|Mock) (memcpy|memset)\\(\\): Rate = (\\d+) KB/s Time: (\\d+) ms|^Error)"\nBytes in current buffer...e eliminated): \nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_20-06-02-653042/test_ramspeed/dut.log'

    @functools.wraps(func)
    def wrapper(
        self, pattern, *args, expect_all: bool = False, not_matching: List[Union[str, re.Pattern]] = (), **kwargs
    ) -> Union[Union[Match, AnyStr], List[Union[Match, AnyStr]]]:
        patterns = to_list(pattern)
        res = []
        while patterns:
            try:
                index = func(self, pattern, *args, **kwargs)
            except (pexpect.EOF, pexpect.TIMEOUT) as e:
                debug_str = (
                    f'Not found "{pattern!s}"\n'
                    f'Bytes in current buffer (color code eliminated): {self.pexpect_proc.buffer_debug_str}\n'
                    f'Please check the full log here: {self.logfile}'
                )
>               raise e.__class__(debug_str) from e
E               pexpect.exceptions.TIMEOUT: Not found "((System|Mock) (memcpy|memset)\(\): Rate = (\d+) KB/s Time: (\d+) ms|^Error)"
E               Bytes in current buffer (color code eliminated): 
E               Please check the full log here: /tmp/pytest-embedded/2024-12-18_20-06-02-653042/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.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-esp32c3-performance/performance/linpack_float/esp32c3/linpack_float.xml [took 16s]
Raw output 
AssertionError: Invalid number of runs completed
assert 1000 == 100
dut = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f1fad69f2f0>
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 == 100

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

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 15s]
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-18_20-16-17-998164/test_superpi/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f1ebd0a1df0>
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-18_20-16-17-998164/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 0x7f1ebd00f2f0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f1ebd0a2570>\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 0x7f1ebd0a2570>
E           searcher: searcher_re:
E               0: re.compile(b'Time: (\\d+)\\.(\\d+) s')
E           <pytest_embedded.log.PexpectProcess object at 0x7f1ebd0a2570>
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 0x7f1ebd0a1df0>
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 0x7f1ebd0a1df0>
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-18_20-16-17-998164/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-18_20-16-17-998164/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.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 1817 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-18_19-51-53-987753/test_coremark/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fdc388317c0>
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 1817 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_19-51-53-987753/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 0x7fdc38857f80>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fdc387c74d0>\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 0x7fdc387c74d0>
E           searcher: searcher_re:
E               0: re.compile(b'CoreMark 1.0 : (\\d+)\\.(\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fdc387c74d0>
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 0x7fdc388317c0>
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 0x7fdc388317c0>
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 1817 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_19-51-53-987753/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 1817 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-18_19-51-53-987753/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.linpack_double.test_linpack_double

See this annotation in the file changed.

@github-actions github-actions / Test Results

2 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 4s]
./artifacts/tests-results-wokwi-esp32s2-performance/performance/linpack_double/esp32s2/linpack_double.xml [took 11s]
Raw output 
AssertionError: Invalid data type
assert 'doub' == 'double'
  
  - double
  ?     --
  + doub
dut = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fb6e2633680>
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"
E       AssertionError: Invalid data type
E       assert 'doub' == 'double'
E         
E         - double
E         ?     --
E         + doub

tests/performance/linpack_double/test_linpack_double.py:19: AssertionError

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 11s]
./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): Timeout: simulation did not finish in 600000ms
Please check the full log here: /tmp/pytest-embedded/2024-12-18_20-05-03-702482/test_fibonacci/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fd0fcb5b440>
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): Timeout: simulation did not finish in 600000ms\nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_20-05-03-702482/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 0x7fd0fc9e0860>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fd0fcb1fd40>\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 0x7fd0fcb1fd40>
E           searcher: searcher_re:
E               0: re.compile(b'Fibonacci\\(N\\): (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fd0fcb1fd40>
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 0x7fd0fcb5b440>
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 0x7fd0fcb5b440>
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): Timeout: simulation did not finish in 600000ms\nPlease check the full log here: /tmp/pytest-embedded/2024-12-18_20-05-03-702482/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): Timeout: simulation did not finish in 600000ms
E               Please check the full log here: /tmp/pytest-embedded/2024-12-18_20-05-03-702482/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.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 19s]
./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-18_20-10-03-217466/test_psramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fd029b52a80>
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-18_20-10-03-217466/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 0x7fd029b6cad0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fd029b52f30>\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 0x7fd029b52f30>
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 0x7fd029b52f30>
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 0x7fd029b52a80>
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 0x7fd029b52a80>
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-18_20-10-03-217466/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-18_20-10-03-217466/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