Skip to content
Pre-commit hooks

test #605

Sign in to view logs

test

test #605

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

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

108 files  108 suites   2h 35m 39s ⏱️
 28 tests  22 ✅ 0 💤  6 ❌
200 runs  176 ✅ 0 💤 24 ❌

Results for commit ae8feef.

Annotations

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 "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 582 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-19_22-33-03-266413/test_psramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fb320919790>
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 582 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_22-33-03-266413/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 0x7fb31f707a70>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fb31f792900>\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 0x7fb31f792900>
E           searcher: searcher_re:
E               0: re.compile(b'Runs: (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fb31f792900>
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 0x7fb320919790>
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 0x7fb320919790>
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 582 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_22-33-03-266413/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 582 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_22-33-03-266413/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.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-esp32h2-performance/performance/linpack_double/esp32h2/linpack_double.xml [took 49s]
./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_22-36-57-596710/test_linpack_double/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f0ca47b1b20>
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_22-36-57-596710/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 0x7f0ca47b3e30>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f0ca47b22a0>\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 0x7f0ca47b22a0>
E           searcher: searcher_re:
E               0: re.compile(b'Runs completed: (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7f0ca47b22a0>
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 0x7f0ca47b1b20>
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 0x7f0ca47b1b20>
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_22-36-57-596710/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_22-36-57-596710/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.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_22-26-43-228912/test_fibonacci/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f75e65d7d40>
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_22-26-43-228912/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 0x7f75e6414860>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f75e65d6630>\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 0x7f75e65d6630>
E           searcher: searcher_re:
E               0: re.compile(b'Fibonacci\\(N\\): (\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7f75e65d6630>
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 0x7f75e65d7d40>
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 0x7f75e65d7d40>
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_22-26-43-228912/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_22-26-43-228912/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.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_22-45-04-368513/test_superpi/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fdbaedfffb0>
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_22-45-04-368513/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 0x7fdbaed68da0>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fdbaedfe6f0>\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 0x7fdbaedfe6f0>
E           searcher: searcher_re:
E               0: re.compile(b'Time: (\\d+)\\.(\\d+) s')
E           <pytest_embedded.log.PexpectProcess object at 0x7fdbaedfe6f0>
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 0x7fdbaedfffb0>
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 0x7fdbaedfffb0>
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_22-45-04-368513/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_22-45-04-368513/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.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 53s]
./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 4m 2s]
./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_22-40-22-283352/test_ramspeed/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7f2aca5f27e0>
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_22-40-22-283352/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 0x7f2aca230b90>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7f2aca3f2180>\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 0x7f2aca3f2180>
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 0x7f2aca3f2180>
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 0x7f2aca5f27e0>
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 0x7f2aca5f27e0>
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_22-40-22-283352/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_22-40-22-283352/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.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 1823 bytes)
Please check the full log here: /tmp/pytest-embedded/2024-12-19_22-22-38-144698/test_coremark/dut.log
self = <pytest_embedded_wokwi.dut.WokwiDut object at 0x7fc29ce6e330>
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 1823 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_22-22-38-144698/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 0x7fc29ce97a40>
err = TIMEOUT("<pytest_embedded.log.PexpectProcess object at 0x7fc29ce95e20>\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 0x7fc29ce95e20>
E           searcher: searcher_re:
E               0: re.compile(b'CoreMark 1.0 : (\\d+)\\.(\\d+)')
E           <pytest_embedded.log.PexpectProcess object at 0x7fc29ce95e20>
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 0x7fc29ce6e330>
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 0x7fc29ce6e330>
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 1823 bytes)\nPlease check the full log here: /tmp/pytest-embedded/2024-12-19_22-22-38-144698/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 1823 bytes)
E               Please check the full log here: /tmp/pytest-embedded/2024-12-19_22-22-38-144698/test_coremark/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