API Reference
pytest-embedded
- class pytest_embedded.app.App(app_path: Optional[str] = None, build_dir: Optional[str] = None, **kwargs)
Bases:
object
Built binary files base class
- app_path
application folder path
- Type:
str
- binary_path
binary folder path
- Type:
str
- class pytest_embedded.dut.Dut(*args, **kwargs)
Bases:
_InjectMixinCls
Device under test (DUT) base class
- pexpect_proc
PexpectProcess instance
- Type:
- logfile
log file path
- Type:
str
- test_case_name
test case name
- Type:
str
- close() None
- expect(pattern, **kwargs) Match
Expect the pattern from the internal buffer. All the arguments will be passed to pexpect.expect().
- Parameters:
pattern – string, or compiled regex, or a list of string and compiled regex.
- Keyword Arguments:
timeout (float) – would raise pexpect.TIMEOUT exception when pattern is not matched after timeout
expect_all (bool) – need to match all specified patterns if this flag is True. Otherwise match any of them could pass
- Returns:
AnyStr or re.Match
AnyStr: if you’re matching pexpect.EOF or pexpect.TIMEOUT to get all the current buffers.
re.Match: if matched given string.
- expect_exact(pattern, **kwargs) Match
Expect the pattern from the internal buffer. All the arguments will be passed to pexpect.expect_exact().
- Parameters:
pattern – string, or a list of string
- Keyword Arguments:
timeout (float) – would raise pexpect.TIMEOUT exception when pattern is not matched after timeout
expect_all (bool) – need to match all specified patterns if this flag is True. Otherwise match any of them could pass
- Returns:
AnyStr or re.Match
AnyStr: if you’re matching pexpect.EOF or pexpect.TIMEOUT to get all the current buffers.
re.Match: if matched given string.
- expect_unity_test_output(remove_asci_escape_code: bool = True, timeout: float = 60, extra_before: Optional[AnyStr] = None) None
Expect a unity test summary block and parse the output into junit report.
Would combine the junit report into the main one if you use
pytest --junitxml
feature.- Parameters:
remove_asci_escape_code – remove asci escape code in the message field. (default: True)
timeout – timeout. (default: 60 seconds)
extra_before – would append before the expected bytes. Use this argument when need to run expect functions between one unity test call.
Note
Would raise AssertionError at the end of the test if any unity test case result is “FAIL”
Would raise TIMEOUT exception at the end of the test if any unity test case execution took longer than timeout value
Warning
All unity test cases record would be missed if the final report block is uncaught.
- property logdir
- run_all_single_board_cases(group: Optional[str] = None, reset: bool = False, timeout: float = 30, run_ignore_cases: bool = False) None
Run all multi_stage cases
- Parameters:
group – test case group
reset – whether to perform a hardware reset before running a case
timeout – timeout. (Default: 30 seconds)
run_ignore_cases – run ignored test cases or not
Warning
requires enable service
idf
- write(s: AnyStr) None
Write to the MessageQueue instance
- class pytest_embedded.log.DuplicateStdoutPopen(msg_queue: MessageQueue, cmd: Union[str, List[str]], meta: Optional[Meta] = None, **kwargs)
Bases:
Popen
Subclass of subprocess.Popen that redirect the output into the MessageQueue instance
- REDIRECT_CLS
alias of
_PopenRedirectProcess
- SOURCE = 'POPEN'
- close()
- terminate()
Terminate the process with SIGTERM
- write(s: AnyStr) None
Write to stdin via stdin.write.
If the input is str, will encode to bytes and add a b’\n’ automatically in the end.
If the input is bytes, will pass this directly.
- Parameters:
s – bytes or str
- class pytest_embedded.log.MessageQueue(maxsize=0, *, ctx)
Bases:
Queue
- flush()
- isatty()
- put(obj, **kwargs)
- write(s: AnyStr)
- class pytest_embedded.log.PexpectProcess(fd, args=None, timeout=30, maxread=2000, searchwindowsize=None, logfile=None, encoding=None, codec_errors='strict', use_poll=False)
Bases:
fdspawn
Use a temp file to gather multiple inputs into one output, and do pexpect.expect() from one place.
- property buffer_debug_str
- read_nonblocking(size: int = 1, timeout: int = -1) bytes
Since we’re using real file stream, here we only raise an EOF error when the file stream has been closed. This could solve the os.read() blocked issue.
- Parameters:
size – Read at most size bytes.
timeout – Wait timeout seconds for file descriptor to be ready to read. When -1 (default), use self.timeout. When 0, poll.
- Returns:
String containing the bytes read
- terminate(force=False)
Close the temporary file stream and itself.
- pytest_embedded.log.live_print_call(*args, msg_queue: Optional[MessageQueue] = None, expect_returncode: int = 0, **kwargs)
live print the subprocess.Popen process
- Parameters:
msg_queue – MessageQueue instance, would redirect to message queue instead of sys.stdout if specified
expect_returncode – expect return code. (Default 0). Would raise exception when return code is different
Note
This function behaves the same as subprocess.call(), it would block your current process.
- class pytest_embedded.unity.JunitMerger(main_junit: Optional[str])
Bases:
object
- SUB_JUNIT_FILENAME = 'dut.xml'
- property junit: ElementTree
- merge(junit_files: List[str])
- class pytest_embedded.unity.TestCase(name: str, result: str, **kwargs)
Bases:
object
- to_xml() Element
- class pytest_embedded.unity.TestSuite(name: Optional[str] = None, **kwargs)
Bases:
object
- add_unity_test_cases(s: AnyStr, additional_attrs: Optional[Dict[str, Any]] = None) None
- dump(path: str) None
- to_xml() Element
- pytest_embedded.unity.escape_dict_value(d: Dict[str, Any]) Dict[str, str]
- pytest_embedded.unity.escape_illegal_xml_chars(s: str) str
- class pytest_embedded.utils.Meta(logdir: str, port_target_cache: Dict[str, str], port_app_cache: Dict[str, str], logfile_extension: str = '.log')
Bases:
object
Meta info for testing, session scope
- drop_port_app_cache(port: str) None
- drop_port_target_cache(port: str) None
- hit_port_target_cache(port: str, target: str) bool
- logdir: str
- logfile_extension: str = '.log'
- port_app_cache: Dict[str, str]
- port_target_cache: Dict[str, str]
- set_port_target_cache(port: str, target: str) None
- exception pytest_embedded.utils.PackageNotInstalledError(service: str)
Bases:
SystemExit
- exception pytest_embedded.utils.RequireServiceError(func_name: str, services: Union[str, List[str]])
Bases:
SystemExit
- exception pytest_embedded.utils.UnknownServiceError(service: str)
Bases:
SystemExit
- exception pytest_embedded.utils.UserHint
Bases:
Warning
- pytest_embedded.utils.find_by_suffix(suffix: str, path: str) List[str]
- pytest_embedded.utils.lazy_load(base_module: module, name_obj_dict: Dict[str, Any], obj_module_dict: Dict[str, str]) Callable[[str], Any]
use __getattr__ in the __init__.py file to lazy load some objects
- Parameters:
base_module (ModuleType) – base package module
name_obj_dict (dict[str, any]) – name, real object dict, used to store real objects, no need to add lazy-load objects
obj_module_dict (dict[str, str]) – dict of object name and module name
- Returns:
__getattr__ function
Example
__getattr__ = lazy_load( importlib.import_module(__name__), { 'IdfApp': IdfApp, 'LinuxDut': LinuxDut, 'LinuxSerial': LinuxSerial, 'CaseTester': CaseTester, }, { 'IdfSerial': '.serial', 'IdfDut': '.dut', }, )
- pytest_embedded.utils.remove_asci_color_code(s: AnyStr) str
- pytest_embedded.utils.to_bytes(bytes_str: AnyStr, ending: Optional[AnyStr] = None) bytes
Turn bytes or str to bytes
- Parameters:
bytes_str – bytes or str
ending – bytes or str, will add to the end of the result. Only works when the bytes_str is str
- Returns:
utf8-encoded bytes
- pytest_embedded.utils.to_list(s: _T) List[_T]
- Parameters:
s – Anything
- Returns:
List (list[_T])
list(s) (List. If s is a tuple or a set.
itself. If s is a list.
[s]. If s is other types.
- pytest_embedded.utils.to_str(bytes_str: AnyStr) str
Turn bytes or str to str
- Parameters:
bytes_str – bytes or str
- Returns:
utf8-decoded string
pytest-embedded-serial
- class pytest_embedded_serial.serial.Serial(msg_queue: MessageQueue, port: Optional[str] = None, port_location: Optional[str] = None, baud: int = 115200, meta: Optional[Meta] = None, **kwargs)
Bases:
object
Custom serial class
- port
port address
- Type:
str
- baud
baud rate
- Type:
int
- proc
process created by serial.serial_for_url()
- Type:
pyserial.Serial
Warning
make sure this Serial.__init__() run the last in MRO, it would create and start the redirect serial process
- DEFAULT_BAUDRATE = 115200
- DEFAULT_PORT_CONFIG = {'baudrate': 115200, 'bytesize': 8, 'parity': 'N', 'rtscts': False, 'stopbits': 1, 'timeout': 0.05, 'xonxoff': False}
- close()
- disable_redirect_thread() bool
kill the redirect thread, and start a new one after got yield back
- Yields:
True if redirect serial thread has been terminated
- occupied_ports: Dict[str, None] = {}
- start_redirect_thread() None
- stop_redirect_thread() bool
pytest-embedded-serial-esp
- class pytest_embedded_serial_esp.serial.EspSerial(pexpect_proc: PexpectProcess, msg_queue: MessageQueue, target: Optional[str] = None, beta_target: Optional[str] = None, port: Optional[str] = None, port_mac: Optional[str] = None, baud: int = 115200, esptool_baud: int = 921600, skip_autoflash: bool = False, erase_all: bool = False, meta: Optional[Meta] = None, **kwargs)
Bases:
Serial
Serial class for ports connected to espressif products
- ESPTOOL_DEFAULT_BAUDRATE = 921600
- erase_flash()
Erase the complete flash
- hard_reset()
Hard reset your espressif device
- use_esptool(no_stub: bool = False)
tell the redirect serial thread to stop reading from the pyserial instance
esptool reuse the pyserial instance and call run_stub()
call to the decorated function, could use self.stub inside the function as the stubbed loader
call hard_reset(), if hard_reset_after is True
tell the redirect serial thread to continue reading from serial
- Parameters:
hard_reset_after – run hard reset after
no_stub – disable launching the flasher stub
- class pytest_embedded_serial_esp.serial.EsptoolArgs(**kwargs)
Bases:
object
fake args object, this is a hack until esptool Python API is improved
pytest-embedded-jtag
- class pytest_embedded_jtag.openocd.OpenOcd(openocd_prog_path: Optional[str] = None, openocd_cli_args: Optional[str] = None, port_offset: int = 0, **kwargs)
Bases:
DuplicateStdoutPopen
Class to communicate to OpenOCD
- GDB_BASE_PORT = 3333
- OPENOCD_DEFAULT_ARGS = '-f board/esp32-wrover-kit-3.3v.cfg'
- OPENOCD_PROG_PATH = 'openocd'
- REDIRECT_CLS = None
- SOURCE = 'OPENOCD'
- TCL_BASE_PORT = 6666
- TELNET_BASE_PORT = 4444
- write(s: AnyStr) str
Write to stdin via stdin.write.
If the input is str, will encode to bytes and add a b’\n’ automatically in the end.
If the input is bytes, will pass this directly.
- Parameters:
s – bytes or str
- class pytest_embedded_jtag.gdb.Gdb(gdb_prog_path: Optional[str] = None, gdb_cli_args: Optional[str] = None, **kwargs)
Bases:
DuplicateStdoutPopen
- GDB_DEFAULT_ARGS = '--quiet'
- GDB_PROG_PATH = 'xtensa-esp32-elf-gdb'
- REDIRECT_CLS = None
- SOURCE = 'GDB'
- write(s: AnyStr, non_blocking: bool = False, timeout: float = 30) Optional[str]
Write to stdin via stdin.write.
If the input is str, will encode to bytes and add a b’\n’ automatically in the end.
If the input is bytes, will pass this directly.
- Parameters:
s – bytes or str
pytest-embedded-idf
- class pytest_embedded_idf.app.FlashFile(offset, file_path, encrypted)
Bases:
tuple
- property encrypted
Alias for field number 2
- property file_path
Alias for field number 1
- property offset
Alias for field number 0
- class pytest_embedded_idf.app.IdfApp(part_tool: Optional[str] = None, **kwargs)
Bases:
App
Idf App class
- elf_file
elf file path
- Type:
str
- flash_args
dict of flasher_args.json
- Type:
dict[str, Any]
- flash_files
list of (offset, file path, encrypted) of files need to be flashed in
- Type:
list[FlashFile]
- flash_settings
dict of flash settings
- Type:
dict[str, Any]
- FLASH_ARGS_FILENAME = 'flash_args'
- FLASH_ARGS_JSON_FILENAME = 'flasher_args.json'
- FLASH_PROJECT_ARGS_FILENAME = 'flash_project_args'
- RISCV32_TARGETS = ['esp32c3', 'esp32h2', 'esp32c2', 'esp32c6']
- XTENSA_TARGETS = ['esp32', 'esp32s2', 'esp32s3']
- get_sha256(filepath: str) Optional[str]
Get the sha256 of the file
- Parameters:
filepath – path to the file
- Returns:
sha256 value appended to app
- property is_riscv32
- property is_xtensa
- property partition_table: Dict[str, Any]
Returns: partition table dict generated by the partition tool
- property parttool_path: str
Returns: Partition tool path
- property sdkconfig: Dict[str, Any]
Returns: dict contains all k-v pairs from the sdkconfig file
- property target: str
Returns: target chip type
- property write_flash_args
Returns: list of flash args
- class pytest_embedded_idf.serial.IdfSerial(app: IdfApp, target: Optional[str] = None, confirm_target_elf_sha256: bool = False, erase_nvs: bool = False, **kwargs)
Bases:
EspSerial
IDF serial Dut class
Auto flash the app while starting test.
- DEFAULT_SHA256_OFFSET = 176
- SUGGEST_FLASH_BAUDRATE = 921600
- dump_flash(partition: Optional[str] = None, address: Optional[str] = None, size: Optional[str] = None, output: Optional[Union[str, TextIO]] = None) Optional[bytes]
Dump the flash bytes into the output file by partition name or by start address and size.
- Parameters:
output – file path or file stream to write to. File stream should be opened with bytes mode.
partition – partition name
address – address that start reading from
size – read size
- Returns:
None if output is str or file stream. bytes if output is None.
- erase_partition(partition_name: str) None
Erase the partition provided
- Parameters:
partition_name – partition name
- esp: esptool.ESPLoader
- flash() None
Flash the app.flash_files to the dut
- is_target_flashed_same_elf() bool
Check if the sha256 values are matched between the flashed target and the self.app.elf_file
- Returns:
True if the sha256 values are matched
- load_ram() None
- read_flash_elf_sha256() bytes
Read the sha256 digest of the flashed elf file
- Returns:
bytes of sha256
- stub: esptool.ESPLoader
- class pytest_embedded_idf.linux.LinuxDut(*args, **kwargs)
Bases:
Dut
Dut class for Linux targets
- serial
LinuxSerial instance
- Type:
- write(data: AnyStr) None
Write to the MessageQueue instance
- class pytest_embedded_idf.linux.LinuxSerial(app: IdfApp, **kwargs)
Bases:
DuplicateStdoutPopen
Linux serial Dut class
- class pytest_embedded_idf.dut.IdfDut(*args, **kwargs)
Bases:
IdfUnityDutMixin
,SerialDut
Dut class for serial ports connect to Espressif boards which are flashed with ESP-IDF apps
- target
target chip type
- Type:
str
- skip_check_coredump
skip check core dumped or not while dut teardown if set to True
- Type:
bool
- COREDUMP_UART_END = b'================= CORE DUMP END ================='
- COREDUMP_UART_REGEX = re.compile(b'================= CORE DUMP START =================(.+?)================= CORE DUMP END =================', re.DOTALL)
- COREDUMP_UART_START = b'================= CORE DUMP START ================='
- PANIC_END = b'ELF file SHA256:'
- PANIC_START = b'register dump:'
- RISCV32_TARGETS = ['esp32c3', 'esp32h2', 'esp32c2', 'esp32c6']
- XTENSA_TARGETS = ['esp32', 'esp32s2', 'esp32s3']
- close() None
- flash_via_jtag()
- property panic_output_decode_script: Optional[str]
Returns: Panic output decode script path
- setup_jtag()
- property toolchain_prefix: str
Returns: Toolchain prefix according to the self.target
- write(data: AnyStr) None
Write to the MessageQueue instance
- class pytest_embedded_idf.unity_tester.CaseTester(dut: Union[IdfDut, List[IdfDut]])
Bases:
object
The Generic tester of all the types
The list of the cases
- Type:
t.List[UnittestMenuCase]
- run_all_cases(reset: bool = False, timeout: int = 90, start_retry: int = 3) None
Run all cases
- Parameters:
reset – whether to perform a hardware reset before running a case
timeout – timeout in second
start_retry (int) – number of retries for a single case when it is failed to start
- run_all_multi_dev_cases(reset: bool = False, timeout: float = 90, start_retry: int = 3) None
Run only multi_device cases
- Parameters:
reset – whether to perform a hardware reset before running a case
timeout – timeout in second
start_retry (int) – number of retries for a single case when it is failed to start
- run_all_multi_stage_cases(reset: bool = False, timeout: int = 90) None
Run all multi_stage cases
- Parameters:
reset – whether do a hardware reset before running the case
timeout – timeout in second
- run_all_normal_cases(reset: bool = False, timeout: int = 90) None
Run all normal cases
- Parameters:
reset – whether do a hardware reset before running the case
timeout – timeout in second
- run_case(case: UnittestMenuCase, reset: bool = False, timeout: int = 90, start_retry: int = 3) None
Run a specific case
- Parameters:
case – the specific case that parsed in test menu
reset – whether to perform a hardware reset before running a case
timeout – timeout in second, setup time excluded
start_retry (int) – number of retries for a single case when it is failed to start
- run_multi_dev_case(case: UnittestMenuCase, reset: bool = False, timeout: float = 90, start_retry: int = 3) None
Run a specific multi_device case
Note
Will skip with a warning if the case type is not multi_device
- Parameters:
case – the specific case that parsed in test menu
reset – whether to perform a hardware reset before running a case
timeout – timeout in second
start_retry (int) – number of retries for a single case when it is failed to start
- run_multi_stage_case(case: UnittestMenuCase, reset: bool = False, timeout: int = 90) None
Run a specific multi_stage case
Notes
Will skip if the case type is not multi_stage
- Parameters:
case – the specific case that parsed in test menu
reset – whether do a hardware reset before running the case
timeout – timeout in second
- run_normal_case(case: UnittestMenuCase, reset: bool = False, timeout: int = 90) None
Run a specific normal case
Notes
Will skip if the case type is not normal
- Parameters:
case – the specific case that parsed in test menu
reset – whether do a hardware reset before running the case
timeout – timeout in second
- class pytest_embedded_idf.unity_tester.IdfUnityDutMixin(*args, **kwargs)
Bases:
object
This mixin class provide ESP-IDF modified unity test framework related functions.
- confirm_write(write_str: Any, *, expect_pattern: Optional[Any] = None, expect_str: Optional[Any] = None, timeout: int = 1, retry_times: int = 3)
- run_all_single_board_cases(group: Optional[str] = None, reset: bool = False, timeout: float = 30, run_ignore_cases: bool = False) None
Run all single board cases, including multi_stage cases, and normal cases
- Parameters:
group – test case group
reset – whether to perform a hardware reset before running a case
timeout – timeout. (Default: 30 seconds)
run_ignore_cases – run ignored test cases or not
- run_single_board_case(name: str, reset: bool = False, timeout: float = 30) None
- class pytest_embedded_idf.unity_tester.MultiDevRunTestManager(duts, case, start_retry, wait_for_menu_timeout, runtest_timeout)
Bases:
object
Manager for control dut generator function
- add_report_to_first_dut(attrs)
- gather()
- static get_merge_data(test_cases_attr: List[Dict]) Dict
- get_processed_report_data(res: List[Any]) List[Dict]
- next_for_all()
- class pytest_embedded_idf.unity_tester.UnittestMenuCase(index: int, name: str, type: str, keywords: List[str], groups: List[str], attributes: Dict[str, Any], subcases: List[Dict[str, Any]])
Bases:
object
Dataclass of esp-idf unit test cases parsed from test menu
- attributes: Dict[str, Any]
Dict of attributes of this case, which is used to describe timeout duration,
- groups: List[str]
List of groups of this case, this is usually the component which this case belongs to.
- index: int
The index of the case, which can be used to run this case.
- property is_ignored
- keywords: List[str]
List of additional keywords of this case. For now, we have disable and ignore.
- name: str
The name of the case.
- subcases: List[Dict[str, Any]]
List of dict of subcases of this case, if this case is a multi_stage or multi_device one.
- type: str
Type of this case, which can be normal multi_stage or multi_device.
pytest-embedded-arduino
- class pytest_embedded_arduino.app.ArduinoApp(**kwargs)
Bases:
App
Arduino App class
- sketch
Sketch name.
- Type:
str
- fqbn
Fully Qualified Board Name.
- Type:
str
- target
ESPxx chip.
- Type:
str
- flash_files
List of (offset, file path, encrypted) of files need to be flashed in.
- Type:
List[Tuple[int, str, str]]
- binary_offsets = {'esp32': [4096, 32768, 65536], 'esp32c3': [0, 32768, 65536], 'esp32c6': [0, 32768, 65536], 'esp32h2': [0, 32768, 65536], 'esp32s2': [4096, 32768, 65536], 'esp32s3': [0, 32768, 65536]}
dict of binaries’ offset.
- flash_settings = {'esp32': {'flash_freq': '80m', 'flash_mode': 'dio', 'flash_size': 'detect'}, 'esp32c3': {'flash_freq': '80m', 'flash_mode': 'dio', 'flash_size': 'detect'}, 'esp32c6': {'flash_freq': '80m', 'flash_mode': 'dio', 'flash_size': 'detect'}, 'esp32h2': {'flash_freq': '48m', 'flash_mode': 'dio', 'flash_size': 'detect'}, 'esp32s2': {'flash_freq': '80m', 'flash_mode': 'dio', 'flash_size': 'detect'}, 'esp32s3': {'flash_freq': '80m', 'flash_mode': 'dio', 'flash_size': 'detect'}}
dict of flash settings
- class pytest_embedded_arduino.serial.ArduinoSerial(app: ArduinoApp, target: Optional[str] = None, **kwargs)
Bases:
EspSerial
Arduino serial Dut class
Auto flash the app while starting test.
- SUGGEST_FLASH_BAUDRATE = 921600
- esp: esptool.ESPLoader
- flash() None
Flash the binary files to the board.
- stub: esptool.ESPLoader
pytest-embedded-qemu
- class pytest_embedded_qemu.app.IdfFlashImageMaker(app: ~pytest_embedded_qemu.app.QemuApp, image_path: str, *, qemu_version: ~packaging.version.Version = <Version('8.0.0')>)
Bases:
object
Create a single image for QEMU based on the IdfApp’s partition table and all the flash files.
- RISCV_FLASH_BIN_SIZES = [(262144, '256KB'), (524288, '512KB'), (1048576, '1MB'), (2097152, '2MB'), (4194304, '4MB'), (8388608, '8MB'), (16777216, '16MB'), (33554432, '32MB'), (67108864, '64MB'), (134217728, '128MB')]
- XTENSA_FLASH_BIN_SIZES = [(2097152, '2MB'), (4194304, '4MB'), (8388608, '8MB'), (16777216, '16MB')]
- make_bin() None
Create a single image file for qemu.
- property qemu_flash_size: str
Get QEMU flash size.
If flash_size is set to keep or detect, the size will be automatically detected. Otherwise, the size will be taken from flash_size settings.
- Returns:
QEMU flash size
Warning
QEMU < 8.0.0 only support 4MB flash image size for xtensa.
- class pytest_embedded_qemu.app.QemuApp(msg_queue: MessageQueue, qemu_image_path: Optional[str] = None, skip_regenerate_image: Optional[bool] = False, encrypt: Optional[bool] = False, keyfile: Optional[str] = None, **kwargs)
Bases:
IdfApp
QEMU App class
- image_path
QEMU flash-able bin path
- Type:
str
- QEMU_VERSION_REGEX = re.compile('QEMU emulator version (\\d+\\.\\d+\\.\\d+)')
- create_image() None
Create the image, if it doesn’t exist.
- property qemu_version: Version
Get QEMU version
- Returns:
QEMU version
- class pytest_embedded_qemu.qemu.Qemu(qemu_image_path: Optional[str] = None, qemu_prog_path: Optional[str] = None, qemu_cli_args: Optional[str] = None, qemu_extra_args: Optional[str] = None, app: Optional[QemuApp] = None, **kwargs)
Bases:
DuplicateStdoutPopen
QEMU class
- QEMU_DEFAULT_ARGS = '-nographic -machine esp32'
- QEMU_DEFAULT_FMT = '-nographic -machine {}'
- QEMU_PROG_FMT = 'qemu-system-{}'
- QEMU_PROG_PATH = 'qemu-system-xtensa'
- QEMU_SERIAL_TCP_FMT = '-serial tcp::{},server,nowait'
- QEMU_STRAP_MODE_FMT = '-global driver=esp32.gpio,property=strap_mode,value={}'
- SOURCE = 'QEMU'
- property qemu_default_args
- property qemu_prog_name